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

package/dist/routing-C0jFxoT6.d.ts

@@ -0,0 +1,742 @@
+import { z } from "zod";
+import { HttpError } from "http-errors";
+import "ansis";
+import express, { IRouter, NextFunction, Request, RequestHandler, Response } from "express";
+import { ServerOptions } from "node:https";
+import compression from "compression";
+import fileUpload from "express-fileupload";
+import cookieParser from "cookie-parser";
+import { ListenOptions } from "node:net";
+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;
+}
+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;
+}
+declare const methods: ("get" | "post" | "put" | "delete" | "patch" | "query")[];
+declare const clientMethods: ("get" | "post" | "put" | "delete" | "patch" | "head" | "query")[];
+/**
+ * @desc Methods supported by the framework API to produce Endpoints on EndpointsFactory.
+ * @see BuildProps
+ * @example "get" | "post" | "put" | "delete" | "patch" | "query"
+ * */
+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];
+type Base = object & {
+  [Symbol.iterator]?: never;
+};
+/** @desc The type allowed on the top level of Middlewares and Endpoints */
+type IOSchema = z.ZodType<Base>;
+/** 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 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$2<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$2);
+  execute(...params: Parameters<Handler$2>): 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$2<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;
+  }
+>;
+/** @desc Returns child logger for the given request (if configured) or the configured logger otherwise */
+type GetLogger = (request?: Request) => ActualLogger;
+type InputSource = keyof Pick<Request, "query" | "body" | "files" | "params" | "headers" | "cookies" | "signedCookies">;
+type InputSources = Record<Method, InputSource[]>;
+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.
+   * @desc You can provide custom middleware or the `cors` package.
+   * @example cors({ origin: "https://example.com" }) // import cors from "cors"
+   * @link https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS
+   * @link https://www.npmjs.com/package/cors
+   */
+  cors: boolean | RequestHandler;
+  /**
+   * @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>;
+}
+type ServerHook = (params: {
+  app: IRouter;
+  /** @desc Returns child logger for the given request (if configured) or the configured logger otherwise */
+  getLogger: GetLogger;
+}) => 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 applied to all incoming requests.
+   * @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 parser for Buffer payloads applied to all incoming requests.
+   * @default express.raw()
+   * @link https://expressjs.com/en/5x/api.html#express.raw
+   * */
+  rawParser?: RequestHandler;
+  /**
+   * @desc Custom parser for URL Encoded requests applied to all incoming requests.
+   * @default express.urlencoded()
+   * @link https://expressjs.com/en/5x/api.html#express.urlencoded
+   * */
+  formParser?: RequestHandler;
+  /**
+   * @desc A code to execute before the installation of parsers (compression, cookies, CORS, body).
+   * @example ({ app }) => { app.use(helmet()); }
+   * */
+  beforeParsers?: ServerHook;
+  /**
+   * @desc A code to execute before processing the Routing of your API.
+   * @desc Runs after compression, cookies, CORS and body parsers are installed.
+   * @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;
+/** @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;
+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 DeviceAuthUrl {
+  /** @desc The device authorization URL to use for this flow (RFC 8628). Can be relative to the API server URL. */
+  deviceAuthorizationUrl: 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>;
+type DeviceAuthFlow<S extends string> = DeviceAuthUrl & TokenUrl & RefreshUrl & Scopes<S>;
+/**
+ * @see https://swagger.io/docs/specification/authentication/oauth2/
+ */
+interface OAuth2Security<S extends string> {
+  type: "oauth2";
+  /**
+   * @desc URL to OAuth 2.0 Authorization Server metadata document
+   * @link https://www.rfc-editor.org/rfc/rfc8414
+   * */
+  oauth2MetadataUrl?: string;
+  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 Device Authorization flow (OAuth 2.0 Device Authorization Grant)
+     * @link https://oauth.net/2/device-flow/
+     * */
+    deviceAuthorization?: DeviceAuthFlow<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>
+) & {
+  deprecated?: boolean;
+};
+type Handler$1<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$1<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 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 OriginalStatic = typeof express.static;
+declare class ServeStatic {
+  constructor(...params: Parameters<OriginalStatic>);
+}
+/**
+ * @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;
+}
+export {
+  ensureHttpError as A,
+  ResponseVariant as B,
+  CommonConfig as C,
+  ResultHandler as D,
+  AbstractResultHandler as E,
+  Method as F,
+  BuiltinLogger as I,
+  AbstractLogger as L,
+  FinalInputSchema as M,
+  IOSchema as N,
+  arrayResultHandler as O,
+  ClientMethod as P,
+  LoggerOverrides as R,
+  AppConfig as S,
+  createConfig as T,
+  EmptySchema as _,
+  Handler as a,
+  TagOverrides as b,
+  Middleware as c,
+  CookieSecurity as d,
+  HeaderSecurity as f,
+  EmptyObject as g,
+  OpenIdSecurity as h,
+  Endpoint as i,
+  Extension as j,
+  defaultResultHandler as k,
+  BasicSecurity as l,
+  OAuth2Security as m,
+  ServeStatic as n,
+  AbstractMiddleware as o,
+  InputSecurity as p,
+  AbstractEndpoint as r,
+  ExpressMiddleware as s,
+  Routing as t,
+  BearerSecurity as u,
+  FlatObject as v,
+  ServerConfig as w,
+  getMessageFromError as x,
+  Tag as y,
+  ApiResponse as z,
+};