@eggjs/koa 3.1.0-beta.19 → 3.1.0-beta.20

package/dist/index.d.ts

@@ -1,6 +1,918 @@
-import { Response } from "./response.js";
-import { Request, RequestSocket } from "./request.js";
-import { AnyProto, CustomError } from "./types.js";
-import { Context } from "./context.js";
-import { Application, MiddlewareFunc, Next, ProtoImplClass } from "./application.js";
+import util from "node:util";
+import Emitter from "node:events";
+import Stream from "node:stream";
+import http, { IncomingMessage, ServerResponse } from "node:http";
+import * as http_errors0 from "http-errors";
+import Cookies from "cookies";
+import { Socket } from "node:net";
+import { ParsedUrlQuery } from "node:querystring";
+import { Accepts } from "accepts";
+import { Options } from "content-disposition";
+import { AsyncLocalStorage } from "node:async_hooks";
+import * as http6 from "http";
+import * as net0 from "net";
+
+//#region src/response.d.ts
+declare class Response {
+  [key: symbol]: unknown;
+  app: Application;
+  req: IncomingMessage;
+  res: ServerResponse;
+  ctx: Context;
+  request: Request;
+  constructor(app: Application, ctx: Context, req: IncomingMessage, res: ServerResponse);
+  /**
+   * Return the request socket.
+   */
+  get socket(): net0.Socket | null;
+  /**
+   * Return response header.
+   */
+  get header(): http6.OutgoingHttpHeaders;
+  /**
+   * Return response header, alias as response.header
+   */
+  get headers(): http6.OutgoingHttpHeaders;
+  _explicitStatus: boolean;
+  /**
+   * Get response status code.
+   */
+  get status(): number;
+  /**
+   * Set response status code.
+   */
+  set status(code: number);
+  /**
+   * Get response status message
+   */
+  get message(): string;
+  /**
+   * Set response status message
+   */
+  set message(msg: string);
+  _body: any;
+  _explicitNullBody: boolean;
+  /**
+   * Get response body.
+   */
+  get body(): string | Buffer | object | Stream | null | undefined | boolean;
+  /**
+   * Set response body.
+   */
+  set body(val: string | Buffer | object | Stream | null | undefined | boolean);
+  /**
+   * Set Content-Length field to `n`.
+   */
+  set length(n: number | string | undefined);
+  /**
+   * Return parsed response Content-Length when present.
+   *
+   * When Content-Length is not defined it will return `undefined`.
+   */
+  get length(): number | undefined;
+  /**
+   * Check if a header has been written to the socket.
+   */
+  get headerSent(): boolean;
+  /**
+   * Vary on `field`.
+   */
+  vary(field: string): void;
+  _getBackReferrer(): string | undefined;
+  /**
+   * Perform a 302 redirect to `url`.
+   *
+   * The string "back" is special-cased
+   * to provide Referrer support, when Referrer
+   * is not present `alt` or "/" is used.
+   *
+   * Examples:
+   *
+   *    this.redirect('back');
+   *    this.redirect('back', '/index.html');
+   *    this.redirect('/login');
+   *    this.redirect('http://google.com'); // will format to 'http://google.com/'
+   */
+  redirect(url: string, alt?: string): void;
+  /**
+   * Set Content-Disposition header to "attachment" with optional `filename`.
+   */
+  attachment(filename?: string, options?: Options): void;
+  /**
+   * Set Content-Type response header with `type` through `mime.lookup()`
+   * when it does not contain a charset.
+   *
+   * Examples:
+   *
+   *     this.type = '.html';
+   *     this.type = 'html';
+   *     this.type = 'json';
+   *     this.type = 'application/json';
+   *     this.type = 'png';
+   */
+  set type(type: string | null | undefined);
+  /**
+   * Return the response mime type void of
+   * parameters such as "charset".
+   */
+  get type(): string;
+  /**
+   * Check whether the response is one of the listed types.
+   * Pretty much the same as `this.request.is()`.
+   *
+   *     this.response.is('html')
+   *     this.response.is('html', 'json')
+   */
+  is(type?: string | string[], ...types: string[]): string | false;
+  /**
+   * Set the Last-Modified date using a string or a Date.
+   *
+   *     this.response.lastModified = new Date();
+   *     this.response.lastModified = '2013-09-13';
+   */
+  set lastModified(val: string | Date | undefined);
+  /**
+   * Get the Last-Modified date in Date form, if it exists.
+   */
+  get lastModified(): Date | undefined;
+  /**
+   * Set the ETag of a response.
+   * This will normalize the quotes if necessary.
+   *
+   *     this.response.etag = 'md5-hash-sum';
+   *     this.response.etag = '"md5-hash-sum"';
+   *     this.response.etag = 'W/"123456789"';
+   */
+  set etag(val: string);
+  /**
+   * Get the ETag of a response.
+   */
+  get etag(): string;
+  /**
+   * Return response header.
+   *
+   * Examples:
+   *
+   *     this.get('Content-Type');
+   *     // => "text/plain"
+   *
+   *     this.get('content-type');
+   *     // => "text/plain"
+   */
+  get<T = string | string[] | number>(field: string): T;
+  /**
+   * Returns true if the header identified by name is currently set in the outgoing headers.
+   * The header name matching is case-insensitive.
+   *
+   * Examples:
+   *
+   *     this.has('Content-Type');
+   *     // => true
+   *
+   *     this.get('content-type');
+   *     // => true
+   */
+  has(field: string): boolean;
+  /**
+   * Set header `field` to `val` or pass
+   * an object of header fields.
+   *
+   * Examples:
+   *
+   *    this.set('Foo', ['bar', 'baz']);
+   *    this.set('Accept', 'application/json');
+   *    this.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
+   */
+  set(field: string | Record<string, string>, val?: string | number | unknown[]): void;
+  /**
+   * Append additional header `field` with value `val`.
+   *
+   * Examples:
+   *
+   * ```
+   * this.append('Link', ['<http://localhost/>', '<http://localhost:3000/>']);
+   * this.append('Set-Cookie', 'foo=bar; Path=/; HttpOnly');
+   * this.append('Warning', '199 Miscellaneous warning');
+   */
+  append(field: string, val: string | string[]): void;
+  /**
+   * Remove header `field`.
+   */
+  remove(field: string): void;
+  /**
+   * Checks if the request is writable.
+   * Tests for the existence of the socket
+   * as node sometimes does not set it.
+   */
+  get writable(): boolean;
+  /**
+   * Inspect implementation.
+   */
+  inspect(): {
+    status: number;
+    message: string;
+    header: http6.OutgoingHttpHeaders;
+  } | undefined;
+  [util.inspect.custom](): {
+    status: number;
+    message: string;
+    header: http6.OutgoingHttpHeaders;
+  } | undefined;
+  /**
+   * Return JSON representation.
+   */
+  toJSON(): {
+    status: number;
+    message: string;
+    header: http6.OutgoingHttpHeaders;
+  };
+  /**
+   * Flush any set headers and begin the body
+   */
+  flushHeaders(): void;
+}
+//#endregion
+//#region src/request.d.ts
+interface RequestSocket extends Socket {
+  encrypted: boolean;
+}
+declare class Request {
+  [key: symbol]: unknown;
+  app: Application;
+  req: IncomingMessage;
+  res: ServerResponse;
+  ctx: Context;
+  response: Response;
+  originalUrl: string;
+  constructor(app: Application, ctx: Context, req: IncomingMessage, res: ServerResponse);
+  /**
+   * Return request header.
+   */
+  get header(): http6.IncomingHttpHeaders;
+  /**
+   * Set request header.
+   */
+  set header(val: http6.IncomingHttpHeaders);
+  /**
+   * Return request header, alias as request.header
+   */
+  get headers(): http6.IncomingHttpHeaders;
+  /**
+   * Set request header, alias as request.header
+   */
+  set headers(val: http6.IncomingHttpHeaders);
+  /**
+   * Get request URL.
+   */
+  get url(): string;
+  /**
+   * Set request URL.
+   */
+  set url(val: string);
+  /**
+   * Get origin of URL.
+   */
+  get origin(): string;
+  /**
+   * Get full request URL.
+   */
+  get href(): string;
+  /**
+   * Get request method.
+   */
+  get method(): string;
+  /**
+   * Set request method.
+   */
+  set method(val: string);
+  /**
+   * Get request pathname.
+   */
+  get path(): string;
+  /**
+   * Set pathname, retaining the query string when present.
+   */
+  set path(pathname: string);
+  protected _parsedUrlQueryCache: Record<string, ParsedUrlQuery> | undefined;
+  /**
+   * Get parsed query string.
+   */
+  get query(): ParsedUrlQuery;
+  /**
+   * Set query string as an object.
+   */
+  set query(obj: ParsedUrlQuery);
+  /**
+   * Get query string.
+   */
+  get querystring(): string;
+  /**
+   * Set query string.
+   */
+  set querystring(str: string);
+  /**
+   * Get the search string. Same as the query string
+   * except it includes the leading ?.
+   */
+  get search(): string;
+  /**
+   * Set the search string. Same as
+   * request.querystring= but included for ubiquity.
+   */
+  set search(str: string);
+  /**
+   * Parse the "Host" header field host
+   * and support X-Forwarded-Host when a
+   * proxy is enabled.
+   * return `hostname:port` format
+   */
+  get host(): string;
+  /**
+   * Parse the "Host" header field hostname
+   * and support X-Forwarded-Host when a
+   * proxy is enabled.
+   */
+  get hostname(): string;
+  protected _memoizedURL: URL | undefined;
+  /**
+   * Get WHATWG parsed URL.
+   * Lazily memoized.
+   */
+  get URL(): URL;
+  /**
+   * Check if the request is fresh, aka
+   * Last-Modified and/or the ETag
+   * still match.
+   */
+  get fresh(): boolean;
+  /**
+   * Check if the request is stale, aka
+   * "Last-Modified" and / or the "ETag" for the
+   * resource has changed.
+   */
+  get stale(): boolean;
+  /**
+   * Check if the request is idempotent.
+   */
+  get idempotent(): boolean;
+  /**
+   * Return the request socket.
+   */
+  get socket(): RequestSocket;
+  /**
+   * Get the charset when present or undefined.
+   */
+  get charset(): string;
+  /**
+   * Return parsed Content-Length when present.
+   */
+  get length(): number | undefined;
+  /**
+   * Return the protocol string "http" or "https"
+   * when requested with TLS. When the proxy setting
+   * is enabled the "X-Forwarded-Proto" header
+   * field will be trusted. If you're running behind
+   * a reverse proxy that supplies https for you this
+   * may be enabled.
+   */
+  get protocol(): string;
+  /**
+   * Shorthand for:
+   *
+   *    this.protocol == 'https'
+   */
+  get secure(): boolean;
+  /**
+   * When `app.proxy` is `true`, parse
+   * the "X-Forwarded-For" ip address list.
+   *
+   * For example if the value was "client, proxy1, proxy2"
+   * you would receive the array `["client", "proxy1", "proxy2"]`
+   * where "proxy2" is the furthest down-stream.
+   */
+  get ips(): string[];
+  protected _ip: string;
+  /**
+   * Return request's remote address
+   * When `app.proxy` is `true`, parse
+   * the "X-Forwarded-For" ip address list and return the first one
+   */
+  get ip(): string;
+  set ip(ip: string);
+  /**
+   * Return subdomains as an array.
+   *
+   * Subdomains are the dot-separated parts of the host before the main domain
+   * of the app. By default, the domain of the app is assumed to be the last two
+   * parts of the host. This can be changed by setting `app.subdomainOffset`.
+   *
+   * For example, if the domain is "tobi.ferrets.example.com":
+   * If `app.subdomainOffset` is not set, this.subdomains is
+   * `["ferrets", "tobi"]`.
+   * If `app.subdomainOffset` is 3, this.subdomains is `["tobi"]`.
+   */
+  get subdomains(): string[];
+  protected _accept: Accepts;
+  /**
+   * Get accept object.
+   * Lazily memoized.
+   */
+  get accept(): Accepts;
+  /**
+   * Set accept object.
+   */
+  set accept(obj: Accepts);
+  /**
+   * Check if the given `type(s)` is acceptable, returning
+   * the best match when true, otherwise `false`, in which
+   * case you should respond with 406 "Not Acceptable".
+   *
+   * The `type` value may be a single mime type string
+   * such as "application/json", the extension name
+   * such as "json" or an array `["json", "html", "text/plain"]`. When a list
+   * or array is given the _best_ match, if any is returned.
+   *
+   * Examples:
+   *
+   *     // Accept: text/html
+   *     this.accepts('html');
+   *     // => "html"
+   *
+   *     // Accept: text/*, application/json
+   *     this.accepts('html');
+   *     // => "html"
+   *     this.accepts('text/html');
+   *     // => "text/html"
+   *     this.accepts('json', 'text');
+   *     // => "json"
+   *     this.accepts('application/json');
+   *     // => "application/json"
+   *
+   *     // Accept: text/*, application/json
+   *     this.accepts('image/png');
+   *     this.accepts('png');
+   *     // => false
+   *
+   *     // Accept: text/*;q=.5, application/json
+   *     this.accepts(['html', 'json']);
+   *     this.accepts('html', 'json');
+   *     // => "json"
+   */
+  accepts(args: string[]): string | string[] | false;
+  accepts(...args: string[]): string | string[] | false;
+  /**
+   * Return accepted encodings or best fit based on `encodings`.
+   *
+   * Given `Accept-Encoding: gzip, deflate`
+   * an array sorted by quality is returned:
+   *
+   *     ['gzip', 'deflate']
+   */
+  acceptsEncodings(): string[];
+  acceptsEncodings(encodings: string[]): string | false;
+  acceptsEncodings(...encodings: string[]): string | false;
+  /**
+   * Return accepted charsets or best fit based on `charsets`.
+   *
+   * Given `Accept-Charset: utf-8, iso-8859-1;q=0.2, utf-7;q=0.5`
+   * an array sorted by quality is returned:
+   *
+   *     ['utf-8', 'utf-7', 'iso-8859-1']
+   */
+  acceptsCharsets(): string[];
+  acceptsCharsets(charsets: string[]): string | false;
+  acceptsCharsets(...charsets: string[]): string | false;
+  /**
+   * Return accepted languages or best fit based on `langs`.
+   *
+   * Given `Accept-Language: en;q=0.8, es, pt`
+   * an array sorted by quality is returned:
+   *
+   *     ['es', 'pt', 'en']
+   */
+  acceptsLanguages(): string[];
+  acceptsLanguages(languages: string[]): string | false;
+  acceptsLanguages(...languages: string[]): string | false;
+  /**
+   * Check if the incoming request contains the "Content-Type"
+   * header field and if it contains any of the given mime `type`s.
+   * If there is no request body, `null` is returned.
+   * If there is no content type, `false` is returned.
+   * Otherwise, it returns the first `type` that matches.
+   *
+   * Examples:
+   *
+   *     // With Content-Type: text/html; charset=utf-8
+   *     this.is('html'); // => 'html'
+   *     this.is('text/html'); // => 'text/html'
+   *     this.is('text/*', 'application/json'); // => 'text/html'
+   *
+   *     // When Content-Type is application/json
+   *     this.is('json', 'urlencoded'); // => 'json'
+   *     this.is('application/json'); // => 'application/json'
+   *     this.is('html', 'application/*'); // => 'application/json'
+   *
+   *     this.is('html'); // => false
+   */
+  is(type?: string | string[], ...types: string[]): string | false | null;
+  /**
+   * Return the request mime type void of
+   * parameters such as "charset".
+   */
+  get type(): string;
+  /**
+   * Return request header.
+   *
+   * The `Referrer` header field is special-cased,
+   * both `Referrer` and `Referer` are interchangeable.
+   *
+   * Examples:
+   *
+   *     this.get('Content-Type');
+   *     // => "text/plain"
+   *
+   *     this.get('content-type');
+   *     // => "text/plain"
+   *
+   *     this.get('Something');
+   *     // => ''
+   */
+  get<T = string | string[]>(field: string): T;
+  /**
+   * Inspect implementation.
+   */
+  inspect(): {
+    method: string;
+    url: string;
+    header: http6.IncomingHttpHeaders;
+  } | undefined;
+  /**
+   * Custom inspection implementation for newer Node.js versions.
+   */
+  [util.inspect.custom](): {
+    method: string;
+    url: string;
+    header: http6.IncomingHttpHeaders;
+  } | undefined;
+  /**
+   * Return JSON representation.
+   */
+  toJSON(): {
+    method: string;
+    url: string;
+    header: http6.IncomingHttpHeaders;
+  };
+}
+//#endregion
+//#region src/types.d.ts
+type CustomError = Error & {
+  headers?: Record<string, string>;
+  status?: number;
+  statusCode?: number;
+  code?: string;
+  expose?: boolean;
+  headerSent?: boolean;
+};
+interface AnyProto {
+  [key: string | symbol]: any;
+}
+//#endregion
+//#region src/context.d.ts
+declare class Context {
+  #private;
+  [key: symbol | string]: unknown;
+  app: Application;
+  req: IncomingMessage;
+  res: ServerResponse;
+  request: Request & AnyProto;
+  response: Response & AnyProto;
+  originalUrl: string;
+  respond?: boolean;
+  constructor(app: Application, req: IncomingMessage, res: ServerResponse);
+  /**
+   * util.inspect() implementation, which
+   * just returns the JSON output.
+   */
+  inspect(): {
+    request: {
+      method: string;
+      url: string;
+      header: http6.IncomingHttpHeaders;
+    };
+    response: {
+      status: number;
+      message: string;
+      header: http6.OutgoingHttpHeaders;
+    };
+    app: {
+      subdomainOffset: number;
+      proxy: boolean;
+      env: string;
+    };
+    originalUrl: string;
+    req: string;
+    res: string;
+    socket: string;
+  };
+  /**
+   * Custom inspection implementation for newer Node.js versions.
+   */
+  [util.inspect.custom](): {
+    request: {
+      method: string;
+      url: string;
+      header: http6.IncomingHttpHeaders;
+    };
+    response: {
+      status: number;
+      message: string;
+      header: http6.OutgoingHttpHeaders;
+    };
+    app: {
+      subdomainOffset: number;
+      proxy: boolean;
+      env: string;
+    };
+    originalUrl: string;
+    req: string;
+    res: string;
+    socket: string;
+  };
+  /**
+   * Return JSON representation.
+   *
+   * Here we explicitly invoke .toJSON() on each
+   * object, as iteration will otherwise fail due
+   * to the getters and cause utilities such as
+   * clone() to fail.
+   */
+  toJSON(): {
+    request: {
+      method: string;
+      url: string;
+      header: http6.IncomingHttpHeaders;
+    };
+    response: {
+      status: number;
+      message: string;
+      header: http6.OutgoingHttpHeaders;
+    };
+    app: {
+      subdomainOffset: number;
+      proxy: boolean;
+      env: string;
+    };
+    originalUrl: string;
+    req: string;
+    res: string;
+    socket: string;
+  };
+  /**
+   * Similar to .throw(), adds assertion.
+   *
+   * ```ts
+   * this.assert(this.user, 401, 'Please login!');
+   * ```
+   */
+  assert(value: unknown, status?: number, errorProps?: Record<string, unknown>): void;
+  assert(value: unknown, status?: number, errorMessage?: string, errorProps?: Record<string, unknown>): void;
+  /**
+   * Throw an error with `status` (default 500) and
+   * `msg`. Note that these are user-level
+   * errors, and the message may be exposed to the client.
+   *
+   *    this.throw(403)
+   *    this.throw(400, 'name required')
+   *    this.throw('something exploded')
+   *    this.throw(new Error('invalid'))
+   *    this.throw(400, new Error('invalid'))
+   *    this.throw(400, new Error('invalid'), { foo: 'bar' })
+   *    this.throw(new Error('invalid'), { foo: 'bar' })
+   *
+   * See: https://github.com/jshttp/http-errors
+   *
+   * Note: `status` should only be passed as the first parameter.
+   *
+   * @param {String|Number|Error} status error, msg or status
+   * @param {String|Number|Error|Object} [error] error, msg, status or errorProps
+   * @param {Object} [errorProps] error object properties
+   */
+  throw(status: number): void;
+  throw(status: number, errorProps: object): void;
+  throw(status: number, errorMessage: string): void;
+  throw(status: number, errorMessage: string, errorProps: object): void;
+  throw(status: number, error: Error): void;
+  throw(status: number, error: Error, errorProps: object): void;
+  throw(errorMessage: string): void;
+  throw(errorMessage: string, errorProps: object): void;
+  throw(errorMessage: string, status: number): void;
+  throw(errorMessage: string, status: number, errorProps: object): void;
+  throw(error: Error): void;
+  throw(error: Error, errorProps: object): void;
+  throw(error: Error, status: number): void;
+  throw(error: Error, status: number, errorProps: object): void;
+  /**
+   * Default error handling.
+   * @private
+   */
+  onerror(err: CustomError): void;
+  protected _cookies: Cookies | undefined;
+  get cookies(): Cookies;
+  set cookies(cookies: Cookies);
+  get state(): Record<string, any>;
+  /**
+   * Request delegation.
+   */
+  acceptsLanguages(): string[];
+  acceptsLanguages(languages: string[]): string | false;
+  acceptsLanguages(...languages: string[]): string | false;
+  acceptsEncodings(): string[];
+  acceptsEncodings(encodings: string[]): string | false;
+  acceptsEncodings(...encodings: string[]): string | false;
+  acceptsCharsets(): string[];
+  acceptsCharsets(charsets: string[]): string | false;
+  acceptsCharsets(...charsets: string[]): string | false;
+  accepts(args: string[]): string | string[] | false;
+  accepts(...args: string[]): string | string[] | false;
+  get<T = string | string[]>(field: string): T;
+  is(type?: string | string[], ...types: string[]): string | false | null;
+  get querystring(): string;
+  set querystring(str: string);
+  get idempotent(): boolean;
+  get socket(): RequestSocket;
+  get search(): string;
+  set search(str: string);
+  get method(): string;
+  set method(method: string);
+  get query(): ParsedUrlQuery;
+  set query(obj: ParsedUrlQuery);
+  get path(): string;
+  set path(path: string);
+  get url(): string;
+  set url(url: string);
+  get accept(): Accepts;
+  set accept(accept: Accepts);
+  get origin(): string;
+  get href(): string;
+  get subdomains(): string[];
+  get protocol(): string;
+  get host(): string;
+  get hostname(): string;
+  get URL(): URL;
+  get header(): http6.IncomingHttpHeaders;
+  get headers(): http6.IncomingHttpHeaders;
+  get secure(): boolean;
+  get stale(): boolean;
+  get fresh(): boolean;
+  get ips(): string[];
+  get ip(): string;
+  /**
+   * Response delegation.
+   */
+  attachment(...args: Parameters<Response['attachment']>): void;
+  redirect(...args: Parameters<Response['redirect']>): void;
+  remove(...args: Parameters<Response['remove']>): void;
+  vary(...args: Parameters<Response['vary']>): void;
+  has(...args: Parameters<Response['has']>): boolean;
+  set(...args: Parameters<Response['set']>): void;
+  append(...args: Parameters<Response['append']>): void;
+  flushHeaders(...args: Parameters<Response['flushHeaders']>): void;
+  get status(): number;
+  set status(status: number);
+  get message(): string;
+  set message(msg: string);
+  get body(): any;
+  set body(val: any);
+  get length(): number | undefined;
+  set length(n: number | string | undefined);
+  get type(): string;
+  set type(type: string | null | undefined);
+  get lastModified(): string | Date | undefined;
+  set lastModified(val: string | Date | undefined);
+  get etag(): string;
+  set etag(val: string);
+  get headerSent(): boolean;
+  get writable(): boolean;
+}
+//#endregion
+//#region src/application.d.ts
+type ProtoImplClass<T = object> = new (...args: any[]) => T;
+type Next = () => Promise<void>;
+type _MiddlewareFunc<T> = (ctx: T, next: Next) => Promise<void> | void;
+type MiddlewareFunc<T extends Context = Context> = _MiddlewareFunc<T> & {
+  _name?: string;
+};
+/**
+ * Expose `Application` class.
+ * Inherits from `Emitter.prototype`.
+ */
+declare class Application extends Emitter {
+  [key: symbol]: unknown;
+  /**
+   * Make HttpError available to consumers of the library so that consumers don't
+   * have a direct dependency upon `http-errors`
+   */
+  static HttpError: http_errors0.HttpErrorConstructor<number>;
+  protected _proxy: boolean;
+  protected _env: string;
+  subdomainOffset: number;
+  proxyIpHeader: string;
+  maxIpsCount: number;
+  protected _keys?: string[];
+  middleware: MiddlewareFunc<Context>[];
+  ctxStorage: AsyncLocalStorage<Context>;
+  silent: boolean;
+  ContextClass: ProtoImplClass<Context>;
+  context: AnyProto;
+  RequestClass: ProtoImplClass<Request>;
+  request: AnyProto;
+  ResponseClass: ProtoImplClass<Response>;
+  response: AnyProto;
+  /**
+   * Initialize a new `Application`.
+   *
+   * @param {object} [options] Application options
+   * @param {string} [options.env] Environment, default is `development`
+   * @param {string[]} [options.keys] Signed cookie keys
+   * @param {boolean} [options.proxy] Trust proxy headers
+   * @param {number} [options.subdomainOffset] Subdomain offset
+   * @param {string} [options.proxyIpHeader] Proxy IP header, defaults to X-Forwarded-For
+   * @param {number} [options.maxIpsCount] Max IPs read from proxy IP header, default to 0 (means infinity)
+   */
+  constructor(options?: {
+    proxy?: boolean;
+    subdomainOffset?: number;
+    proxyIpHeader?: string;
+    maxIpsCount?: number;
+    env?: string;
+    keys?: string[];
+  });
+  get keys(): string[] | undefined;
+  set keys(value: string[] | undefined);
+  get env(): string;
+  set env(value: string);
+  get proxy(): boolean;
+  set proxy(value: boolean);
+  /**
+   * Shorthand for:
+   *
+   *    http.createServer(app.callback()).listen(...)
+   */
+  listen(...args: any[]): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;
+  /**
+   * Return JSON representation.
+   * We only bother showing settings.
+   */
+  toJSON(): {
+    subdomainOffset: number;
+    proxy: boolean;
+    env: string;
+  };
+  /**
+   * Inspect implementation.
+   */
+  inspect(): {
+    subdomainOffset: number;
+    proxy: boolean;
+    env: string;
+  };
+  [util.inspect.custom](): {
+    subdomainOffset: number;
+    proxy: boolean;
+    env: string;
+  };
+  /**
+   * Use the given middleware `fn`.
+   */
+  use<T extends Context = Context>(fn: MiddlewareFunc<T>): this;
+  /**
+   * Return a request handler callback
+   * for node's native http server.
+   */
+  callback(): (req: IncomingMessage, res: ServerResponse) => Promise<void | http.ServerResponse<http.IncomingMessage>>;
+  /**
+   * return current context from async local storage
+   */
+  get currentContext(): Context | undefined;
+  /**
+   * Handle request in callback.
+   * @private
+   */
+  protected handleRequest(ctx: Context, fnMiddleware: (ctx: Context) => Promise<void>): Promise<void | http.ServerResponse<http.IncomingMessage>>;
+  /**
+   * Initialize a new context.
+   * @private
+   */
+  createContext(req: IncomingMessage, res: ServerResponse): Context;
+  /**
+   * Default error handler.
+   * @private
+   */
+  protected onerror(err: CustomError): void;
+  /**
+   * Response helper.
+   */
+  protected _respond(ctx: Context): http.ServerResponse<http.IncomingMessage> | undefined;
+}
+//#endregion
 export { type AnyProto, Application, Context, type CustomError, MiddlewareFunc, Next, ProtoImplClass, Request, RequestSocket, Response, Application as default };