express-zod-api 28.7.5 → 29.0.0-beta.3

package/dist/index.d.ts

@@ -1,690 +1,51 @@
+import {
+  A as ensureHttpError,
+  C as CommonConfig,
+  D as ResultHandler,
+  E as AbstractResultHandler,
+  F as Method,
+  I as BuiltinLogger,
+  L as AbstractLogger,
+  M as FinalInputSchema,
+  N as IOSchema,
+  O as arrayResultHandler,
+  P as ClientMethod,
+  R as LoggerOverrides,
+  S as AppConfig,
+  T as createConfig,
+  _ as EmptySchema,
+  a as Handler,
+  b as TagOverrides,
+  c as Middleware,
+  d as CookieSecurity,
+  f as HeaderSecurity,
+  g as EmptyObject,
+  h as OpenIdSecurity,
+  i as Endpoint,
+  j as Extension,
+  k as defaultResultHandler,
+  l as BasicSecurity,
+  m as OAuth2Security,
+  n as ServeStatic,
+  o as AbstractMiddleware,
+  p as InputSecurity,
+  r as AbstractEndpoint,
+  s as ExpressMiddleware,
+  t as Routing,
+  u as BearerSecurity,
+  v as FlatObject,
+  w as ServerConfig,
+  x as getMessageFromError,
+  y as Tag,
+  z as ApiResponse,
+} from "./routing-C0jFxoT6.js";
+import { i as OpenAPIContext } from "./documentation-helpers-BLgXFiWr.js";
 import { z } from "zod";
-import { HttpError } from "http-errors";
-import express, { CookieOptions, IRouter, NextFunction, Request, RequestHandler, Response } from "express";
+import express, { CookieOptions, Request, Response } from "express";
 import http from "node:http";
-import { ServerOptions } from "node:https";
-import { OpenApiBuilder, ReferenceObject, SchemaObject, TagObject } from "openapi3-ts/oas31";
 import { RequestOptions, ResponseOptions } from "node-mocks-http";
-import compression from "compression";
-import fileUpload from "express-fileupload";
-import cookieParser from "cookie-parser";
-import { ListenOptions } from "node:net";
+import "express-fileupload";
 import { AugmentedRequest, Options, RateLimitInfo, RateLimitRequestHandler } from "express-rate-limit";
-import ts from "typescript";
-declare const methods: ("get" | "post" | "put" | "delete" | "patch")[];
-declare const clientMethods: ("get" | "post" | "put" | "delete" | "patch" | "head")[];
-/**
- * @desc Methods supported by the framework API to produce Endpoints on EndpointsFactory.
- * @see BuildProps
- * @example "get" | "post" | "put" | "delete" | "patch"
- * */
-type Method = (typeof methods)[number];
-/**
- * @desc Methods usable on the client side, available via generated Integration and Documentation
- * @see withHead
- * @example Method | "head"
- * */
-type ClientMethod = (typeof clientMethods)[number];
-declare const defaultStatusCodes: {
-  positive: number;
-  negative: number;
-};
-type ResponseVariant = keyof typeof defaultStatusCodes;
-/**
- * @desc A container for describing an API response: its schema, status code(s) and MIME type(s).
- * @see ResultHandler
- * */
-interface ApiResponse<S extends z.ZodType> {
-  /** @desc The Zod schema describing the response body. */
-  schema: S;
-  /**
-   * @desc The status code(s) for this response.
-   * @default 200 for a positive response, 400 for a negative one
-   * */
-  statusCode?: number | [number, ...number[]];
-  /**
-   * @desc The MIME type(s) of the response.
-   * @default "application/json"
-   * @example null — no content, typical for 204 and 302
-   * */
-  mimeType?: string | [string, ...string[]] | null;
-}
-/** @since zod 3.25.61 output type fixed */
-declare const emptySchema: z.ZodObject<{}, z.core.$strip>;
-type EmptySchema = typeof emptySchema;
-/** @desc this type does not allow props assignment, but it works for reading them when merged with another interface */
-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;
-/**
- * @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 } }
- * @link https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
- * */
-interface TagOverrides {}
-type Tag = NoNever<keyof TagOverrides, string>;
-declare const getMessageFromError: (error: Error) => string;
-declare const severity: {
-  debug: number;
-  info: number;
-  warn: number;
-  error: number;
-};
-type Severity = keyof typeof severity;
-/** @desc You can use any logger compatible with this type. */
-type AbstractLogger = Record<Severity, (message: string, meta?: any) => any>;
-/**
- * @desc Using module augmentation approach you can set the type of the actual logger used
- * @example declare module "express-zod-api" { interface LoggerOverrides extends winston.Logger {} }
- * @link https://www.typescriptlang.org/docs/handbook/declaration-merging.html#module-augmentation
- * */
-interface LoggerOverrides {}
-type ActualLogger = AbstractLogger & LoggerOverrides;
-interface Context extends FlatObject {
-  requestId?: string;
-}
-interface BuiltinLoggerConfig {
-  /**
-   * @desc The minimal severity to log or "silent" to disable logging
-   * @example "debug" also enables pretty output for inspected entities
-   * */
-  level: "silent" | "warn" | "info" | "debug";
-  /** @desc Enables colors on printed severity and inspected entities */
-  color: boolean;
-  /**
-   * @desc Control how deeply entities should be inspected
-   * @example null
-   * @example Infinity
-   * */
-  depth: number | null;
-  /**
-   * @desc Context: the metadata applicable for each logged entry, used by .child() method
-   * @see childLoggerProvider
-   * */
-  ctx: Context;
-}
-interface ProfilerOptions {
-  message: string;
-  /** @default "debug" */
-  severity?: Severity | ((ms: number) => Severity);
-  /** @default formatDuration - adaptive units and limited fraction */
-  formatter?: (ms: number) => string | number;
-}
-/** @desc Built-in console logger with optional colorful inspections */
-declare class BuiltinLogger implements AbstractLogger {
-  protected readonly config: BuiltinLoggerConfig;
-  /** @example new BuiltinLogger({ level: "debug", color: true, depth: 4 }) */
-  constructor({ color, level, depth, ctx }?: Partial<BuiltinLoggerConfig>);
-  protected format(subject: unknown): string;
-  protected print(method: Severity, message: string, meta?: unknown): void;
-  debug(message: string, meta?: unknown): void;
-  info(message: string, meta?: unknown): void;
-  warn(message: string, meta?: unknown): void;
-  error(message: string, meta?: unknown): void;
-  child(ctx: Context): BuiltinLogger;
-  /**
-   * @desc The argument used for instance created by .child() method
-   * @see ChildLoggerProvider
-   * */
-  get ctx(): Context;
-  /** @desc Measures the duration until you invoke the returned callback */
-  profile(message: string): () => void;
-  profile(options: ProfilerOptions): () => void;
-}
-type Base$1 = object & {
-  [Symbol.iterator]?: never;
-};
-/** @desc The type allowed on the top level of Middlewares and Endpoints */
-type IOSchema = z.ZodType<Base$1>;
-/** EndpointsFactory schema extended type when adding a Middleware */
-type Extension<Current extends IOSchema | undefined, Inc extends IOSchema | undefined> = Current extends IOSchema
-  ? Inc extends IOSchema
-    ? z.ZodIntersection<Current, Inc>
-    : Current
-  : Inc;
-/** The Endpoint input schema type, condition wrapped into schema to make it z.output-compatible */
-type FinalInputSchema<FIN extends IOSchema | undefined, BIN extends IOSchema> = z.ZodIntersection<
-  FIN extends IOSchema ? FIN : BIN,
-  BIN
->;
-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 HeaderSecurity {
-  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 Middleware security schema descriptor
- * @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 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
-   * */
-  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<RET>;
-declare abstract class AbstractMiddleware {
-  abstract execute(params: {
-    input: unknown;
-    ctx: FlatObject;
-    request: Request;
-    response: Response;
-    logger: ActualLogger;
-  }): Promise<FlatObject>;
-}
-/**
- * @desc A Middleware that validates its input schema, executes its handler, and returns context properties available to
- *       next middlewares and the Endpoint handler. Can also declare security schemas for Documentation.
- * @see EndpointsFactory#addMiddleware
- * */
-declare class Middleware<
-  CTX extends FlatObject,
-  RET extends FlatObject,
-  SCO extends string,
-  IN extends IOSchema | undefined = undefined,
-> extends AbstractMiddleware {
-  constructor({
-    input,
-    security,
-    handler,
-  }: {
-    /**
-     * @desc Input schema of the Middleware, combining properties from all the enabled input sources
-     * @default undefined
-     * @see defaultInputSources
-     * */
-    input?: IN;
-    /**
-     * @desc Declaration of the security schemas implemented within the handler (used by Documentation).
-     * @see Documentation
-     * */
-    security?: LogicalContainer<Security<Extract<keyof z.input<IN>, string>, SCO>>;
-    /** @desc The handler returning a context available to Endpoints. */
-    handler: Handler$2<z.output<IN>, CTX, RET>;
-  });
-  /** @throws InputValidationError */
-  execute({
-    input,
-    ...rest
-  }: {
-    input: unknown;
-    ctx: CTX;
-    request: Request;
-    response: Response;
-    logger: ActualLogger;
-  }): Promise<RET>;
-}
-/**
- * @desc A wrapper around native Express middlewares that converts them into the framework's Middleware instances.
- *       Optionally, a `provider` can extend the context, and a `transformer` can convert caught errors.
- * @see EndpointsFactory#addExpressMiddleware
- * */
-declare class ExpressMiddleware<R extends Request, S extends Response, RET extends FlatObject> extends Middleware<
-  FlatObject,
-  RET,
-  string
-> {
-  constructor(
-    nativeMw: (request: R, response: S, next: NextFunction) => any,
-    {
-      provider,
-      transformer,
-    }?: {
-      /** @desc Extracts context properties from request and response after the native middleware execution. */
-      provider?: (request: R, response: S) => RET | Promise<RET>;
-      /** @desc Transforms errors caught from the native middleware before they propagate further. */
-      transformer?: (err: Error) => Error;
-    },
-  );
-}
-type ResultSchema<R extends Result> = R extends Result<infer S> ? S : never;
-type DiscriminatedResult =
-  | {
-      output: FlatObject;
-      error: null;
-    }
-  | {
-      output: null;
-      error: Error;
-    };
-/**
- * @example InputValidationError —> BadRequest(400)
- * @example Error —> InternalServerError(500)
- * */
-declare const ensureHttpError: (error: Error) => HttpError;
-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 the presence of the required property using the "in" operator */
-    ctx: FlatObject;
-    request: Request;
-    response: Response<RES>;
-    logger: ActualLogger;
-  },
-) => void | Promise<void>;
-/**
- * @desc Result definition for ResultHandler: a plain schema (for JSON and default status codes) or custom ApiResponse.
- * @see ApiResponse
- * */
-type Result<S extends z.ZodType = z.ZodType> = S | ApiResponse<S> | ApiResponse<S>[];
-/** @desc A function that lazily produces a Result definition. */
-type LazyResult<R extends Result, A extends unknown[] = []> = (...args: A) => R;
-declare abstract class AbstractResultHandler {
-  protected constructor(handler: Handler$1);
-  execute(...params: Parameters<Handler$1>): Promise<void>;
-}
-/**
- * @desc The entity responsible to respond consistently. Accepts positive and negative Result definitions.
- *       The positive definition can be a lazy function receiving the output schema of an Endpoint.
- * @see Result
- * */
-declare class ResultHandler<POS extends Result, NEG extends Result> extends AbstractResultHandler {
-  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>>>;
-  });
-}
-/**
- * @desc The default ResultHandler wrapping Endpoint output in `{ status: "success", data: output }`
- *       and errors in `{ status: "error", error: { message } }`. Responds with JSON Content-Type.
- *       Respects the status of errors from createHttpError(), others become InternalServerError (500).
- * @see ensureHttpError
- * */
-declare const defaultResultHandler: ResultHandler<
-  z.ZodObject<
-    {
-      status: z.ZodLiteral<"success">;
-      data: IOSchema;
-    },
-    z.core.$strip
-  >,
-  z.ZodObject<
-    {
-      status: z.ZodLiteral<"error">;
-      error: z.ZodObject<
-        {
-          message: z.ZodString;
-        },
-        z.core.$strip
-      >;
-    },
-    z.core.$strip
-  >
->;
-/**
- * @deprecated Resist the urge of using it: this handler is designed only to simplify the migration of legacy APIs.
- * @desc Responding with an 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: ResultHandler<
-  z.ZodArray<z.core.$ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>> | z.ZodArray<z.ZodAny>,
-  {
-    schema: z.ZodString;
-    mimeType: string;
-  }
->;
-type OriginalStatic = typeof express.static;
-declare class ServeStatic {
-  constructor(...params: Parameters<OriginalStatic>);
-}
-/** @desc Returns child logger for the given request (if configured) or the configured logger otherwise */
-type GetLogger = (request?: Request) => ActualLogger;
-/**
- * @example { v1: { books: { ":bookId": getBookEndpoint } } }
- * @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.recognizeMethodDependentRoutes
- * */
-interface Routing {
-  [K: string]: Routing | AbstractEndpoint | ServeStatic;
-}
-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 */
-  ctx: CTX;
-  /** @desc The instance of the configured logger */
-  logger: ActualLogger;
-}) => Promise<OUT>;
-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;
-    logger: ActualLogger;
-    config: CommonConfig;
-  }): Promise<void>;
-}
-declare class Endpoint<IN extends IOSchema, OUT extends IOSchema, CTX extends FlatObject> extends AbstractEndpoint {
-  constructor(def: {
-    deprecated?: boolean;
-    middlewares?: AbstractMiddleware[];
-    inputSchema: IN;
-    outputSchema: OUT;
-    handler: Handler<z.output<IN>, z.input<OUT>, CTX>;
-    resultHandler: AbstractResultHandler;
-    description?: string;
-    summary?: string;
-    getOperationId?: (method: ClientMethod) => string | undefined;
-    methods?: Method[];
-    scopes?: string[];
-    tags?: string[];
-  });
-  deprecated(): this;
-  execute({
-    request,
-    response,
-    logger,
-    config,
-  }: {
-    request: Request;
-    response: Response;
-    logger: ActualLogger;
-    config: CommonConfig;
-  }): Promise<undefined>;
-}
-type InputSource = keyof Pick<Request, "query" | "body" | "files" | "params" | "headers" | "cookies" | "signedCookies">;
-type InputSources = Record<Method, InputSource[]>;
-type Headers = Record<string, string>;
-type HeadersProvider = (params: {
-  /** @desc The default headers to be overridden. */
-  defaultHeaders: Headers;
-  request: Request;
-  endpoint: AbstractEndpoint;
-  logger: ActualLogger;
-}) => Headers | Promise<Headers>;
-type ChildLoggerProvider = (params: { request: Request; parent: ActualLogger }) => ActualLogger | Promise<ActualLogger>;
-type LogAccess = (request: Request, logger: ActualLogger) => void;
-interface CommonConfig {
-  /**
-   * @desc Enables cross-origin resource sharing.
-   * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS
-   * @desc You can override the default CORS headers by setting up a provider function here.
-   */
-  cors: boolean | HeadersProvider;
-  /**
-   * @desc Controls how to respond to a request to an existing endpoint with an invalid HTTP method.
-   * @example true — respond with status code 405 and "Allow" header containing a list of valid methods
-   * @example false — respond with status code 404 (Not found)
-   * @default true
-   */
-  hintAllowedMethods?: boolean;
-  /**
-   * @desc Controls how to treat Routing keys matching HTTP methods ("get", "post") and having Endpoint assigned.
-   * @example true — treat such keys as HTTP methods complementing their parent paths
-   *          { users: { get: ... }} becomes GET /users
-   * @example false — treat such keys as nested path segments regardless of the name
-   *          { users: { get: ... }} remains /users/get
-   * @default true
-   */
-  recognizeMethodDependentRoutes?: boolean;
-  /**
-   * @desc The ResultHandler to use for handling routing, parsing and upload errors
-   * @default defaultResultHandler
-   * @see defaultResultHandler
-   */
-  errorHandler?: AbstractResultHandler;
-  /**
-   * @desc Built-in logger configuration or an instance of any compatible logger.
-   * @example { level: "debug", color: true }
-   * @default { level: NODE_ENV === "production" ? "warn" : "debug", color: isSupported(), depth: 2 }
-   * */
-  logger?: Partial<BuiltinLoggerConfig> | AbstractLogger;
-  /**
-   * @desc A child logger returned by this function can override the logger in all handlers for each request
-   * @example ({ parent }) => parent.child({ requestId: uuid() })
-   * */
-  childLoggerProvider?: ChildLoggerProvider;
-  /**
-   * @desc The function for producing access logs
-   * @default ({ method, path }, logger) => logger.debug(`${method}: ${path}`)
-   * @example null — disables the feature
-   * */
-  accessLogger?: null | LogAccess;
-  /**
-   * @desc You can disable the startup logo.
-   * @default true
-   */
-  startupLogo?: boolean;
-  /**
-   * @desc Which properties of request are combined into the input for endpoints and middlewares.
-   * @desc The order matters: priority from lowest to highest
-   * @default defaultInputSources
-   * @see defaultInputSources
-   */
-  inputSources?: Partial<InputSources>;
-}
-type BeforeUpload = (params: { request: Request; logger: ActualLogger }) => void | Promise<void>;
-type UploadOptions = Pick<
-  fileUpload.Options,
-  | "createParentPath"
-  | "uriDecodeFileNames"
-  | "safeFileNames"
-  | "preserveExtension"
-  | "useTempFiles"
-  | "tempFileDir"
-  | "debug"
-  | "uploadTimeout"
-  | "limits"
-> & {
-  /**
-   * @desc The error to throw when the file exceeds the configured fileSize limit (handled by errorHandler).
-   * @see limits
-   * @override limitHandler
-   * @example createHttpError(413, "The file is too large")
-   * */
-  limitError?: Error;
-  /**
-   * @desc A handler to execute before uploading — it can be used for restrictions by throwing an error.
-   * @example ({ request }) => { throw createHttpError(403, "Not authorized"); }
-   * */
-  beforeUpload?: BeforeUpload;
-};
-interface CookieParserOptions extends cookieParser.CookieParseOptions {
-  /** @desc The secret string or array used by cookie-parser for signed cookies */
-  secret?: Parameters<typeof cookieParser>[0];
-}
-type CompressionOptions = Pick<
-  compression.CompressionOptions,
-  "threshold" | "level" | "strategy" | "chunkSize" | "memLevel"
->;
-interface GracefulOptions {
-  /**
-   * @desc Time given to drain ongoing requests before closing the server.
-   * @default 1000
-   * */
-  timeout?: number;
-  /**
-   * @desc Process event (Signal) that triggers the graceful shutdown.
-   * @see Signals
-   * @default [SIGINT, SIGTERM]
-   * */
-  events?: string[];
-  /** @desc The hook to call after the server was closed, but before terminating the process. */
-  beforeExit?: () => void | Promise<void>;
-}
-/** @todo consider removing Promise to make createServer sync in next major */
-type ServerHook = (params: {
-  app: IRouter;
-  /** @desc Returns child logger for the given request (if configured) or the configured logger otherwise */
-  getLogger: GetLogger;
-}) => void | Promise<void>;
-interface HttpConfig {
-  /** @desc Port, UNIX socket or custom options. */
-  listen: number | string | ListenOptions;
-}
-interface HttpsConfig extends HttpConfig {
-  /** @desc At least "cert" and "key" options required. */
-  options: ServerOptions;
-}
-interface ServerConfig extends CommonConfig {
-  /** @desc HTTP server configuration. */
-  http?: HttpConfig;
-  /** @desc HTTPS server configuration. */
-  https?: HttpsConfig;
-  /**
-   * @desc Custom JSON parser.
-   * @default express.json()
-   * @link https://expressjs.com/en/5x/api.html#express.json
-   * */
-  jsonParser?: RequestHandler;
-  /**
-   * @desc Enable or configure uploads handling.
-   * @requires express-fileupload
-   * */
-  upload?: boolean | UploadOptions;
-  /**
-   * @desc Enable or configure response compression.
-   * @requires compression
-   */
-  compression?: boolean | CompressionOptions;
-  /**
-   * @desc Enable cookie parsing via cookie-parser.
-   * @requires cookie-parser
-   * @example true
-   * @example { secret: "my-secret" }
-   */
-  cookies?: boolean | CookieParserOptions;
-  /**
-   * @desc Configure or customize the parser for request query string
-   * @example "simple" // for "node:querystring" module, array elements must be repeated: ?a=1&a=2
-   * @example "extended" // for "qs" module, supports nested objects and arrays with brackets: ?a[]=1&a[]=2
-   * @example (query) => qs.parse(query, {comma: true}) // for comma-separated arrays: ?a=1,2,3
-   * @default "simple"
-   * @link https://expressjs.com/en/5x/api.html#req.query
-   */
-  queryParser?: "simple" | "extended" | ((query: string) => object);
-  /**
-   * @desc Custom raw parser (assigns Buffer to request body)
-   * @default express.raw()
-   * @link https://expressjs.com/en/5x/api.html#express.raw
-   * */
-  rawParser?: RequestHandler;
-  /**
-   * @desc Custom parser for URL Encoded requests used for submitting HTML forms
-   * @default express.urlencoded()
-   * @link https://expressjs.com/en/5x/api.html#express.urlencoded
-   * */
-  formParser?: RequestHandler;
-  /**
-   * @desc A code to execute before processing the Routing of your API (and before parsing).
-   * @desc This can be a good place for express middlewares establishing their own routes.
-   * @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?: 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.
-   * */
-  gracefulShutdown?: boolean | GracefulOptions;
-}
-interface AppConfig extends CommonConfig {
-  /** @desc Your custom express app or express router instead. */
-  app: IRouter;
-}
-declare function createConfig(config: ServerConfig): ServerConfig;
-declare function createConfig(config: AppConfig): AppConfig;
 /**
  * @desc Directives shared by both request and response Cache-Control headers.
  * @see https://developer.mozilla.org/en-US/docs/Web/HTTP/Reference/Headers/Cache-Control#cache_directives
@@ -1108,101 +469,11 @@ declare const attachRouting: (
 declare const createServer: (
   config: ServerConfig,
   routing: Routing,
-) => Promise<{
+) => {
   app: import("express-serve-static-core").Express;
   logger: AbstractLogger | BuiltinLogger;
   servers: http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>[];
-}>;
-interface ReqResCommons {
-  makeRef: (key: object | string, value: SchemaObject | ReferenceObject, proposedName?: string) => ReferenceObject;
-  path: string;
-  method: ClientMethod;
-}
-interface OpenAPIContext extends ReqResCommons {
-  isResponse: boolean;
-}
-type Depicter = (
-  zodCtx: {
-    zodSchema: z.core.$ZodType;
-    jsonSchema: z.core.JSONSchema.BaseSchema;
-  },
-  oasCtx: OpenAPIContext,
-) => z.core.JSONSchema.BaseSchema | SchemaObject;
-/** @desc Using defaultIsHeader when returns null or undefined */
-type IsHeader = (name: string, method: ClientMethod, path: string) => boolean | null | undefined;
-type BrandHandling = Record<string | symbol, Depicter>;
-declare const depictTags: (
-  tags: Partial<
-    Record<
-      Tag,
-      | string
-      | {
-          description: string;
-          url?: string;
-        }
-    >
-  >,
-) => TagObject[];
-/** @desc Ensures the summary string does not exceed the limit */
-declare const trimSummary: (summary?: string, limit?: number) => string | undefined;
-type Component = `${ResponseVariant}Response` | "requestParameter" | "requestBody";
-/** @desc user defined function that creates a component description from its properties */
-type Descriptor = (
-  props: Record<"method" | "path" | "operationId", string> & {
-    statusCode?: number;
-  },
-) => string;
-type Summarizer = (params: { summary?: string; description?: string; trim: typeof trimSummary }) => string | undefined;
-interface DocumentationParams {
-  title: string;
-  version: string;
-  serverUrl: string | [string, ...string[]];
-  routing: Routing;
-  config: CommonConfig;
-  /**
-   * @desc Descriptions of various components based on their properties (method, path, operationId).
-   * @desc When composition set to "components", component name is generated from this description
-   * @default () => `${method} ${path} ${component}`
-   * */
-  descriptions?: Partial<Record<Component, Descriptor>>;
-  /**
-   * @desc The function that ensures the maximum length for summary fields. Can optionally make them from descriptions.
-   * @see defaultSummarizer
-   * @see trimSummary
-   * */
-  summarizer?: Summarizer;
-  /**
-   * @desc Depict the HEAD method for each Endpoint supporting the GET method (feature of Express)
-   * @default true
-   * */
-  hasHeadMethod?: boolean;
-  /** @default inline */
-  composition?: "inline" | "components";
-  /**
-   * @desc Handling rules for your own schemas branded with `x-brand` metadata.
-   * @desc Keys: brands (recommended to use unique symbols).
-   * @desc Values: functions having Zod context as first argument, second one is the framework context.
-   * @example { MyBrand: ({ zodSchema, jsonSchema }) => ({ type: "object" })
-   * @link https://www.npmjs.com/package/@express-zod-api/zod-plugin
-   */
-  brandHandling?: BrandHandling;
-  /**
-   * @desc Ability to configure recognition of headers among other input data
-   * @desc Only applicable when "headers" is present within inputSources config option
-   * @see defaultIsHeader
-   * @link https://www.iana.org/assignments/http-fields/http-fields.xhtml
-   * */
-  isHeader?: IsHeader;
-  /**
-   * @desc Extended description of tags used in endpoints. For enforcing constraints:
-   * @see TagOverrides
-   * @example { users: "About users", files: { description: "About files", url: "https://example.com" } }
-   * */
-  tags?: Parameters<typeof depictTags>[0];
-}
-declare class Documentation extends OpenApiBuilder {
-  constructor({ hasHeadMethod, ...rest }: DocumentationParams);
-}
+};
 /** @desc An error related to the wrong Routing declaration */
 declare class RoutingError extends Error {
   name: string;
@@ -1282,7 +553,7 @@ declare const testEndpoint: <LOG extends FlatObject, REQ extends RequestOptions>
   responseMock: import("node-mocks-http").MockResponse<Response<any, Record<string, any>>>;
   loggerMock: AbstractLogger &
     LOG & {
-      _getLogs: () => Record<"debug" | "info" | "warn" | "error", unknown[]>;
+      _getLogs: () => Record<"error" | "debug" | "info" | "warn", unknown[]>;
     };
 }>;
 interface MiddlewareLike<RET extends FlatObject> {
@@ -1312,98 +583,9 @@ declare const testMiddleware: <LOG extends FlatObject, REQ extends RequestOption
   responseMock: import("node-mocks-http").MockResponse<Response<any, Record<string, any>>>;
   loggerMock: AbstractLogger &
     LOG & {
-      _getLogs: () => Record<"debug" | "info" | "warn" | "error", unknown[]>;
+      _getLogs: () => Record<"error" | "debug" | "info" | "warn", unknown[]>;
     };
 }>;
-declare abstract class IntegrationBase {
-  protected readonly serverUrl: string;
-  protected constructor(typescript: typeof ts, serverUrl: string);
-}
-interface NextHandlerInc<U> {
-  next: (schema: z.core.$ZodType) => U;
-}
-type SchemaHandler<U, Context extends FlatObject = EmptyObject, Variant extends "regular" | "last" = "regular"> = (
-  schema: any, // eslint-disable-line @typescript-eslint/no-explicit-any -- for assignment compatibility
-  ctx: Context & (Variant extends "regular" ? NextHandlerInc<U> : Context),
-) => U;
-type HandlingRules<U, Context extends FlatObject = EmptyObject, K extends string | symbol = string | symbol> = Partial<
-  Record<K, SchemaHandler<U, Context>>
->;
-interface ZTSContext extends FlatObject {
-  isResponse: boolean;
-  makeAlias: (key: object, produce: () => ts.TypeNode) => ts.TypeNode;
-}
-type Producer = SchemaHandler<ts.TypeNode, ZTSContext>;
-interface IntegrationParams {
-  /** @default loadPeer("typescript") */
-  typescript?: typeof ts;
-  routing: Routing;
-  config: CommonConfig;
-  /**
-   * @desc What should be generated
-   * @example "types" — types of your endpoint requests and responses (for a DIY solution)
-   * @example "client" — an entity for performing typed requests and receiving typed responses
-   * @default "client"
-   * */
-  variant?: "types" | "client";
-  /** @default Client */
-  clientClassName?: string;
-  /** @default Subscription */
-  subscriptionClassName?: string;
-  /**
-   * @desc The API URL to use in the generated code
-   * @default https://example.com
-   * */
-  serverUrl?: string;
-  /**
-   * @desc The schema to use for responses without body such as 204
-   * @default z.undefined()
-   * */
-  noBodySchema?: z.ZodType;
-  /**
-   * @desc Depict the HEAD method for each Endpoint supporting the GET method (feature of Express)
-   * @default true
-   * */
-  hasHeadMethod?: boolean;
-  /**
-   * @desc Handling rules for your own schemas branded with `x-brand` metadata.
-   * @desc Keys: brands (recommended to use unique symbols).
-   * @desc Values: functions having schema as first argument that you should assign type to, second one is a context.
-   * @example { MyBrand: (schema: typeof myBrandSchema, { next }) => createKeywordTypeNode(SyntaxKind.AnyKeyword)
-   * @link https://www.npmjs.com/package/@express-zod-api/zod-plugin
-   */
-  brandHandling?: HandlingRules<ts.TypeNode, ZTSContext>;
-}
-interface FormattedPrintingOptions {
-  /** @desc Typescript printer options */
-  printerOptions?: ts.PrinterOptions;
-  /**
-   * @desc Typescript code formatter
-   * @default prettier.format
-   * */
-  format?: (program: string) => Promise<string>;
-}
-declare class Integration extends IntegrationBase {
-  constructor({
-    typescript,
-    routing,
-    config,
-    brandHandling,
-    variant,
-    clientClassName,
-    subscriptionClassName,
-    serverUrl,
-    noBodySchema,
-    hasHeadMethod,
-  }: IntegrationParams);
-  /**
-   * @deprecated use `new Integration()` without `typescript` option on its argument
-   * @todo remove in the next major — no longer needed
-   * */
-  static create(params: Omit<IntegrationParams, "typescript">): Promise<Integration>;
-  print(printerOptions?: ts.PrinterOptions): string;
-  printFormatted({ printerOptions, format: userDefined }?: FormattedPrintingOptions): Promise<string>;
-}
 type EventsMap = Record<string, z.ZodType>;
 interface Emitter<E extends EventsMap> extends FlatObject {
   /** @desc Returns true when the connection was closed or terminated */
@@ -1597,8 +779,6 @@ export {
   type CachePolicy,
   type CommonConfig,
   type CookieSecurity,
-  type Depicter,
-  Documentation,
   DocumentationError,
   EndpointsFactory,
   EventStreamFactory,
@@ -1607,7 +787,6 @@ export {
   type IOSchema,
   type InputSecurity,
   InputValidationError,
-  Integration,
   type LoggerOverrides,
   type Method,
   Middleware,
@@ -1615,7 +794,6 @@ export {
   type OAuth2Security,
   type OpenIdSecurity,
   OutputValidationError,
-  type Producer,
   ResultHandler,
   type Routing,
   RoutingError,