express-zod-api 9.2.1 → 10.0.0-beta2

package/dist/index.d.ts

@@ -1,21 +1,776 @@
-export { createConfig, LoggerConfig } from "./config-type";
-export { AbstractEndpoint } from "./endpoint";
-export { Method } from "./method";
-export { EndpointsFactory, defaultEndpointsFactory } from "./endpoints-factory";
-export { IOSchema } from "./io-schema";
-export { FlatObject, getMessageFromError, getStatusCodeFromError, } from "./common-helpers";
-export { createLogger } from "./logger";
-export { createMiddleware } from "./middleware";
-export { createResultHandler, defaultResultHandler } from "./result-handler";
-export { DependsOnMethod } from "./depends-on-method";
-export { ServeStatic } from "./serve-static";
-export { Routing } from "./routing";
-export { createServer, attachRouting } from "./server";
-export { OpenAPI } from "./open-api";
-export { OpenAPIError, DependsOnMethodError, RoutingError, OutputValidationError, InputValidationError, } from "./errors";
-export { withMeta } from "./metadata";
-export { testEndpoint } from "./mock";
-export { Client } from "./client";
-import * as z from "./extend-zod";
-import createHttpError from "http-errors";
-export { createHttpError, z };
+import compression from 'compression';
+import { NextHandleFunction } from 'connect';
+import express, { Request, Response, Express } from 'express';
+import fileUpload, { UploadedFile } from 'express-fileupload';
+import https, { ServerOptions } from 'https';
+import winston, { Logger } from 'winston';
+import { z, ZodError, ZodType, ParseInput, ParseReturnType, ZodTypeDef } from 'zod';
+import { HttpError } from 'http-errors';
+export { default as createHttpError } from 'http-errors';
+import * as qs from 'qs';
+import * as express_serve_static_core from 'express-serve-static-core';
+import * as http from 'http';
+import { OpenApiBuilder, SecuritySchemeType, SecuritySchemeObject } from 'openapi3-ts';
+import ts from 'typescript';
+
+type LogicalOr<T> = {
+    or: T[];
+};
+type LogicalAnd<T> = {
+    and: T[];
+};
+type LogicalContainer<T> = LogicalOr<T | LogicalAnd<T>> | LogicalAnd<T | LogicalOr<T>> | T;
+
+interface BasicSecurity {
+    type: "basic";
+}
+interface BearerSecurity {
+    type: "bearer";
+    format?: "JWT" | string;
+}
+interface InputSecurity<K extends string> {
+    type: "input";
+    name: K;
+}
+interface CustomHeaderSecurity {
+    type: "header";
+    name: string;
+}
+interface CookieSecurity {
+    type: "cookie";
+    name: string;
+}
+/**
+ * @see https://swagger.io/docs/specification/authentication/openid-connect-discovery/
+ * @desc available scopes has to be provided via the specified URL
+ */
+interface OpenIdSecurity {
+    type: "openid";
+    url: string;
+}
+interface AuthUrl {
+    /**
+     * @desc The authorization URL to use for this flow. Can be relative to the API server URL.
+     * @see https://swagger.io/docs/specification/api-host-and-base-path/
+     */
+    authorizationUrl: string;
+}
+interface TokenUrl {
+    /** @desc The token URL to use for this flow. Can be relative to the API server URL. */
+    tokenUrl: string;
+}
+interface RefreshUrl {
+    /** @desc The URL to be used for obtaining refresh tokens. Can be relative to the API server URL. */
+    refreshUrl?: string;
+}
+interface Scopes<K extends string> {
+    /** @desc The available scopes for the OAuth2 security and their short descriptions. Optional. */
+    scopes?: Record<K, string>;
+}
+type AuthCodeFlow<S extends string> = AuthUrl & TokenUrl & RefreshUrl & Scopes<S>;
+type ImplicitFlow<S extends string> = AuthUrl & RefreshUrl & Scopes<S>;
+type PasswordFlow<S extends string> = TokenUrl & RefreshUrl & Scopes<S>;
+type ClientCredFlow<S extends string> = TokenUrl & RefreshUrl & Scopes<S>;
+/**
+ * @see https://swagger.io/docs/specification/authentication/oauth2/
+ */
+interface OAuth2Security<S extends string> {
+    type: "oauth2";
+    flows?: {
+        /** @desc Authorization Code flow (previously called accessCode in OpenAPI 2.0) */
+        authorizationCode?: AuthCodeFlow<S>;
+        /** @desc Implicit flow */
+        implicit?: ImplicitFlow<S>;
+        /** @desc Resource Owner Password flow */
+        password?: PasswordFlow<S>;
+        /** @desc Client Credentials flow (previously called application in OpenAPI 2.0) */
+        clientCredentials?: ClientCredFlow<S>;
+    };
+}
+/**
+ * @desc K is an optional input field used by InputSecurity
+ * @desc S is an optional union of scopes used by OAuth2Security
+ * */
+type Security<K extends string = string, S extends string = string> = BasicSecurity | BearerSecurity | InputSecurity<K> | CustomHeaderSecurity | CookieSecurity | OpenIdSecurity | OAuth2Security<S>;
+
+interface MiddlewareParams<IN, OPT> {
+    input: IN;
+    options: OPT;
+    request: Request;
+    response: Response;
+    logger: Logger;
+}
+type Middleware<IN, OPT, OUT> = (params: MiddlewareParams<IN, OPT>) => Promise<OUT>;
+interface MiddlewareCreationProps<IN extends IOSchema<"strip">, OPT, OUT extends FlatObject, SCO extends string> {
+    input: IN;
+    security?: LogicalContainer<Security<keyof z.input<IN> & string, SCO>>;
+    middleware: Middleware<z.output<IN>, OPT, OUT>;
+}
+interface MiddlewareDefinition<IN extends IOSchema<"strip">, OPT, OUT extends FlatObject, SCO extends string> extends MiddlewareCreationProps<IN, OPT, OUT, SCO> {
+    type: "proprietary" | "express";
+}
+type AnyMiddlewareDef = MiddlewareDefinition<any, any, any, any>;
+declare const createMiddleware: <IN extends IOSchema<"strip">, OPT, OUT extends FlatObject, SCO extends string>(props: MiddlewareCreationProps<IN, OPT, OUT, SCO>) => MiddlewareDefinition<IN, OPT, OUT, SCO>;
+type ExpressMiddleware<R extends Request, S extends Response> = (request: R, response: S, next: (error?: any) => void) => void | Promise<void>;
+interface ExpressMiddlewareFeatures<R extends Request, S extends Response, OUT extends FlatObject> {
+    provider?: (request: R, response: S) => OUT | Promise<OUT>;
+    transformer?: (err: Error) => HttpError | Error;
+}
+
+type UnknownKeysParam = "passthrough" | "strict" | "strip";
+type Refined<T extends z.ZodTypeAny> = T extends z.ZodType<infer O> ? z.ZodEffects<T | Refined<T>, O, O> : never;
+/**
+ * @desc The type allowed on the top level of Middlewares and Endpoints
+ * @param U — only "strip" is allowed for Middlewares due to intersection issue (Zod) #600
+ * */
+type IOSchema<U extends UnknownKeysParam = any> = z.ZodObject<any, U> | z.ZodUnion<[IOSchema<U>, ...IOSchema<U>[]]> | z.ZodIntersection<IOSchema<U>, IOSchema<U>> | z.ZodDiscriminatedUnion<string, z.ZodObject<any, U>[]> | Refined<z.ZodObject<any, U>>;
+type ProbableIntersection<A extends IOSchema<"strip"> | null, B extends IOSchema> = A extends null ? B : A extends IOSchema<"strip"> ? z.ZodIntersection<A, B> : never;
+
+type Method = "get" | "post" | "put" | "delete" | "patch";
+type MethodsDefinition<M extends Method> = {
+    methods: M[];
+} | {
+    method: M;
+};
+
+type FlatObject = Record<string, any>;
+declare function getMessageFromError(error: Error): string;
+declare function getStatusCodeFromError(error: Error): number;
+type ErrMessage = Exclude<Parameters<typeof z.ZodString.prototype.email>[0], undefined>;
+
+declare const metaProp = "expressZodApiMeta";
+type MetaProp = typeof metaProp;
+type MetaDef<T extends z.ZodTypeAny> = {
+    [K in MetaProp]: {
+        examples: z.input<T>[];
+    };
+};
+type ExampleSetter<T extends z.ZodTypeAny> = (example: z.input<T>) => WithMeta<T>;
+/**
+ * @desc fixes the incompatibility of the ZodObject.keyof() method introduced in v3.17.9
+ * @todo remove it if/when it will be compatible
+ */
+type MetaFixForStrippedObject<T> = T extends z.ZodObject<any> ? T & {
+    keyof: z.ZodObject<any>["keyof"];
+} : T;
+type WithMeta<T extends z.ZodTypeAny> = MetaFixForStrippedObject<T> & {
+    _def: T["_def"] & MetaDef<T>;
+    example: ExampleSetter<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[]];
+}
+
+/** @desc An error related to the wrong Routing declaration */
+declare class RoutingError extends Error {
+    name: string;
+}
+/** @desc An error related to the issues of using DependsOnMethod class */
+declare class DependsOnMethodError extends RoutingError {
+    name: string;
+}
+/** @desc An error related to the generating of the documentation */
+declare class OpenAPIError extends Error {
+    name: string;
+}
+/** @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);
+}
+
+interface ResultHandlerParams<RES> {
+    error: Error | null;
+    input: any;
+    output: any;
+    request: Request;
+    response: Response<RES>;
+    logger: Logger;
+}
+type ResultHandler<RES> = (params: ResultHandlerParams<RES>) => void | Promise<void>;
+interface ResultHandlerDefinition<POS extends z.ZodTypeAny, NEG extends z.ZodTypeAny> {
+    getPositiveResponse: (output: IOSchema) => POS | ApiResponse<POS>;
+    getNegativeResponse: () => NEG | ApiResponse<NEG>;
+    handler: ResultHandler<z.output<POS> | z.output<NEG>>;
+}
+declare const createResultHandler: <POS extends z.ZodTypeAny, NEG extends z.ZodTypeAny>(definition: ResultHandlerDefinition<POS, NEG>) => ResultHandlerDefinition<POS, NEG>;
+declare const defaultResultHandler: ResultHandlerDefinition<z.ZodObject<{
+    status: z.ZodLiteral<"success">;
+    data: IOSchema<any>;
+}, "strip", z.ZodTypeAny, {
+    status: "success";
+    data?: unknown;
+}, {
+    status: "success";
+    data?: unknown;
+}> & {
+    keyof: () => z.ZodEnum<never>;
+} & {
+    _def: z.ZodObjectDef<{
+        status: z.ZodLiteral<"success">;
+        data: IOSchema<any>;
+    }, "strip", z.ZodTypeAny> & MetaDef<z.ZodObject<{
+        status: z.ZodLiteral<"success">;
+        data: IOSchema<any>;
+    }, "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<any>;
+    }, "strip", z.ZodTypeAny, {
+        status: "success";
+        data?: unknown;
+    }, {
+        status: "success";
+        data?: unknown;
+    }> & {
+        keyof: () => z.ZodEnum<never>;
+    } & 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;
+    };
+}> & {
+    keyof: () => z.ZodEnum<never>;
+} & {
+    _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;
+        };
+    }> & {
+        keyof: () => z.ZodEnum<never>;
+    } & any;
+}>;
+
+type Handler<IN, OUT, OPT> = (params: {
+    input: IN;
+    options: OPT;
+    logger: Logger;
+}) => Promise<OUT>;
+type DescriptionVariant = "short" | "long";
+type IOVariant = "input" | "output";
+type ResponseVariant = "positive" | "negative";
+type MimeVariant = Extract<IOVariant, "input"> | ResponseVariant;
+declare abstract class AbstractEndpoint {
+    abstract execute(params: {
+        request: Request;
+        response: Response;
+        logger: Logger;
+        config: CommonConfig;
+    }): Promise<void>;
+    abstract getDescription(variant: DescriptionVariant): string | undefined;
+    abstract getMethods(): Method[];
+    abstract getSchema(variant: IOVariant): IOSchema;
+    abstract getSchema(variant: ResponseVariant): z.ZodTypeAny;
+    abstract getMimeTypes(variant: MimeVariant): string[];
+    abstract getStatusCode(variant: ResponseVariant): number;
+    abstract getSecurity(): LogicalContainer<Security>;
+    abstract getScopes(): string[];
+    abstract getTags(): string[];
+    abstract _setSiblingMethods(methods: Method[]): void;
+}
+type EndpointProps<IN extends IOSchema, OUT extends IOSchema, OPT extends FlatObject, M extends Method, POS extends z.ZodTypeAny, NEG extends z.ZodTypeAny, SCO extends string, TAG extends string> = {
+    middlewares: AnyMiddlewareDef[];
+    inputSchema: IN;
+    outputSchema: OUT;
+    handler: Handler<z.output<IN>, z.input<OUT>, OPT>;
+    resultHandler: ResultHandlerDefinition<POS, NEG>;
+    description?: string;
+    shortDescription?: string;
+} & ({
+    scopes?: SCO[];
+} | {
+    scope?: SCO;
+}) & ({
+    tags?: TAG[];
+} | {
+    tag?: TAG;
+}) & MethodsDefinition<M>;
+declare class Endpoint<IN extends IOSchema, OUT extends IOSchema, OPT extends FlatObject, M extends Method, POS extends z.ZodTypeAny, NEG extends z.ZodTypeAny, SCO extends string, TAG extends string> extends AbstractEndpoint {
+    #private;
+    protected readonly descriptions: Record<DescriptionVariant, string | undefined>;
+    protected readonly methods: M[];
+    protected siblingMethods: Method[];
+    protected readonly middlewares: AnyMiddlewareDef[];
+    protected readonly mimeTypes: Record<MimeVariant, string[]>;
+    protected readonly statusCodes: Record<ResponseVariant, number>;
+    protected readonly handler: Handler<z.output<IN>, z.input<OUT>, OPT>;
+    protected readonly resultHandler: ResultHandlerDefinition<POS, NEG>;
+    protected readonly schemas: {
+        input: IN;
+        output: OUT;
+        positive: POS;
+        negative: NEG;
+    };
+    protected readonly scopes: SCO[];
+    protected readonly tags: TAG[];
+    constructor({ middlewares, inputSchema, outputSchema, handler, resultHandler, description, shortDescription, ...rest }: EndpointProps<IN, OUT, OPT, M, POS, NEG, SCO, TAG>);
+    /**
+     * @desc Sets the other methods supported by the same path. Used by Routing in DependsOnMethod case, for options.
+     * @deprecated This method is for internal needs of the library, please avoid using it.
+     * */
+    _setSiblingMethods(methods: Method[]): void;
+    getDescription(variant: DescriptionVariant): string | undefined;
+    getMethods(): M[];
+    getSchema(variant: "input"): IN;
+    getSchema(variant: "output"): OUT;
+    getSchema(variant: "positive"): POS;
+    getSchema(variant: "negative"): NEG;
+    getMimeTypes(variant: MimeVariant): string[];
+    getStatusCode(variant: ResponseVariant): number;
+    getSecurity(): LogicalContainer<Security<string, string>>;
+    getScopes(): SCO[];
+    getTags(): TAG[];
+    execute({ request, response, logger, config, }: {
+        request: Request;
+        response: Response;
+        logger: Logger;
+        config: CommonConfig;
+    }): Promise<void>;
+}
+
+declare const loggerLevels: {
+    silent: boolean;
+    warn: boolean;
+    debug: boolean;
+};
+interface LoggerConfig {
+    level: keyof typeof loggerLevels;
+    color: boolean;
+}
+type UploadOptions = Pick<fileUpload.Options, "createParentPath" | "uriDecodeFileNames" | "safeFileNames" | "preserveExtension" | "useTempFiles" | "tempFileDir" | "debug" | "uploadTimeout">;
+type CompressionOptions = Pick<compression.CompressionOptions, "threshold" | "level" | "strategy" | "chunkSize" | "memLevel">;
+interface ServerConfig {
+    server: {
+        listen: number | string;
+        jsonParser?: NextHandleFunction;
+        upload?: boolean | UploadOptions;
+        compression?: boolean | CompressionOptions;
+    };
+    https?: {
+        options: ServerOptions;
+        listen: number | string;
+    };
+}
+interface AppConfig {
+    app: Express;
+}
+type InputSource = keyof Pick<Request, "query" | "body" | "files" | "params">;
+type InputSources = Record<Method, InputSource[]>;
+type Headers = Record<string, string>;
+type HeadersProvider = (params: {
+    defaultHeaders: Headers;
+    request: Request;
+    endpoint: AbstractEndpoint;
+    logger: Logger;
+}) => Headers | Promise<Headers>;
+type TagsConfig<TAG extends string> = Record<TAG, string | {
+    description: string;
+    url?: string;
+}>;
+interface CommonConfig<TAG extends string = string> {
+    cors: boolean | HeadersProvider;
+    errorHandler?: ResultHandlerDefinition<any, any>;
+    logger: LoggerConfig | Logger;
+    startupLogo?: boolean;
+    inputSources?: Partial<InputSources>;
+    tags?: TagsConfig<TAG>;
+}
+declare const createConfig: <TAG extends string, T extends (ServerConfig | AppConfig) & CommonConfig<TAG>>(config: T) => T;
+
+type BuildProps<IN extends IOSchema, OUT extends IOSchema, MIN extends IOSchema<"strip"> | null, OPT extends FlatObject, M extends Method, SCO extends string, TAG extends string> = {
+    input: IN;
+    output: OUT;
+    handler: Handler<z.output<ProbableIntersection<MIN, IN>>, z.input<OUT>, OPT>;
+    description?: string;
+    shortDescription?: string;
+} & ({
+    scopes?: SCO[];
+} | {
+    scope?: SCO;
+}) & ({
+    tags?: TAG[];
+} | {
+    tag?: TAG;
+}) & MethodsDefinition<M>;
+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> {
+    #private;
+    protected resultHandler: ResultHandlerDefinition<POS, NEG>;
+    protected middlewares: AnyMiddlewareDef[];
+    constructor(resultHandler: ResultHandlerDefinition<POS, NEG>);
+    /** @desc Consider using the "config" prop with the "tags" option to enforce constraints on tagging the endpoints */
+    constructor(params: {
+        resultHandler: ResultHandlerDefinition<POS, NEG>;
+        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, M extends Method>({ input, handler, output: outputSchema, ...rest }: BuildProps<BIN, BOUT, IN, OUT, M, SCO, TAG>): Endpoint<ProbableIntersection<IN, BIN>, BOUT, OUT, M, POS, NEG, SCO, TAG>;
+}
+declare const defaultEndpointsFactory: EndpointsFactory<z.ZodObject<{
+    status: z.ZodLiteral<"success">;
+    data: IOSchema<any>;
+}, "strip", z.ZodTypeAny, {
+    status: "success";
+    data?: unknown;
+}, {
+    status: "success";
+    data?: unknown;
+}> & {
+    keyof: () => z.ZodEnum<never>;
+} & {
+    _def: z.ZodObjectDef<{
+        status: z.ZodLiteral<"success">;
+        data: IOSchema<any>;
+    }, "strip", z.ZodTypeAny> & MetaDef<z.ZodObject<{
+        status: z.ZodLiteral<"success">;
+        data: IOSchema<any>;
+    }, "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<any>;
+    }, "strip", z.ZodTypeAny, {
+        status: "success";
+        data?: unknown;
+    }, {
+        status: "success";
+        data?: unknown;
+    }> & {
+        keyof: () => z.ZodEnum<never>;
+    } & 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;
+    };
+}> & {
+    keyof: () => z.ZodEnum<never>;
+} & {
+    _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;
+        };
+    }> & {
+        keyof: () => z.ZodEnum<never>;
+    } & any;
+}, null, {}, string, string>;
+
+declare function createLogger(loggerConfig: LoggerConfig): winston.Logger;
+
+declare class DependsOnMethod {
+    readonly methods: {
+        [K in Method]?: Endpoint<any, any, any, K, any, any, any, any> | Endpoint<any, any, any, Method, any, any, any, any>;
+    };
+    constructor(methods: {
+        [K in Method]?: Endpoint<any, any, any, K, any, any, any, any> | Endpoint<any, any, any, Method, any, any, any, any>;
+    });
+}
+
+type OriginalStatic = typeof express.static;
+type StaticHandler = ReturnType<OriginalStatic>;
+declare class ServeStatic {
+    params: Parameters<OriginalStatic>;
+    constructor(...params: Parameters<OriginalStatic>);
+    apply(path: string, cb: (path: string, handler: StaticHandler) => void): void;
+}
+
+interface Routing {
+    [SEGMENT: string]: Routing | DependsOnMethod | AbstractEndpoint | ServeStatic;
+}
+
+declare function attachRouting(config: AppConfig & CommonConfig, routing: Routing): {
+    notFoundHandler: express.RequestHandler<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>;
+    logger: Logger;
+};
+declare function createServer(config: ServerConfig & CommonConfig, routing: Routing): {
+    app: express_serve_static_core.Express;
+    httpServer: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+    httpsServer: https.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | undefined;
+    logger: Logger;
+};
+
+interface GeneratorParams {
+    title: string;
+    version: string;
+    serverUrl: string;
+    routing: Routing;
+    config: CommonConfig;
+    /** @default Successful response */
+    successfulResponseDescription?: string;
+    /** @default Error response */
+    errorResponseDescription?: string;
+    /** @default true */
+    hasSummaryFromDescription?: boolean;
+}
+declare class OpenAPI extends OpenApiBuilder {
+    protected lastSecuritySchemaIds: Partial<Record<SecuritySchemeType, number>>;
+    protected lastOperationIdSuffixes: Record<string, number>;
+    protected ensureUniqOperationId(path: string, method: Method): string;
+    protected ensureUniqSecuritySchemaName(subject: SecuritySchemeObject): string;
+    constructor({ routing, config, title, version, serverUrl, successfulResponseDescription, errorResponseDescription, hasSummaryFromDescription, }: GeneratorParams);
+}
+
+interface TestEndpointProps<REQ, RES, LOG> {
+    endpoint: AbstractEndpoint;
+    requestProps?: REQ;
+    responseProps?: RES;
+    configProps?: Partial<CommonConfig>;
+    loggerProps?: LOG;
+    /** @deprecated for testing purposes only */
+    __noJest?: boolean;
+}
+/**
+ * @description You need to install Jest and probably @types/jest to use this method
+ */
+declare const testEndpoint: <REQ extends Partial<Record<keyof Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>, any>> | undefined = undefined, RES extends Partial<Record<keyof Response<any, Record<string, any>>, any>> | undefined = undefined, LOG extends Partial<Record<keyof Logger, any>> | undefined = undefined>({ endpoint, requestProps, responseProps, configProps, loggerProps, __noJest, }: TestEndpointProps<REQ, RES, LOG>) => Promise<{
+    requestMock: {
+        method: string;
+    } & Record<"header", jest.Mock<any, any, any>> & (REQ extends undefined ? {} : REQ);
+    responseMock: {
+        writableEnded: boolean;
+        statusCode: number;
+        statusMessage: string;
+    } & Record<"status" | "set" | "json" | "end", jest.Mock<any, any, any>> & (RES extends undefined ? {} : RES);
+    loggerMock: Record<"error" | "warn" | "debug" | "info", jest.Mock<any, any, any>> & (LOG extends undefined ? {} : LOG);
+}>;
+
+interface Registry {
+    [METHOD_PATH: string]: Record<"in" | "out", string> & {
+        isJson: boolean;
+    };
+}
+declare class Client {
+    protected agg: ts.Node[];
+    protected registry: Registry;
+    protected paths: string[];
+    constructor(routing: Routing);
+    print(printerOptions?: ts.PrinterOptions): 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";
+declare type ZodFileCheck = {
+    kind: "binary";
+    message?: string;
+} | {
+    kind: "base64";
+    message?: string;
+};
+interface ZodFileDef extends ZodTypeDef {
+    checks: ZodFileCheck[];
+    typeName: typeof zodFileKind;
+}
+declare class ZodFile extends ZodType<string, ZodFileDef> {
+    _parse(input: ParseInput): ParseReturnType<string>;
+    binary: (message?: ErrMessage) => ZodFile;
+    base64: (message?: ErrMessage) => ZodFile;
+    get isBinary(): boolean;
+    get isBase64(): boolean;
+    static create: () => ZodFile;
+}
+
+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;
+}
+
+declare namespace ez {
+    const file: () => ZodFile;
+    const upload: () => ZodUpload;
+    const dateIn: () => ZodDateIn;
+    const dateOut: () => ZodDateOut;
+}
+
+export { AbstractEndpoint, Client, DependsOnMethod, DependsOnMethodError, EndpointsFactory, FlatObject, IOSchema, InputValidationError, LoggerConfig, Method, OpenAPI, OpenAPIError, OutputValidationError, Routing, RoutingError, ServeStatic, attachRouting, createConfig, createLogger, createMiddleware, createResultHandler, createServer, defaultEndpointsFactory, defaultResultHandler, ez, getMessageFromError, getStatusCodeFromError, testEndpoint, withMeta };