express-zod-api 25.5.3 → 26.0.0-beta.2

package/dist/index.d.ts

@@ -15,8 +15,8 @@ import compression from "compression";
 import * as express_fileupload0 from "express-fileupload";
 import fileUpload from "express-fileupload";
 import { ListenOptions } from "node:net";
-import * as express_serve_static_core2 from "express-serve-static-core";
-import * as qs2 from "qs";
+import * as express_serve_static_core0 from "express-serve-static-core";
+import * as qs0 from "qs";
 import * as zod_v4_core0 from "zod/v4/core";
 
 //#region src/method.d.ts
@@ -37,8 +37,8 @@ type ClientMethod = (typeof clientMethods)[number];
 //#endregion
 //#region src/api-response.d.ts
 /** @public this is the user facing configuration */
-interface ApiResponse<S extends z.ZodType> {
-  schema: S;
+interface ApiResponse<S$1 extends z.ZodType> {
+  schema: S$1;
   /** @default 200 for a positive and 400 for a negative response */
   statusCode?: number | [number, ...number[]];
   /**
@@ -56,7 +56,7 @@ type EmptySchema = typeof emptySchema;
 type EmptyObject = z.output<EmptySchema>;
 type FlatObject = Record<string, unknown>;
 /** @link https://stackoverflow.com/a/65492934 */
-type NoNever<T, F> = [T] extends [never] ? F : T;
+type NoNever<T$1, F> = [T$1] extends [never] ? F : T$1;
 /**
  * @desc Using module augmentation approach you can specify tags as the keys of this interface
  * @example declare module "express-zod-api" { interface TagOverrides { users: unknown } }
@@ -85,7 +85,7 @@ interface LoggerOverrides {}
 type ActualLogger = AbstractLogger & LoggerOverrides;
 //#endregion
 //#region src/builtin-logger.d.ts
-interface Context$1 extends FlatObject {
+interface Context extends FlatObject {
   requestId?: string;
 }
 interface BuiltinLoggerConfig {
@@ -106,7 +106,7 @@ interface BuiltinLoggerConfig {
    * @desc Context: the metadata applicable for each logged entry, used by .child() method
    * @see childLoggerProvider
    * */
-  ctx: Context$1;
+  ctx: Context;
 }
 interface ProfilerOptions {
   message: string;
@@ -131,12 +131,12 @@ declare class BuiltinLogger implements AbstractLogger {
   info(message: string, meta?: unknown): void;
   warn(message: string, meta?: unknown): void;
   error(message: string, meta?: unknown): void;
-  child(ctx: Context$1): BuiltinLogger;
+  child(ctx: Context): BuiltinLogger;
   /**
    * @desc The argument used for instance created by .child() method
    * @see ChildLoggerProvider
    * */
-  get ctx(): Context$1;
+  get ctx(): Context;
   /** @desc Measures the duration until you invoke the returned callback */
   profile(message: string): () => void;
   profile(options: ProfilerOptions): () => void;
@@ -154,13 +154,13 @@ type Extension<Current extends IOSchema | undefined, Inc extends IOSchema | unde
 type FinalInputSchema<FIN extends IOSchema | undefined, BIN extends IOSchema> = z.ZodIntersection<FIN extends IOSchema ? FIN : BIN, BIN>;
 //#endregion
 //#region src/logical-container.d.ts
-type LogicalOr<T> = {
-  or: T[];
+type LogicalOr<T$1> = {
+  or: T$1[];
 };
-type LogicalAnd<T> = {
-  and: T[];
+type LogicalAnd<T$1> = {
+  and: T$1[];
 };
-type LogicalContainer<T> = LogicalOr<T | LogicalAnd<T>> | LogicalAnd<T | LogicalOr<T>> | T;
+type LogicalContainer<T$1> = LogicalOr<T$1 | LogicalAnd<T$1>> | LogicalAnd<T$1 | LogicalOr<T$1>> | T$1;
 //#endregion
 //#region src/security.d.ts
 interface BasicSecurity {
@@ -170,9 +170,9 @@ interface BearerSecurity {
   type: "bearer";
   format?: "JWT" | string;
 }
-interface InputSecurity<K extends string> {
+interface InputSecurity<K$1 extends string> {
   type: "input";
-  name: K;
+  name: K$1;
 }
 interface HeaderSecurity {
   type: "header";
@@ -205,28 +205,28 @@ 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> {
+interface Scopes<K$1 extends string> {
   /** @desc The available scopes for the OAuth2 security and their short descriptions. Optional. */
-  scopes?: Record<K, string>;
+  scopes?: Record<K$1, 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>;
+type AuthCodeFlow<S$1 extends string> = AuthUrl & TokenUrl & RefreshUrl & Scopes<S$1>;
+type ImplicitFlow<S$1 extends string> = AuthUrl & RefreshUrl & Scopes<S$1>;
+type PasswordFlow<S$1 extends string> = TokenUrl & RefreshUrl & Scopes<S$1>;
+type ClientCredFlow<S$1 extends string> = TokenUrl & RefreshUrl & Scopes<S$1>;
 /**
  * @see https://swagger.io/docs/specification/authentication/oauth2/
  */
-interface OAuth2Security<S extends string> {
+interface OAuth2Security<S$1 extends string> {
   type: "oauth2";
   flows?: {
     /** @desc Authorization Code flow (previously called accessCode in OpenAPI 2.0) */
-    authorizationCode?: AuthCodeFlow<S>;
+    authorizationCode?: AuthCodeFlow<S$1>;
     /** @desc Implicit flow */
-    implicit?: ImplicitFlow<S>;
+    implicit?: ImplicitFlow<S$1>;
     /** @desc Resource Owner Password flow */
-    password?: PasswordFlow<S>;
+    password?: PasswordFlow<S$1>;
     /** @desc Client Credentials flow (previously called application in OpenAPI 2.0) */
-    clientCredentials?: ClientCredFlow<S>;
+    clientCredentials?: ClientCredFlow<S$1>;
   };
 }
 /**
@@ -234,34 +234,34 @@ interface OAuth2Security<S extends string> {
  * @param K is an optional input field used by InputSecurity
  * @param S is an optional union of scopes used by OAuth2Security
  * */
-type Security<K extends string = string, S extends string = string> = BasicSecurity | BearerSecurity | InputSecurity<K> | HeaderSecurity | CookieSecurity | OpenIdSecurity | OAuth2Security<S>;
+type Security<K$1 extends string = string, S$1 extends string = string> = BasicSecurity | BearerSecurity | InputSecurity<K$1> | HeaderSecurity | CookieSecurity | OpenIdSecurity | OAuth2Security<S$1>;
 //#endregion
 //#region src/middleware.d.ts
-type Handler$2<IN, OPT, OUT> = (params: {
+type Handler$2<IN, CTX, RET> = (params: {
   /** @desc The inputs from the enabled input sources validated against the input schema of the Middleware */
   input: IN;
   /**
    * @desc The returns of the previously executed Middlewares (typed when chaining Middlewares)
    * @link https://github.com/RobinTail/express-zod-api/discussions/1250
    * */
-  options: OPT;
+  ctx: CTX;
   /** @link https://expressjs.com/en/5x/api.html#req */
   request: Request;
   /** @link https://expressjs.com/en/5x/api.html#res */
   response: Response;
   /** @desc The instance of the configured logger */
   logger: ActualLogger;
-}) => Promise<OUT>;
+}) => Promise<RET>;
 declare abstract class AbstractMiddleware {
   abstract execute(params: {
     input: unknown;
-    options: FlatObject;
+    ctx: FlatObject;
     request: Request;
     response: Response;
     logger: ActualLogger;
   }): Promise<FlatObject>;
 }
-declare class Middleware<OPT extends FlatObject, OUT extends FlatObject, SCO extends string, IN extends IOSchema | undefined = undefined> extends AbstractMiddleware {
+declare class Middleware<CTX extends FlatObject, RET extends FlatObject, SCO extends string, IN extends IOSchema | undefined = undefined> extends AbstractMiddleware {
   #private;
   constructor({
     input,
@@ -276,8 +276,8 @@ declare class Middleware<OPT extends FlatObject, OUT extends FlatObject, SCO ext
     input?: IN;
     /** @desc Declaration of the security schemas implemented within the handler */
     security?: LogicalContainer<Security<Extract<keyof z.input<IN>, string>, SCO>>;
-    /** @desc The handler returning options available to Endpoints */
-    handler: Handler$2<z.output<IN>, OPT, OUT>;
+    /** @desc The handler returning a context available to Endpoints */
+    handler: Handler$2<z.output<IN>, CTX, RET>;
   });
   /** @throws InputValidationError */
   execute({
@@ -285,36 +285,22 @@ declare class Middleware<OPT extends FlatObject, OUT extends FlatObject, SCO ext
     ...rest
   }: {
     input: unknown;
-    options: OPT;
+    ctx: CTX;
     request: Request;
     response: Response;
     logger: ActualLogger;
-  }): Promise<OUT>;
+  }): Promise<RET>;
 }
-declare class ExpressMiddleware<R extends Request, S extends Response, OUT extends FlatObject> extends Middleware<FlatObject, OUT, string> {
-  constructor(nativeMw: (request: R, response: S, next: NextFunction) => any, {
+declare class ExpressMiddleware<R extends Request, S$1 extends Response, RET extends FlatObject> extends Middleware<FlatObject, RET, string> {
+  constructor(nativeMw: (request: R, response: S$1, next: NextFunction) => any, {
     provider,
     transformer
   }?: {
-    provider?: (request: R, response: S) => OUT | Promise<OUT>;
+    provider?: (request: R, response: S$1) => RET | Promise<RET>;
     transformer?: (err: Error) => Error;
   });
 }
 //#endregion
-//#region src/depends-on-method.d.ts
-declare class DependsOnMethod extends Routable {
-  #private;
-  constructor(endpoints: Partial<Record<Method, AbstractEndpoint>>);
-  deprecated(): this;
-}
-//#endregion
-//#region src/serve-static.d.ts
-type OriginalStatic = typeof express.static;
-declare class ServeStatic {
-  #private;
-  constructor(...params: Parameters<OriginalStatic>);
-}
-//#endregion
 //#region src/result-helpers.d.ts
 type ResultSchema<R extends Result> = R extends Result<infer S> ? S : never;
 type DiscriminatedResult = {
@@ -335,12 +321,12 @@ type Handler$1<RES = unknown> = (params: DiscriminatedResult & {
   /** null in case of failure to parse or to find the matching endpoint (error: not found) */
   input: FlatObject | null;
   /** can be empty: check presence of the required property using "in" operator */
-  options: FlatObject;
+  ctx: FlatObject;
   request: Request;
   response: Response<RES>;
   logger: ActualLogger;
 }) => void | Promise<void>;
-type Result<S extends z.ZodType = z.ZodType> = S | ApiResponse<S> | ApiResponse<S>[];
+type Result<S$1 extends z.ZodType = z.ZodType> = S$1 | ApiResponse<S$1> | ApiResponse<S$1>[];
 type LazyResult<R extends Result, A extends unknown[] = []> = (...args: A) => R;
 declare abstract class AbstractResultHandler {
   #private;
@@ -377,6 +363,13 @@ declare const arrayResultHandler: ResultHandler<z.ZodArray<z.core.$ZodType<unkno
   mimeType: string;
 }>;
 //#endregion
+//#region src/serve-static.d.ts
+type OriginalStatic = typeof express.static;
+declare class ServeStatic {
+  #private;
+  constructor(...params: Parameters<OriginalStatic>);
+}
+//#endregion
 //#region src/server-helpers.d.ts
 /** @desc Returns child logger for the given request (if configured) or the configured logger otherwise */
 type GetLogger = (request?: Request) => ActualLogger;
@@ -387,29 +380,27 @@ type GetLogger = (request?: Request) => ActualLogger;
  * @example { "v1/books/:bookId": getBookEndpoint }
  * @example { "get /v1/books/:bookId": getBookEndpoint }
  * @example { v1: { "patch /books/:bookId": changeBookEndpoint } }
+ * @example { dependsOnMethod: { get: retrieveEndpoint, post: createEndpoint } }
+ * @see CommonConfig.methodLikeRouteBehavior
  * */
 interface Routing {
-  [K: string]: Routing | DependsOnMethod | AbstractEndpoint | ServeStatic;
-}
-//#endregion
-//#region src/routable.d.ts
-declare abstract class Routable {
-  /** @desc Marks the route as deprecated (makes a copy of the endpoint) */
-  abstract deprecated(): this;
-  /** @desc Enables nested routes within the path assigned to the subject */
-  nest(routing: Routing): Routing;
+  [K: string]: Routing | AbstractEndpoint | ServeStatic;
 }
 //#endregion
 //#region src/endpoint.d.ts
-type Handler<IN, OUT, OPT> = (params: {
+type Handler<IN, OUT, CTX> = (params: {
   /** @desc The inputs from the enabled input sources validated against the final input schema (incl. Middlewares) */
   input: IN;
   /** @desc The returns of the assigned Middlewares */
-  options: OPT;
+  ctx: CTX;
   /** @desc The instance of the configured logger */
   logger: ActualLogger;
 }) => Promise<OUT>;
-declare abstract class AbstractEndpoint extends Routable {
+declare abstract class AbstractEndpoint {
+  /** @desc Enables nested routes within the path assigned to the subject */
+  nest(routing: Routing): Routing;
+  /** @desc Marks the route as deprecated (makes a copy of the endpoint) */
+  abstract deprecated(): this;
   abstract execute(params: {
     request: Request;
     response: Response;
@@ -417,14 +408,14 @@ declare abstract class AbstractEndpoint extends Routable {
     config: CommonConfig;
   }): Promise<void>;
 }
-declare class Endpoint<IN extends IOSchema, OUT extends IOSchema, OPT extends FlatObject> extends AbstractEndpoint {
+declare class Endpoint<IN extends IOSchema, OUT extends IOSchema, CTX extends FlatObject> extends AbstractEndpoint {
   #private;
   constructor(def: {
     deprecated?: boolean;
     middlewares?: AbstractMiddleware[];
     inputSchema: IN;
     outputSchema: OUT;
-    handler: Handler<z.output<IN>, z.input<OUT>, OPT>;
+    handler: Handler<z.output<IN>, z.input<OUT>, CTX>;
     resultHandler: AbstractResultHandler;
     description?: string;
     shortDescription?: string;
@@ -477,6 +468,14 @@ interface CommonConfig {
    * @default 405
    * */
   wrongMethodBehavior?: 404 | 405;
+  /**
+   * @desc How to treat Routing keys that look like methods (when assigned with an Endpoint)
+   * @see Method
+   * @example "method" — the key is treated as method of its parent path
+   * @example "path" — the key is treated as a nested path segment
+   * @default "method"
+   * */
+  methodLikeRouteBehavior?: "method" | "path";
   /**
    * @desc The ResultHandler to use for handling routing, parsing and upload errors
    * @default defaultResultHandler
@@ -547,7 +546,7 @@ interface GracefulOptions {
   /** @desc The hook to call after the server was closed, but before terminating the process. */
   beforeExit?: () => void | Promise<void>;
 }
-type BeforeRouting = (params: {
+type ServerHook = (params: {
   app: IRouter;
   /** @desc Returns child logger for the given request (if configured) or the configured logger otherwise */
   getLogger: GetLogger;
@@ -608,7 +607,12 @@ interface ServerConfig extends CommonConfig {
    * @desc It can help to avoid making a DIY solution based on the attachRouting() approach.
    * @example ({ app }) => { app.use('/docs', swaggerUi.serve, swaggerUi.setup(swaggerDocument)); }
    * */
-  beforeRouting?: BeforeRouting;
+  beforeRouting?: ServerHook;
+  /**
+   * @desc A code to execute after processing the Routing of your API, but before error handling.
+   * @see beforeRouting
+   * */
+  afterRouting?: ServerHook;
   /**
    * @desc Rejects new connections and attempts to finish ongoing ones in the specified time before exit.
    * */
@@ -622,7 +626,7 @@ declare function createConfig(config: ServerConfig): ServerConfig;
 declare function createConfig(config: AppConfig): AppConfig;
 //#endregion
 //#region src/endpoints-factory.d.ts
-interface BuildProps<IN extends IOSchema, OUT extends IOSchema | z.ZodVoid, MIN extends IOSchema | undefined, OPT extends FlatObject, SCO extends string> {
+interface BuildProps<IN extends IOSchema, OUT extends IOSchema | z.ZodVoid, MIN extends IOSchema | undefined, CTX extends FlatObject, SCO extends string> {
   /**
    * @desc Input schema of the Endpoint, combining properties from all the enabled input sources (path params, headers)
    * @default z.object({})
@@ -631,8 +635,8 @@ interface BuildProps<IN extends IOSchema, OUT extends IOSchema | z.ZodVoid, MIN
   input?: IN;
   /** @desc The schema by which the returns of the Endpoint handler is validated */
   output: OUT;
-  /** @desc The Endpoint handler receiving the validated inputs, returns of added Middlewares (options) and a logger */
-  handler: Handler<z.output<FinalInputSchema<MIN, IN>>, z.input<OUT>, OPT>;
+  /** @desc The Endpoint handler receiving the validated inputs, returns of added Middlewares (ctx) and a logger */
+  handler: Handler<z.output<FinalInputSchema<MIN, IN>>, z.input<OUT>, CTX>;
   /** @desc The operation description for the generated Documentation */
   description?: string;
   /** @desc The operation summary for the generated Documentation (50 symbols max) */
@@ -641,8 +645,7 @@ interface BuildProps<IN extends IOSchema, OUT extends IOSchema | z.ZodVoid, MIN
   operationId?: string | ((method: ClientMethod) => string);
   /**
    * @desc HTTP method(s) this endpoint can handle
-   * @default "get" unless the Endpoint is assigned within DependsOnMethod
-   * @see DependsOnMethod
+   * @default "get" unless method is explicitly defined in Routing keys
    * */
   method?: Method | [Method, ...Method[]];
   /**
@@ -658,19 +661,19 @@ interface BuildProps<IN extends IOSchema, OUT extends IOSchema | z.ZodVoid, MIN
   /** @desc Marks the operation deprecated in the generated Documentation */
   deprecated?: boolean;
 }
-declare class EndpointsFactory<IN extends IOSchema | undefined = undefined, OUT extends FlatObject = EmptyObject, SCO extends string = string> {
+declare class EndpointsFactory<IN extends IOSchema | undefined = undefined, CTX extends FlatObject = EmptyObject, SCO extends string = string> {
   #private;
   protected resultHandler: AbstractResultHandler;
   protected schema: IN;
   protected middlewares: AbstractMiddleware[];
   constructor(resultHandler: AbstractResultHandler);
-  addMiddleware<AOUT extends FlatObject, ASCO extends string, AIN extends IOSchema | undefined = undefined>(subject: Middleware<OUT, AOUT, ASCO, AIN> | ConstructorParameters<typeof Middleware<OUT, AOUT, ASCO, AIN>>[0]): EndpointsFactory<Extension<IN, AIN>, OUT & AOUT, SCO & ASCO>;
-  use: <R extends Request, S extends Response, AOUT extends FlatObject = Record<string, never>>(nativeMw: (request: R, response: S, next: express0.NextFunction) => any, params_1?: {
-    provider?: ((request: R, response: S) => AOUT | Promise<AOUT>) | undefined;
+  addMiddleware<RET extends FlatObject, ASCO extends string, AIN extends IOSchema | undefined = undefined>(subject: Middleware<CTX, RET, ASCO, AIN> | ConstructorParameters<typeof Middleware<CTX, RET, ASCO, AIN>>[0]): EndpointsFactory<Extension<IN, AIN>, CTX & RET, SCO & ASCO>;
+  use: <R extends Request, S$1 extends Response, AOUT extends FlatObject = Record<string, never>>(nativeMw: (request: R, response: S$1, next: express0.NextFunction) => any, params_1?: {
+    provider?: ((request: R, response: S$1) => AOUT | Promise<AOUT>) | undefined;
     transformer?: (err: Error) => Error;
-  } | undefined) => EndpointsFactory<Extension<IN, undefined>, OUT & AOUT, SCO>;
-  addExpressMiddleware<R extends Request, S extends Response, AOUT extends FlatObject = EmptyObject>(...params: ConstructorParameters<typeof ExpressMiddleware<R, S, AOUT>>): EndpointsFactory<Extension<IN, undefined>, OUT & AOUT, SCO>;
-  addOptions<AOUT extends FlatObject>(getOptions: () => Promise<AOUT>): EndpointsFactory<Extension<IN, undefined>, OUT & AOUT, SCO>;
+  } | undefined) => EndpointsFactory<Extension<IN, undefined>, CTX & AOUT, SCO>;
+  addExpressMiddleware<R extends Request, S$1 extends Response, AOUT extends FlatObject = EmptyObject>(...params: ConstructorParameters<typeof ExpressMiddleware<R, S$1, AOUT>>): EndpointsFactory<Extension<IN, undefined>, CTX & AOUT, SCO>;
+  addContext<RET extends FlatObject>(getContext: () => Promise<RET>): EndpointsFactory<Extension<IN, undefined>, CTX & RET, SCO>;
   build<BOUT extends IOSchema, BIN extends IOSchema = EmptySchema>({
     input,
     output: outputSchema,
@@ -679,12 +682,12 @@ declare class EndpointsFactory<IN extends IOSchema | undefined = undefined, OUT
     tag,
     method,
     ...rest
-  }: BuildProps<BIN, BOUT, IN, OUT, SCO>): Endpoint<FinalInputSchema<IN, BIN>, BOUT, OUT>;
+  }: BuildProps<BIN, BOUT, IN, CTX, SCO>): Endpoint<FinalInputSchema<IN, BIN>, BOUT, CTX>;
   /** @desc shorthand for returning {} while having output schema z.object({}) */
   buildVoid<BIN extends IOSchema = EmptySchema>({
     handler,
     ...rest
-  }: Omit<BuildProps<BIN, z.ZodVoid, IN, OUT, SCO>, "output">): Endpoint<FinalInputSchema<IN, BIN>, z.ZodObject<{}, z.core.$strip>, OUT>;
+  }: Omit<BuildProps<BIN, z.ZodVoid, IN, CTX, SCO>, "output">): Endpoint<FinalInputSchema<IN, BIN>, z.ZodObject<{}, z.core.$strip>, CTX>;
 }
 declare const defaultEndpointsFactory: EndpointsFactory<undefined, Record<string, never>, string>;
 /**
@@ -696,11 +699,11 @@ declare const arrayEndpointsFactory: EndpointsFactory<undefined, Record<string,
 //#endregion
 //#region src/server.d.ts
 declare const attachRouting: (config: AppConfig, routing: Routing) => {
-  notFoundHandler: express.RequestHandler<express_serve_static_core2.ParamsDictionary, any, any, qs2.ParsedQs, Record<string, any>>;
+  notFoundHandler: express.RequestHandler<express_serve_static_core0.ParamsDictionary, any, any, qs0.ParsedQs, Record<string, any>>;
   logger: AbstractLogger | BuiltinLogger;
 };
 declare const createServer: (config: ServerConfig, routing: Routing) => Promise<{
-  app: express_serve_static_core2.Express;
+  app: express_serve_static_core0.Express;
   logger: AbstractLogger | BuiltinLogger;
   servers: (http.Server<typeof http.IncomingMessage, typeof http.ServerResponse> | https.Server<typeof http.IncomingMessage, typeof http.ServerResponse>)[];
 }>;
@@ -749,6 +752,7 @@ interface DocumentationParams {
   /**
    * @desc Depict the HEAD method for each Endpoint supporting the GET method (feature of Express)
    * @default true
+   * @todo move to config
    * */
   hasHeadMethod?: boolean;
   /** @default inline */
@@ -865,26 +869,26 @@ declare const testEndpoint: <LOG extends FlatObject, REQ extends RequestOptions>
   /** @desc The endpoint to test */
   endpoint: AbstractEndpoint;
 }) => Promise<{
-  requestMock: node_mocks_http0.MockRequest<Request<express_serve_static_core2.ParamsDictionary, any, any, qs2.ParsedQs, Record<string, any>> & REQ>;
+  requestMock: node_mocks_http0.MockRequest<Request<express_serve_static_core0.ParamsDictionary, any, any, qs0.ParsedQs, Record<string, any>> & REQ>;
   responseMock: node_mocks_http0.MockResponse<Response<any, Record<string, any>>>;
   loggerMock: AbstractLogger & LOG & {
-    _getLogs: () => Record<"error" | "debug" | "info" | "warn", unknown[]>;
+    _getLogs: () => Record<"debug" | "info" | "warn" | "error", unknown[]>;
   };
 }>;
 declare const testMiddleware: <LOG extends FlatObject, REQ extends RequestOptions>({
   middleware,
-  options,
+  ctx,
   ...rest
 }: TestingProps<REQ, LOG> & {
   /** @desc The middleware to test */
   middleware: AbstractMiddleware;
-  /** @desc The aggregated output from previously executed middlewares */
-  options?: FlatObject;
+  /** @desc The aggregated returns of previously executed middlewares */
+  ctx?: FlatObject;
 }) => Promise<{
-  requestMock: node_mocks_http0.MockRequest<Request<express_serve_static_core2.ParamsDictionary, any, any, qs2.ParsedQs, Record<string, any>> & REQ>;
+  requestMock: node_mocks_http0.MockRequest<Request<express_serve_static_core0.ParamsDictionary, any, any, qs0.ParsedQs, Record<string, any>> & REQ>;
   responseMock: node_mocks_http0.MockResponse<Response<any, Record<string, any>>>;
   loggerMock: AbstractLogger & LOG & {
-    _getLogs: () => Record<"error" | "debug" | "info" | "warn", unknown[]>;
+    _getLogs: () => Record<"debug" | "info" | "warn" | "error", unknown[]>;
   };
   output: FlatObject;
 }>;
@@ -903,10 +907,10 @@ interface NextHandlerInc<U> {
 interface PrevInc<U> {
   prev: U;
 }
-type SchemaHandler<U, Context extends FlatObject = EmptyObject, Variant extends "regular" | "each" | "last" = "regular"> = (schema: any,
+type SchemaHandler<U, Context$1 extends FlatObject = EmptyObject, Variant extends "regular" | "each" | "last" = "regular"> = (schema: any,
 // eslint-disable-line @typescript-eslint/no-explicit-any -- for assignment 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>>>;
+ctx: Context$1 & (Variant extends "regular" ? NextHandlerInc<U> : Variant extends "each" ? PrevInc<U> : Context$1)) => U;
+type HandlingRules<U, Context$1 extends FlatObject = EmptyObject, K$1 extends string | symbol = string | symbol> = Partial<Record<K$1, SchemaHandler<U, Context$1>>>;
 //#endregion
 //#region src/zts-helpers.d.ts
 interface ZTSContext extends FlatObject {
@@ -918,6 +922,7 @@ type Producer = SchemaHandler<ts.TypeNode, ZTSContext>;
 //#region src/integration.d.ts
 interface IntegrationParams {
   routing: Routing;
+  config: CommonConfig;
   /**
    * @desc What should be generated
    * @example "types" — types of your endpoint requests and responses (for a DIY solution)
@@ -942,6 +947,7 @@ interface IntegrationParams {
   /**
    * @desc Depict the HEAD method for each Endpoint supporting the GET method (feature of Express)
    * @default true
+   * @todo move to config
    * */
   hasHeadMethod?: boolean;
   /**
@@ -965,6 +971,7 @@ declare class Integration extends IntegrationBase {
   #private;
   constructor({
     routing,
+    config,
     brandHandling,
     variant,
     clientClassName,
@@ -988,7 +995,7 @@ interface Emitter<E extends EventsMap> extends FlatObject {
   /** @desc Abort signal bound to the client connection lifecycle */
   signal: AbortSignal;
   /** @desc Sends an event to the stream according to the declared schema */
-  emit: <K extends keyof E>(event: K, data: z.input<E[K]>) => void;
+  emit: <K$1 extends keyof E>(event: K$1, data: z.input<E[K$1]>) => void;
 }
 declare class EventStreamFactory<E extends EventsMap> extends EndpointsFactory<undefined, Emitter<E>> {
   constructor(events: E);
@@ -1009,13 +1016,13 @@ declare const base: z.ZodObject<{
   raw: z.core.$ZodBranded<z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, symbol>;
 }, z.core.$strip>;
 type Base = ReturnType<typeof base.brand<symbol>>;
-declare const extended: <S extends z.core.$ZodShape>(extra: S) => z.core.$ZodBranded<z.ZodObject<("raw" & keyof S extends never ? {
+declare const extended: <S$1 extends z.core.$ZodShape>(extra: S$1) => z.core.$ZodBranded<z.ZodObject<("raw" & keyof S$1 extends never ? {
   raw: z.core.$ZodBranded<z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, symbol>;
-} & S : ({
+} & S$1 : ({
   raw: z.core.$ZodBranded<z.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, symbol>;
-} extends infer T_1 extends z.core.util.SomeObject ? { [K in keyof T_1 as K extends keyof S ? never : K]: T_1[K] } : never) & { [K_1 in keyof S]: S[K_1] }) extends infer T ? { [k in keyof T]: T[k] } : never, z.core.$strip>, symbol>;
+} extends infer T_1 extends z.core.util.SomeObject ? { [K in keyof T_1 as K extends keyof S$1 ? never : K]: T_1[K] } : never) & { [K_1 in keyof S$1]: S$1[K_1] }) extends infer T ? { [k in keyof T]: T[k] } : never, z.core.$strip>, symbol>;
 declare function raw(): Base;
-declare function raw<S extends z.core.$ZodShape>(extra: S): ReturnType<typeof extended<S>>;
+declare function raw<S$1 extends z.core.$ZodShape>(extra: S$1): ReturnType<typeof extended<S$1>>;
 //#endregion
 //#region src/proprietary-schemas.d.ts
 declare const ez: {
@@ -1024,10 +1031,10 @@ declare const ez: {
     ...rest
   }?: DateInParams) => zod_v4_core0.$ZodBranded<zod0.ZodPipe<zod0.ZodPipe<zod0.ZodUnion<readonly [zod0.ZodISODate, zod0.ZodISODateTime, zod0.ZodISODateTime]>, zod0.ZodTransform<Date, string>>, zod0.ZodDate>, symbol>;
   dateOut: (meta?: DateOutParams) => zod_v4_core0.$ZodBranded<zod0.ZodPipe<zod0.ZodDate, zod0.ZodTransform<string, Date>>, symbol>;
-  form: <S extends zod_v4_core0.$ZodShape>(base: S | zod0.ZodObject<S>) => zod_v4_core0.$ZodBranded<zod0.ZodObject<S, zod_v4_core0.$strip>, symbol>;
+  form: <S$1 extends zod_v4_core0.$ZodShape>(base: S$1 | zod0.ZodObject<S$1>) => zod_v4_core0.$ZodBranded<zod0.ZodObject<S$1, zod_v4_core0.$strip>, symbol>;
   upload: () => zod_v4_core0.$ZodBranded<zod0.ZodCustom<express_fileupload0.UploadedFile, express_fileupload0.UploadedFile>, symbol>;
   raw: typeof raw;
   buffer: () => zod_v4_core0.$ZodBranded<zod0.ZodCustom<Buffer<ArrayBufferLike>, Buffer<ArrayBufferLike>>, symbol>;
 };
 //#endregion
-export { type ApiResponse, type AppConfig, type BasicSecurity, type BearerSecurity, BuiltinLogger, type CommonConfig, type CookieSecurity, DependsOnMethod, type Depicter, Documentation, DocumentationError, EndpointsFactory, EventStreamFactory, type FlatObject, type HeaderSecurity, 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, type TagOverrides, arrayEndpointsFactory, arrayResultHandler, attachRouting, createConfig, createServer, defaultEndpointsFactory, defaultResultHandler, ensureHttpError, ez, getMessageFromError, testEndpoint, testMiddleware };
+export { type ApiResponse, type AppConfig, type BasicSecurity, type BearerSecurity, BuiltinLogger, type CommonConfig, type CookieSecurity, type Depicter, Documentation, DocumentationError, EndpointsFactory, EventStreamFactory, type FlatObject, type HeaderSecurity, 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, type TagOverrides, arrayEndpointsFactory, arrayResultHandler, attachRouting, createConfig, createServer, defaultEndpointsFactory, defaultResultHandler, ensureHttpError, ez, getMessageFromError, testEndpoint, testMiddleware };