express-zod-api 19.2.1 → 20.0.0-beta.1

package/dist/index.d.cts

@@ -1,18 +1,21 @@
 import * as zod from 'zod';
 import { z, ZodError } from 'zod';
 import compression from 'compression';
-import express, { Request, Response, NextFunction, RequestHandler, IRouter } from 'express';
+import * as express from 'express';
+import express__default, { Request, Response, NextFunction, RequestHandler, IRouter } from 'express';
 import * as express_fileupload from 'express-fileupload';
 import express_fileupload__default from 'express-fileupload';
 import https, { ServerOptions } from 'node:https';
 import { Ansis } from 'ansis';
-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 * as node_mocks_http from 'node-mocks-http';
+import { RequestOptions, ResponseOptions } from 'node-mocks-http';
 import ts from 'typescript';
+import { Rule } from 'eslint';
 
 declare const metaSymbol: unique symbol;
 interface Metadata {
@@ -47,6 +50,8 @@ interface LoggerOverrides {
 }
 type ActualLogger = AbstractLogger & LoggerOverrides;
 
+/** @desc this type does not allow props assignment, but it works for reading them when merged with another interface */
+type EmptyObject = Record<string, never>;
 type FlatObject = Record<string, unknown>;
 declare const getMessageFromError: (error: Error) => string;
 declare const getStatusCodeFromError: (error: Error) => number;
@@ -107,12 +112,6 @@ declare class BuiltinLogger implements AbstractLogger {
     error(message: string, meta?: unknown): void;
     child(ctx: Context): BuiltinLogger;
 }
-/**
- * @desc Alias for "new BuiltinLogger()"
- * @deprecated use new BuiltinLogger()
- * @todo remove in v20
- * */
-declare const createLogger: (config: BuiltinLoggerConfig) => BuiltinLogger;
 
 interface ApiResponse<S extends z.ZodTypeAny> {
     schema: S;
@@ -136,7 +135,6 @@ interface ApiResponse<S extends z.ZodTypeAny> {
     mimeTypes?: [string, ...string[]];
 }
 type NormalizedResponse = Required<Pick<ApiResponse<z.ZodTypeAny>, "schema" | "statusCodes" | "mimeTypes">>;
-type AnyResponseDefinition = z.ZodTypeAny | ApiResponse<z.ZodTypeAny> | ApiResponse<z.ZodTypeAny>[];
 
 type LogicalOr<T> = {
     or: T[];
@@ -219,28 +217,47 @@ interface OAuth2Security<S extends string> {
  * */
 type Security<K extends string = string, S extends string = string> = BasicSecurity | BearerSecurity | InputSecurity<K> | CustomHeaderSecurity | CookieSecurity | OpenIdSecurity | OAuth2Security<S>;
 
-interface MiddlewareParams<IN, OPT> {
+type Handler$2<IN, OPT, OUT> = (params: {
     input: IN;
     options: OPT;
     request: Request;
     response: Response;
     logger: ActualLogger;
+}) => Promise<OUT>;
+declare abstract class AbstractMiddleware {
+    abstract getSecurity(): LogicalContainer<Security> | undefined;
+    abstract getSchema(): IOSchema<"strip">;
+    abstract execute(params: {
+        input: unknown;
+        options: FlatObject;
+        request: Request;
+        response: Response;
+        logger: ActualLogger;
+    }): Promise<FlatObject>;
 }
-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<Extract<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";
+declare class Middleware<IN extends IOSchema<"strip">, OPT extends FlatObject, OUT extends FlatObject, SCO extends string> extends AbstractMiddleware {
+    #private;
+    constructor({ input, security, handler, }: {
+        input: IN;
+        security?: LogicalContainer<Security<Extract<keyof z.input<IN>, string>, SCO>>;
+        handler: Handler$2<z.output<IN>, OPT, OUT>;
+    });
+    getSecurity(): LogicalContainer<Security<Extract<keyof z.input<IN>, string>, SCO>> | undefined;
+    getSchema(): IN;
+    /** @throws InputValidationError */
+    execute({ input, ...rest }: {
+        input: unknown;
+        options: OPT;
+        request: Request;
+        response: Response;
+        logger: ActualLogger;
+    }): Promise<OUT>;
 }
-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: NextFunction) => 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;
+declare class ExpressMiddleware<R extends Request, S extends Response, OUT extends FlatObject> extends Middleware<z.ZodObject<EmptyObject, "strip">, FlatObject, OUT, string> {
+    constructor(nativeMw: (request: R, response: S, next: NextFunction) => void | Promise<void>, { provider, transformer, }?: {
+        provider?: (request: R, response: S) => OUT | Promise<OUT>;
+        transformer?: (err: Error) => Error;
+    });
 }
 
 /** Shorthand for z.object({ raw: ez.file("buffer") }) */
@@ -262,8 +279,7 @@ type Refined<T extends z.ZodTypeAny> = T extends z.ZodType<infer O> ? z.ZodEffec
  * @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 z.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>> | RawSchema;
-type ProbableIntersection<A extends IOSchema<"strip"> | null, B extends IOSchema> = A extends null ? B : A extends IOSchema<"strip"> ? z.ZodIntersection<A, B> : never;
+type IOSchema<U extends z.UnknownKeysParam = z.UnknownKeysParam> = z.ZodObject<z.ZodRawShape, U> | z.ZodUnion<[IOSchema<U>, ...IOSchema<U>[]]> | z.ZodIntersection<IOSchema<U>, IOSchema<U>> | z.ZodDiscriminatedUnion<string, z.ZodObject<z.ZodRawShape, U>[]> | Refined<z.ZodObject<z.ZodRawShape, U>> | RawSchema;
 
 declare const methods: ("get" | "post" | "put" | "delete" | "patch")[];
 type Method = (typeof methods)[number];
@@ -275,7 +291,9 @@ declare const contentTypes: {
 };
 type ContentType = keyof typeof contentTypes;
 
-interface ResultHandlerParams<RES> {
+type ResultSchema<R extends Result> = R extends Result<infer S> ? S : never;
+
+type Handler$1<RES = unknown> = (params: {
     /** null in case of failure to parse or to find the matching endpoint (error: not found) */
     input: FlatObject | null;
     /** null in case of errors or failures */
@@ -286,17 +304,30 @@ interface ResultHandlerParams<RES> {
     request: Request;
     response: Response<RES>;
     logger: ActualLogger;
+}) => void | Promise<void>;
+type Result<S extends z.ZodTypeAny = z.ZodTypeAny> = S | ApiResponse<S> | ApiResponse<S>[];
+type LazyResult<R extends Result, A extends unknown[] = []> = (...args: A) => R;
+declare abstract class AbstractResultHandler {
+    #private;
+    abstract getPositiveResponse(output: IOSchema): NormalizedResponse[];
+    abstract getNegativeResponse(): NormalizedResponse[];
+    protected constructor(handler: Handler$1);
+    execute(...params: Parameters<Handler$1>): void | Promise<void>;
 }
-type ResultHandler<RES> = (params: ResultHandlerParams<RES>) => void | Promise<void>;
-type ExtractSchema<T extends AnyResponseDefinition> = T extends ApiResponse<infer S>[] ? S : T extends ApiResponse<infer S> ? S : T extends z.ZodTypeAny ? T : never;
-interface ResultHandlerDefinition<POS extends AnyResponseDefinition, NEG extends AnyResponseDefinition> {
-    getPositiveResponse: (output: IOSchema) => POS;
-    getNegativeResponse: () => NEG;
-    handler: ResultHandler<z.output<ExtractSchema<POS>> | z.output<ExtractSchema<NEG>>>;
+declare class ResultHandler<POS extends Result, NEG extends Result> extends AbstractResultHandler {
+    #private;
+    constructor(params: {
+        /** @desc A description of the API response in case of success (schema, status code, MIME type) */
+        positive: POS | LazyResult<POS, [IOSchema]>;
+        /** @desc A description of the API response in case of error (schema, status code, MIME type) */
+        negative: NEG | LazyResult<NEG>;
+        /** @desc The actual implementation to transmit the response in any case */
+        handler: Handler$1<z.output<ResultSchema<POS> | ResultSchema<NEG>>>;
+    });
+    getPositiveResponse(output: IOSchema): Required<Pick<ApiResponse<z.ZodTypeAny>, "schema" | "statusCodes" | "mimeTypes">>[];
+    getNegativeResponse(): Required<Pick<ApiResponse<z.ZodTypeAny>, "schema" | "statusCodes" | "mimeTypes">>[];
 }
-type AnyResultHandlerDefinition = ResultHandlerDefinition<AnyResponseDefinition, AnyResponseDefinition>;
-declare const createResultHandler: <POS extends AnyResponseDefinition, NEG extends AnyResponseDefinition>(definition: ResultHandlerDefinition<POS, NEG>) => ResultHandlerDefinition<POS, NEG>;
-declare const defaultResultHandler: ResultHandlerDefinition<z.ZodObject<{
+declare const defaultResultHandler: ResultHandler<z.ZodObject<{
     status: z.ZodLiteral<"success">;
     data: IOSchema;
 }, "strip", z.ZodTypeAny, {
@@ -330,7 +361,7 @@ declare const defaultResultHandler: ResultHandlerDefinition<z.ZodObject<{
  * @desc Responding with array is a bad practice keeping your endpoints from evolving without breaking changes.
  * @desc This handler expects your endpoint to have the property 'items' in the output object schema
  * */
-declare const arrayResultHandler: ResultHandlerDefinition<z.ZodArray<z.ZodTypeAny, "many">, z.ZodString>;
+declare const arrayResultHandler: ResultHandler<z.ZodArray<z.ZodTypeAny, "many">, z.ZodString>;
 
 type Handler<IN, OUT, OPT> = (params: {
     input: IN;
@@ -364,11 +395,11 @@ declare abstract class 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[];
+        middlewares?: AbstractMiddleware[];
         inputSchema: IN;
         outputSchema: OUT;
         handler: Handler<z.output<IN>, z.input<OUT>, OPT>;
-        resultHandler: AnyResultHandlerDefinition;
+        resultHandler: AbstractResultHandler;
         description?: string;
         shortDescription?: string;
         getOperationId?: (method: Method) => string | undefined;
@@ -427,7 +458,7 @@ interface CommonConfig<TAG extends string = string> {
      * @default defaultResultHandler
      * @see defaultResultHandler
      */
-    errorHandler?: AnyResultHandlerDefinition;
+    errorHandler?: AbstractResultHandler;
     /**
      * @desc Built-in logger configuration or an instance of any compatible logger.
      * @example { level: "debug", color: true }
@@ -533,10 +564,10 @@ interface AppConfig<TAG extends string = string> extends CommonConfig<TAG> {
 declare function createConfig<TAG extends string>(config: ServerConfig<TAG>): ServerConfig<TAG>;
 declare function createConfig<TAG extends string>(config: AppConfig<TAG>): AppConfig<TAG>;
 
-type BuildProps<IN extends IOSchema, OUT extends IOSchema, MIN extends IOSchema<"strip"> | null, OPT extends FlatObject, SCO extends string, TAG extends string> = {
+type BuildProps<IN extends IOSchema, OUT extends IOSchema, MIN extends IOSchema<"strip">, OPT extends FlatObject, SCO extends string, TAG extends string> = {
     input: IN;
     output: OUT;
-    handler: Handler<z.output<ProbableIntersection<MIN, IN>>, z.input<OUT>, OPT>;
+    handler: Handler<z.output<z.ZodIntersection<MIN, IN>>, z.input<OUT>, OPT>;
     description?: string;
     shortDescription?: string;
     operationId?: string | ((method: Method) => string);
@@ -553,29 +584,40 @@ type BuildProps<IN extends IOSchema, OUT extends IOSchema, MIN extends IOSchema<
 } | {
     tag?: TAG;
 });
-declare class EndpointsFactory<IN extends IOSchema<"strip"> | null = null, OUT extends FlatObject = {}, SCO extends string = string, TAG extends string = string> {
+declare class EndpointsFactory<IN extends IOSchema<"strip"> = z.ZodObject<EmptyObject, "strip">, OUT extends FlatObject = EmptyObject, SCO extends string = string, TAG extends string = string> {
     #private;
-    protected resultHandler: AnyResultHandlerDefinition;
-    protected middlewares: AnyMiddlewareDef[];
+    protected resultHandler: AbstractResultHandler;
+    protected middlewares: AbstractMiddleware[];
     /** @desc Consider using the "config" prop with the "tags" option to enforce constraints on tagging the endpoints */
-    constructor(resultHandler: AnyResultHandlerDefinition);
+    constructor(resultHandler: AbstractResultHandler);
     constructor(params: {
-        resultHandler: AnyResultHandlerDefinition;
+        resultHandler: AbstractResultHandler;
         config?: CommonConfig<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>) => 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>;
+    addMiddleware<AIN extends IOSchema<"strip">, AOUT extends FlatObject, ASCO extends string>(subject: Middleware<AIN, OUT, AOUT, ASCO> | ConstructorParameters<typeof Middleware<AIN, OUT, AOUT, ASCO>>[0]): EndpointsFactory<z.ZodIntersection<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 = EmptyObject>(nativeMw: (request: R, response: S, next: express.NextFunction) => void | Promise<void>, params_1?: {
+        provider?: ((request: R, response: S) => AOUT | Promise<AOUT>) | undefined;
+        transformer?: ((err: Error) => Error) | undefined;
+    } | undefined) => EndpointsFactory<IN, OUT & AOUT, SCO, TAG>;
+    addExpressMiddleware<R extends Request, S extends Response, AOUT extends FlatObject = EmptyObject>(...params: ConstructorParameters<typeof ExpressMiddleware<R, S, AOUT>>): EndpointsFactory<IN, OUT & AOUT, SCO, TAG>;
     addOptions<AOUT extends FlatObject>(getOptions: () => Promise<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>;
+    build<BIN extends IOSchema, BOUT extends IOSchema>({ input, handler, output: outputSchema, description, shortDescription, operationId, ...rest }: BuildProps<BIN, BOUT, IN, OUT, SCO, TAG>): Endpoint<z.ZodIntersection<IN, BIN>, BOUT, OUT, SCO, TAG>;
 }
-declare const defaultEndpointsFactory: EndpointsFactory<null, {}, string, string>;
+declare const defaultEndpointsFactory: EndpointsFactory<z.ZodObject<EmptyObject, "strip", z.ZodTypeAny, {
+    [x: string]: never;
+}, {
+    [x: string]: never;
+}>, EmptyObject, 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<null, {}, string, string>;
+declare const arrayEndpointsFactory: EndpointsFactory<z.ZodObject<EmptyObject, "strip", z.ZodTypeAny, {
+    [x: string]: never;
+}, {
+    [x: string]: never;
+}>, EmptyObject, string, string>;
 
 declare class DependsOnMethod {
     readonly pairs: ReadonlyArray<[Method, AbstractEndpoint]>;
@@ -584,7 +626,7 @@ declare class DependsOnMethod {
     constructor(endpoints: Partial<Record<Method, AbstractEndpoint>>);
 }
 
-type OriginalStatic = typeof express.static;
+type OriginalStatic = typeof express__default.static;
 type StaticHandler = ReturnType<OriginalStatic>;
 declare class ServeStatic {
     params: Parameters<OriginalStatic>;
@@ -597,7 +639,7 @@ interface Routing {
 }
 
 declare const attachRouting: (config: AppConfig, routing: Routing) => {
-    notFoundHandler: express.RequestHandler<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>;
+    notFoundHandler: express__default.RequestHandler<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>>;
     logger: AbstractLogger | BuiltinLogger;
 };
 declare const createServer: (config: ServerConfig, routing: Routing) => Promise<{
@@ -670,18 +712,15 @@ declare const ez: {
     }, S>>[k_1]; } : never>, symbol>;
 };
 
-interface VariantDependingProps<U> {
-    regular: {
-        next: (schema: z.ZodTypeAny) => U;
-    };
-    each: {
-        prev: U;
-    };
-    last: {};
+interface NextHandlerInc<U> {
+    next: (schema: z.ZodTypeAny) => U;
+}
+interface PrevInc<U> {
+    prev: U;
 }
-type HandlingVariant = keyof VariantDependingProps<unknown>;
-type SchemaHandler<U, Context extends FlatObject = {}, Variant extends HandlingVariant = "regular"> = (schema: any, ctx: Context & VariantDependingProps<U>[Variant]) => U;
-type HandlingRules<U, Context extends FlatObject = {}, K extends string | symbol = string | symbol> = Partial<Record<K, SchemaHandler<U, Context>>>;
+type SchemaHandler<U, Context extends FlatObject = EmptyObject, Variant extends "regular" | "each" | "last" = "regular"> = (schema: any, // eslint-disable-line @typescript-eslint/no-explicit-any -- for assignmet compatibility
+ctx: Context & (Variant extends "regular" ? NextHandlerInc<U> : Variant extends "each" ? PrevInc<U> : Context)) => U;
+type HandlingRules<U, Context extends FlatObject = EmptyObject, K extends string | symbol = string | symbol> = Partial<Record<K, SchemaHandler<U, Context>>>;
 
 interface OpenAPIContext extends FlatObject {
     isResponse: boolean;
@@ -743,28 +782,19 @@ type LocalResponse = Response<unknown, {
     };
 }>;
 
-/**
- * @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 {} }
- * @link https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
- * */
-interface MockOverrides {
-}
-/** @desc Compatibility constraints for a function mocking method of a testing framework. */
-type MockFunction = (implementation?: (...args: any[]) => any) => MockOverrides;
-interface TestEndpointProps<REQ, RES, LOG> {
+interface TestEndpointProps<REQ, LOG> {
     /** @desc The endpoint to test */
     endpoint: AbstractEndpoint;
     /**
      * @desc Additional properties to set on Request mock
-     * @default { method: "GET", header: () => "application/json" }
+     * @default { method: "GET", headers: { "content-type": "application/json" } }
      * */
     requestProps?: REQ;
     /**
-     * @desc Additional properties to set on Response mock
-     * @default { writableEnded, statusCode, statusMessage, set, setHeader, header, status, json, send, end }
+     * @link https://www.npmjs.com/package/node-mocks-http
+     * @default { req: requestMock }
      * */
-    responseProps?: RES;
+    responseOptions?: ResponseOptions;
     /**
      * @desc Additional properties to set on config mock
      * @default { cors: false, logger }
@@ -775,25 +805,26 @@ interface TestEndpointProps<REQ, RES, LOG> {
      * @default { info, warn, error, debug }
      * */
     loggerProps?: LOG;
-    /**
-     * @desc Optionally specify the function mocking method of your testing framework
-     * @default jest.fn || vi.fn // from vitest
-     * @example mock.fn.bind(mock) // from node:test, binding might be necessary
-     * */
-    fnMethod?: MockFunction;
-}
-/** @desc Requires either jest (with @types/jest) or vitest or to specify the fnMethod option */
-declare const testEndpoint: <LOG extends Record<string, any>, REQ extends Record<string, any>, RES extends Record<string, any>>({ endpoint, requestProps, responseProps, configProps, loggerProps, fnMethod: userDefined, }: TestEndpointProps<REQ, RES, LOG>) => Promise<{
-    requestMock: {
-        method: string;
-    } & Record<"header", MockOverrides> & REQ;
-    responseMock: {
-        writableEnded: boolean;
-        statusCode: number;
-        statusMessage: string;
-        locals: LocalResponse["locals"];
-    } & Record<"status" | "set" | "header" | "json" | "end" | "setHeader" | "send", MockOverrides> & RES;
-    loggerMock: Record<"info" | "debug" | "warn" | "error", MockOverrides> & LOG;
+}
+declare const testEndpoint: <LOG extends FlatObject, REQ extends RequestOptions>({ endpoint, requestProps, responseOptions, configProps, loggerProps, }: TestEndpointProps<REQ, LOG>) => Promise<{
+    requestMock: Request<express_serve_static_core.ParamsDictionary, any, any, qs.ParsedQs, Record<string, any>> & {
+        [key: string]: any;
+        _setParameter: (key: string, value?: string | undefined) => void;
+        _setSessionVariable: (variable: string, value?: string | undefined) => void;
+        _setCookiesVariable: (variable: string, value?: string | undefined) => void;
+        _setSignedCookiesVariable: (variable: string, value?: string | undefined) => void;
+        _setHeadersCookiesVariable: (variable: string, value: string) => void;
+        _setFilesCookiesVariable: (variable: string, value?: string | undefined) => void;
+        _setMethod: (method?: string | undefined) => void;
+        _setURL: (value?: string | undefined) => void;
+        _setOriginalUrl: (value?: string | undefined) => void;
+        _setBody: (body?: node_mocks_http.Body | undefined) => void;
+        _addBody: (key: string, value?: any) => void;
+    } & REQ;
+    responseMock: node_mocks_http.MockResponse<LocalResponse>;
+    loggerMock: AbstractLogger & LOG & {
+        _getLogs: () => Record<"info" | "debug" | "warn" | "error", unknown[]>;
+    };
 }>;
 
 interface ZTSContext extends FlatObject {
@@ -915,4 +946,18 @@ declare class Integration {
     printFormatted({ printerOptions, format: userDefined, }?: FormattedPrintingOptions): Promise<string>;
 }
 
-export { AbstractEndpoint, type ApiResponse, type AppConfig, type BasicSecurity, type BearerSecurity, BuiltinLogger, type CommonConfig, type CookieSecurity, type CustomHeaderSecurity, DependsOnMethod, type Depicter, Documentation, DocumentationError, EndpointsFactory, type FlatObject, type IOSchema, type InputSecurity, InputValidationError, Integration, type LoggerOverrides, type Method, type MiddlewareDefinition, MissingPeerError, type MockOverrides, type OAuth2Security, type OpenIdSecurity, OutputValidationError, type Producer, type ResultHandlerDefinition, type Routing, RoutingError, ServeStatic, type ServerConfig, arrayEndpointsFactory, arrayResultHandler, attachRouting, createConfig, createLogger, createMiddleware, createResultHandler, createServer, defaultEndpointsFactory, defaultResultHandler, ez, getExamples, getMessageFromError, getStatusCodeFromError, testEndpoint };
+/** @desc ESLint plugin for migrating to this version (from previous) */
+declare const migration: {
+    rules: {
+        "ez-migration/v20": "error";
+    };
+    plugins: {
+        "ez-migration": {
+            rules: {
+                v20: Rule.RuleModule;
+            };
+        };
+    };
+};
+
+export { type ApiResponse, type AppConfig, type BasicSecurity, type BearerSecurity, BuiltinLogger, type CommonConfig, type CookieSecurity, type CustomHeaderSecurity, DependsOnMethod, type Depicter, Documentation, DocumentationError, EndpointsFactory, type FlatObject, type IOSchema, type InputSecurity, InputValidationError, Integration, type LoggerOverrides, type Method, Middleware, MissingPeerError, type OAuth2Security, type OpenIdSecurity, OutputValidationError, type Producer, ResultHandler, type Routing, RoutingError, ServeStatic, type ServerConfig, arrayEndpointsFactory, arrayResultHandler, attachRouting, createConfig, createServer, defaultEndpointsFactory, defaultResultHandler, ez, getExamples, getMessageFromError, getStatusCodeFromError, migration, testEndpoint };