index.d.ts

/* auto-generated by NAPI-RS */
/* eslint-disable */
export declare class Bytes {
  constructor()
  static fromOwner(owner: Buffer): Bytes
  get length(): number
  isEmpty(): boolean
  isUnique(): boolean
  static copyFromSlice(data: Uint8Array): Bytes
  slice(startIdx: number, endIdx: number): Bytes
  sliceRef(subset: Uint8Array): Bytes
  splitOff(mid: number): Bytes
  splitTo(at: number): Bytes
  truncate(len: number): void
  clear(): void
}

/**
 * Create a new cookie parser middleware function using the given secret and
 * options.
 *
 * - `secret` a string or array used for signing cookies. This is optional and
 * if not specified, will not parse signed cookies. If a string is provided,
 * this is used as the secret. If an array is provided, an attempt will be
 * made to unsign the cookie with each secret in order.
 *
 * - `options` an object that is passed to cookie.parse as the second option. See cookie for more information.
 * decode a function to decode the value of the cookie
 * The middleware will parse the Cookie header on the request and expose the cookie data as the property req.cookies and, if a secret was provided, as the property req.signedCookies. These properties are name value pairs of the cookie name to cookie value.
 */
export declare class CookieParserMiddleware {
  constructor(secret?: string | Array<string> | undefined | null, options?: JsCookieParserOptions | undefined | null)
  run(request: Request, response: Response): Promise<boolean>
}

export declare class FileStat {
  isDirectory(): boolean
  isFile(): boolean
  isSymbolicLink(): boolean
  get size(): number
  get atimeMs(): bigint
  get mtimeMs(): bigint
  get birthtimeMs(): bigint
}

/**
 * This is a built-in middleware function in Express. It parses incoming
 * requests with JSON payloads.
 *
 * Returns middleware that only parses JSON and only looks at requests where
 * the `Content-Type` header matches the `type` option. This parser accepts
 * any Unicode encoding of the body and supports automatic inflation of `gzip`
 * and `deflate` encodings.
 *
 * A new `body` object containing the parsed data is populated on the
 * `request` object after the middleware (i.e. `req.body`), or `undefined` if
 * there was no body to parse, the `Content-Type` was not matched, or an error
 * occurred.
 *
 * > As `req.body`’s shape is based on user-controlled input, all properties
 * > and values in this object are untrusted and should be validated before
 * > trusting. For example, `req.body.foo.toString()` may fail in multiple
 * > ways, for example `foo` may not be there or may not be a string, and
 * > `toString` may not be a function and instead a string or other
 * > user-input.
 */
export declare class JsonMiddleware {
  constructor(options?: JsJsonOptions | undefined | null)
  run(request: Request, response: Response): Promise<boolean>
}

/**
 * This is a built-in middleware function in Express. It parses incoming
 * requests with JSON payloads.
 *
 * Returns middleware that only parses JSON and only looks at requests where
 * the `Content-Type` header matches the `type` option. This parser accepts
 * any Unicode encoding of the body and supports automatic inflation of `gzip`
 * and `deflate` encodings.
 *
 * A new `body` object containing the parsed data is populated on the
 * `request` object after the middleware (i.e. `req.body`), or `undefined` if
 * there was no body to parse, the `Content-Type` was not matched, or an error
 * occurred.
 *
 * > As `req.body`’s shape is based on user-controlled input, all properties
 * > and values in this object are untrusted and should be validated before
 * > trusting. For example, `req.body.foo.toString()` may fail in multiple
 * > ways, for example `foo` may not be there or may not be a string, and
 * > `toString` may not be a function and instead a string or other
 * > user-input.
 */
export declare class RawMiddleware {
  constructor(options?: JsRawOptions | undefined | null)
  run(request: Request, response: Response): Promise<boolean>
}

export declare class Request {
  /**
   * Checks if the specified content types are acceptable, based on the
   * request’s Accept HTTP header field. The method returns the best match, or
   * if none of the specified content types is acceptable, returns false (in
   * which case, the application should respond with 406 "Not Acceptable").
   *
   * The type value may be a single MIME type string (such as
   * "application/json"), an extension name such as "json", a comma-delimited
   * list, or an array. For a list or array, the method returns the best match
   * (if any).
   *
   * ```javascript
   * // Accept: text/html
   * req.accepts('html')
   * // => "html"
   *
   * // Accept: text/*, application/json
   * req.accepts('html')u
   * // => "html"
   * req.accepts('text/html')
   * // => "text/html"
   * req.accepts(['json', 'text'])
   * // => "json"
   * req.accepts('application/json')
   * // => "application/json"
   *
   * // Accept: text/*, application/json
   * req.accepts('image/png')
   * req.accepts('png')
   * // => false
   *
   * // Accept: text/*;q=.5, application/json
   * req.accepts(['html', 'json'])
   * // => "json"
   * ```
   *
   * For more information, or if you have issues or concerns, see
   * [accepts](https://github.com/expressjs/accepts).
   */
  accepts(types: string | Array<string>): string | Array<string> | null
  /**
   * Returns the specified HTTP request header field (case-insensitive match).
   * The `Referrer` and `Referer` fields are interchangeable.
   *
   * ```javascript
   * req.get('Content-Type')
   * // => "text/plain"
   *
   * req.get('content-type')
   * // => "text/plain"
   *
   * req.get('Something')
   * // => undefined
   * ```
   *
   * Aliased as `req.header(field)`.
   */
  get(field: string): string | Buffer
  header(field: string): string | Buffer
  /**
   * Contains a string corresponding to the HTTP method of the request: `GET`,
   * `POST`, `PUT`, and so on.
   */
  get method(): string
  get params(): object
  /**
   * Range header parser.
   *
   * The size parameter is the maximum size of the resource.
   *
   * The options parameter is an object that can have the following properties.
   *
   * | Property | Type | Description |
   * | ---      | ---  | ---         |
   * | combine | Boolean | Specify if overlapping & adjacent ranges should be
   * | | | combined, defaults to false. When true, ranges will be combined and |
   * | | | returned as if they were specified that way in the header. |
   *
   * An array of ranges will be returned or negative numbers indicating an error parsing.
   *
   * - `-2` signals a malformed header string
   * - `-1` signals an unsatisfiable range
   *
   * ```javascript
   * // parse header from request
   * const range = req.range(1000)
   *
   * // the type of the range
   * if (range.type === 'bytes') {
   *   // the ranges
   *   range.forEach((r) => {
   *     // do something with r.start and r.end
   *   })
   * }
   * ```
   */
  range(size: number, options?: RangeOptions | undefined | null): number | Ranges | null
  /**
   * Included for test purposes. Normally, you will obtain a request from the
   * server
   */
  constructor()
  /**
   * `req.body`'s shape is based on user-controlled input, all properties and
   * values in this object are untrusted and should be validated before
   * trusting. For example, `req.body.foo.toString()` may fail in multiple
   * ways, for example the foo property may not be there or may not be a
   * string, and `toString` may not be a function and instead a string or
   * other user input.
   */
  get body(): string | unknown | Buffer | undefined
  get cookies(): unknown | undefined
}

export declare class Response {
  /**
   * Appends the specified value to the HTTP response header field. If the header is not already set, it creates the header
   * with the specified value. The value parameter can be a string or an array.
   * > **&#10155; Note**
   * >
   * > calling `res.set()` after `res.append()` will reset the previously-set header value.
   *
   * ```javascript
   * res.append('Link', ['<http://localhost/>', '<http://localhost:3000/>'])
   * res.append('Set-Cookie', 'foo=bar; Path=/; HttpOnly')
   * res.append('Warning', '199 Miscellaneous warning')
   * ```
   */
  append(field: string, value: Array<string> | string): void
  /**
   * Sets the HTTP response Content-Disposition header field to "attachment". If a file_path is given, then it sets the
   * Content-Type based on the extension name via res.type(), and sets the Content-Disposition "filename=" parameter.
   *
   * ```javascript
   * res.attachment()
   * // Content-Disposition: attachment
   *
   * res.attachment('path/to/logo.png')
   * // Content-Disposition: attachment; filename="logo.png"
   * // Content-Type: image/png
   * ```
   */
  attachment(filePath?: string | undefined | null): void
  /**
   * Clears the cookie with the specified name by sending a `Set-Cookie` header that sets its expiration date in the past.
   * This instructs the client that the cookie has expired and is no longer valid. For more information about available
   * options, see `res.cookie()`.
   *
   * > The expires and max-age options are being ignored completely.
   *
   * > Web browsers and other compliant clients will only clear the cookie if the given options is identical to those given
   * > to res.cookie()
   *
   * ```javascript
   * res.cookie('name', 'tobi', { path: '/admin' })
   * res.clearCookie('name', { path: '/admin' })
   * ```
   */
  clearCookie(name: string, options?: CookieOptions | undefined | null): void
  /**
   * Sets the `Content-Type` HTTP header to the MIME type as determined by the specified
   * `type`. If `type` contains the "/" character, then it sets the `Content-Type` to
   * the exact value of `type`, otherwise it is assumed to be a file extension and the
   * MIME type is looked up using the `from_ext()` method of the mime_guess crate. When
   * no mapping is found though `mime_guess::from_ext()`, the type is set to
   * "application/octet-stream".
   *
   *  Examples:
   *
   *  ```javascript
   *      res.type('.html'); // => 'text/html'
   *      res.type('html'); // => 'text/html'
   *      res.type('json'); // => 'application/json'
   *      res.type('application/json'); // => 'application/json'
   *      res.type('png'); // => image/png
   * ```
   *
   * Aliased as `res.contentType(type)`.
   */
  type(typ: string): void
  contentType(typ: string): void
  /**
   * Sets cookie `name` to `value`. The `value` parameter may be a string or object converted to JSON.
   *
   * The `options` parameter is an object that can have the following properties.
   *
   * | Property      | Type     | Description |
   * | --------      | -----    | --- |
   * | `domain`      | String   | Domain name for the cookie. Defaults to the domain name of the app. |
   * | `encode`      | Function | A synchronous function used for cookie value encoding. Defaults to `encodeURIComponent`. |
   * | `expires`     | Date     | Expiry date of the cookie in GMT. If not specified or set to 0, creates a session cookie. |
   * | `httpOnly`    | Boolean  | Flags the cookie to be accessible only by the web server. |
   * | `maxAge`      | Number   | Convenient option for setting the expiry time relative to the current time in milliseconds. |
   * | `path`        | String   | Path for the cookie. Defaults to "/". |
   * | `partitioned` | Boolean  | Indicates that the cookie should be stored using partitioned storage. See [Cookies Having Independent Partitioned State (CHIPS)](https://developer.mozilla.org/en-US/docs/Web/Privacy/Partitioned_cookies) for more details. |
   * | `priority`    | String   | Value of the "Priority" Set-Cookie attribute. |
   * | `secure`      | Boolean  | Marks the cookie to be used with HTTPS only. |
   * | `signed`      | Boolean  | Indicates if the cookie should be signed. |
   * | `sameSite`    | Boolean or String | Value of the "SameSite" Set-Cookie attribute. More information at https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00#section-4.1.1. |
   *
   * > All `res.cookie()` does is set the HTTP `Set-Cookie` header with the options provided. Any option not specified defaults to the value stated in [RFC 6265](http://tools.ietf.org/html/rfc6265).
   *
   * For example:
   *
   * ```javascript
   * res.cookie('name', 'tobi', { domain: '.example.com', path: '/admin', secure: true })
   * res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true })
   * ```
   *
   * You can set multiple cookies in a single response by calling res.cookie multiple times, for example:
   *
   * ```javascript
   * res
   *   .status(201)
   *   .cookie('access_token', `Bearer ${token}`, {
   *     expires: new Date(Date.now() + 8 * 3600000) // cookie will be removed after 8 hours
   *   })
   *   .cookie('test', 'test')
   *   .redirect(301, '/admin')
   * ```
   *
   * The encode option allows you to choose the function used for cookie value encoding. Does not support asynchronous functions.
   *
   * Example use case: You need to set a domain-wide cookie for another site in your organization. This other site (not under your administrative control) does not use URI-encoded cookie values.
   *
   * ```javascript
   * // Default encoding
   * res.cookie('some_cross_domain_cookie', 'http://mysubdomain.example.com', { domain: 'example.com' })
   * // Result: 'some_cross_domain_cookie=http%3A%2F%2Fmysubdomain.example.com; Domain=example.com; Path=/'
   *
   * // Custom encoding
   * res.cookie('some_cross_domain_cookie', 'http://mysubdomain.example.com', { domain: 'example.com', encode: String })
   * // Result: 'some_cross_domain_cookie=http://mysubdomain.example.com; Domain=example.com; Path=/;'
   * ```
   *
   * The maxAge option is a convenience option for setting "expires" relative to the current time in milliseconds. The following is equivalent to the second example above.
   *
   * ```javascript
   * res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })
   * ```
   *
   * You can pass an object as the value parameter; it is then serialized as JSON and parsed by bodyParser() middleware.
   *
   * ```javascript
   * res.cookie('cart', { items: [1, 2, 3] })
   * res.cookie('cart', { items: [1, 2, 3] }, { maxAge: 900000 })
   * ```
   *
   * When using cookie-parser middleware, this method also supports signed cookies. Simply include the signed option set to true. Then, res.cookie() will use the secret passed to cookieParser(secret) to sign the value.
   *
   * ```javascript
   * res.cookie('name', 'tobi', { signed: true })
   * ```
   *
   * Later, you may access this value through the `req.signedCookies` object.
   */
  cookie(name: string, value: string, options?: CookieOptions | undefined | null): void
  /**
   * Transfers the file at `path` as an "attachment". Typically, browsers will
   * prompt the user for download. By default, the `Content-Disposition`
   * header "filename=" parameter is derived from the `path` argument, but can
   * be overridden with the `filename` parameter. If `path` is relative, then
   * it will be based on the current working directory of the process or the
   * `root` option, if provided.
   *
   * > This API provides access to data on the running file system. Ensure
   * > that either (a) the way in which the `path` argument was constructed
   * > into an absolute path is secure if it contains user input or (b) set
   * > the `root` option to the absolute path of a directory to contain access
   * > within.
   * >
   * > When the `root` option is provided, the `path` argument is allowed to
   * > be a relative path, including containing `..`. Express will validate
   * > that the relative path provided as `path` will resolve within the given
   * > `root` option.
   *
   * The following table provides details on the options parameter.
   *
   * | Property | Description | Default |
   * | --- | --- | --- |
   * | `maxAge` | Sets the max-age property of the `Cache-Control` header in milliseconds or a string in [ms format](https://www.npmjs.org/package/ms) | 0 |
   * | `root` | Root directory for relative filenames. | |
   * | `lastModified` | Sets the `Last-Modified` header to the last modified date of the file on the OS. Set `false` to disable it. | Enabled |
   * | `headers` | Object containing HTTP headers to serve with the file. | |
   * | `dotfiles` | Option for serving dotfiles. Possible values are "allow", "deny", "ignore". | "ignore" |
   * | `acceptRanges` | Enable or disable accepting ranged requests. | true |
   * | `cacheControl` | Enable or disable setting `Cache-Control` response header. | true |
   * | `immutable` | Enable or disable the `immutable` directive in the `Cache-Control` response header. If enabled, the `maxAge` option should also be specified to enable caching. The `immutable` directive will prevent supported clients from making conditional requests during the life of the `maxAge` option to check if the file has changed. | false |
   *
   * The method invokes the callback function `fn(err)` when the transfer is
   * complete or when an error occurs. If the callback function is specified
   * and an error occurs, the callback function must explicitly handle the
   * response process either by ending the request-response cycle, or by
   * passing control to the next route.
   *
   * Here is an example of using `res.sendFile` with all its arguments.
   *
   * ```javascript
   * res.download('/report-12345.pdf')
   *
   * res.download('/report-12345.pdf', 'report.pdf')
   *
   * res.download('/report-12345.pdf', 'report.pdf', (err) => {
   *   if (err) {
   *     // Handle error, but keep in mind the response may be partially-sent
   *     // so check res.headersSent
   *   } else {
   *     // decrement a download credit, etc.
   *   }
   * })
   *
   * ```
   */
  download(path: string, options?: DownloadOptions | undefined | null): Promise<unknown>
  /**
   *  Performs content-negotiation on the Accept HTTP header on the request
   *  object, when present. It uses `req.accepts()` to select a handler for the
   *  request, based on the acceptable types ordered by their quality values.
   *  If the header is not specified, the first callback is invoked. When no
   *  match is found, the server responds with 406 "Not Acceptable", or invokes
   *  the default callback.
   *
   *  The `Content-Type` response header is set when a callback is selected.
   *  However, you may alter this within the callback using methods such as
   *  `res.set()` or `res.type()`.
   *
   *  The following example would respond with `{ "message": "hey" }` when the
   *  Accept header field is set to "application/json" or "*&#8203;/json" (however, if
   *  it is "*&#8203;/*", then the response will be "hey").
   *
   * ```javascript
   *  res.format({
   *    'text/plain' () {
   *      res.send('hey')
   *    },
   *
   *    'text/html' () {
   *      res.send('<p>hey</p>')
   *    },
   *
   *    'application/json' () {
   *      res.send({ message: 'hey' })
   *    },
   *
   *    default () {
   *      // log the request and respond with 406
   *      res.status(406).send('Not Acceptable')
   *    }
   *  })
   *  ```
   *
   *  In addition to canonicalized MIME types, you may also use extension names
   *  mapped to these types for a slightly less verbose implementation:
   *
   *  ```javascript
   *  res.format({
   *    text () {
   *      res.send('hey')
   *    },
   *
   *    html () {
   *      res.send('<p>hey</p>')
   *    },
   *
   *    json () {
   *      res.send({ message: 'hey' })
   *    }
   *  })
   *  ```
   */
  format(obj: object): Response
  /**
   * Returns the HTTP response header specified by `field`. The match is case-insensitive.
   *
   * ```javascript
   * res.get('Content-Type')
   * // => "text/plain"
   * ```
   */
  get(field: string): string | Buffer
  /**
   * Sends a JSON response. This method sends a response (with the correct
   * content-type) that is the parameter converted to a JSON string using
   * JSON.stringify().
   *
   * The parameter can be any JSON type, including object, array, string,
   * Boolean, number, or null, and you can also use it to convert other values
   * to JSON.
   *
   * ```javascript
   * res.json(null)
   * res.json({ user: 'tobi' })
   * res.status(500).json({ error: 'message' })
   * ```
   */
  json(body: string | number | boolean | object | null): void
  /**
   * Joins the links provided as properties of the parameter to populate the response’s Link HTTP header field.
   *
   * For example, the following call:
   *
   * ```javascript
   * res.links({
   *   next: 'http://api.example.com/users?page=2',
   *   last: 'http://api.example.com/users?page=5'
   * })
   * ```
   *
   * Yields the following results:
   *
   * ```text
   * Link: <http://api.example.com/users?page=2>; rel="next",
   *       <http://api.example.com/users?page=5>; rel="last"
   * ```
   */
  links(links: object): void
  /**
   * Sets the response Location HTTP header to the specified path parameter.
   *
   * ```javascript
   * res.location('/foo/bar')
   * res.location('http://example.com')
   * ```
   *
   * > After encoding the URL, if not encoded already, the specified URL is
   * > passed to the browser in the Location header, without any validation.
   * >
   * > Browsers take the responsibility of deriving the intended URL from the
   * > current URL or the referring URL, and the URL specified in the Location
   * > header; and redirect the user accordingly.
   *
   * The given `url` can also be "back", which redirects to the _Referrer_ or
   * _Referer_ headers or "/".
   */
  location(url: string): Response
  /**
   * Redirects to the URL derived from the specified `path`, with specified
   * `status`, a positive integer that corresponds to an
   * [HTTP status code](https://www.rfc-editor.org/rfc/rfc9110.html#name-status-codes).
   * If not specified, `status` defaults to `302 "Found"`.
   *
   * ```javascript
   * res.redirect('/foo/bar')
   * res.redirect('http://example.com')
   * res.redirect(301, 'http://example.com')
   * res.redirect('../login')
   * ```
   *
   * Redirects can be a fully-qualified URL for redirecting to a different site:
   *
   * ```javascript
   * res.redirect('http://google.com')
   * ```
   *
   * Redirects can be relative to the root of the host name. For example, if
   * the application is on `http://example.com/admin/post/new`, the following
   * would redirect to the URL `http://example.com/admin`:
   *
   * ```javascript
   * res.redirect('/admin')
   * ```
   *
   * Redirects can be relative to the current URL. For example, from
   * `http://example.com/blog/admin/` (notice the trailing slash), the
   * following would redirect to the URL
   * `http://example.com/blog/admin/post/new`.
   *
   * ```javascript
   * res.redirect('post/new')
   * ```
   *
   * Redirecting to `post/new` from `http://example.com/blog/admin` (no
   * trailing slash), will redirect to `http://example.com/blog/post/new`.
   *
   * If you found the above behavior confusing, think of path segments as
   * directories (with trailing slashes) and files, it will start to make
   * sense.
   *
   * Path-relative redirects are also possible. If you were on
   * `http://example.com/admin/post/new`, the following would redirect to
   * `http://example.com/admin/post`:
   *
   * ```javascript
   * res.redirect('..')
   * ```
   *
   * See also [Security best practices: Prevent open redirect vulnerabilities](http://expressjs.com/en/advanced/best-practice-security.html#prevent-open-redirects).
   */
  redirect(status: number | string, address?: string | undefined | null): void
  /**
   * Sends the HTTP response.
   *
   * The body parameter can be a Buffer object, a String, an object, Boolean, or
   * an Array. For example:
   *
   * ```javascript
   * res.send(Buffer.from('whoop'))
   * res.send({ some: 'json' })
   * res.send('<p>some html</p>')
   * res.status(404).send('Sorry, we cannot find that!')
   * res.status(500).send({ error: 'something blew up' })
   * ```
   *
   * This method performs many useful tasks for simple non-streaming responses:
   * For example, it automatically assigns the Content-Length HTTP response
   * header field and provides automatic HEAD and HTTP cache freshness support.
   *
   * When the parameter is a Buffer object, the method sets the Content-Type
   * response header field to "application/octet-stream", unless previously
   * defined as shown below:
   *
   * ```javascript
   * res.set('Content-Type', 'text/html')
   * res.send(Buffer.from('<p>some html</p>'))
   * ```
   *
   * When the parameter is a String, the method sets the Content-Type to
   * "text/html":
   *
   * ```javascript
   * res.send('<p>some html</p>')
   * ```
   *
   * When the parameter is an Array or Object, Express responds with the JSON
   * representation:
   *
   * ```javascript
   * res.send({ user: 'tobi' })
   * res.send([1, 2, 3])
   * ```
   */
  send(body: string | number | boolean | null | Buffer | object): void
  /**
   * Transfers the file at the given `path`. Sets the `Content-Type` response
   * HTTP header field based on the filename’s extension. Unless the `root`
   * option is set in the options object, `path` must be an absolute path to
   * the file.
   *
   * > This API provides access to data on the running file system. Ensure
   * > that either (a) the way in which the `path` argument was constructed
   * > into an absolute path is secure if it contains user input or (b) set
   * > the `root` option to the absolute path of a directory to contain access
   * > within.
   * >
   * > When the `root` option is provided, the `path` argument is allowed to
   * > be a relative path, including containing `..`. Express will validate
   * > that the relative path provided as `path` will resolve within the given
   * > `root` option.
   *
   * The following table provides details on the options parameter.
   *
   * | Property | Description | Default |
   * | --- | --- | --- |
   * | `maxAge` | Sets the max-age property of the `Cache-Control` header in milliseconds or a string in [ms format](https://www.npmjs.org/package/ms) | 0 |
   * | `root` | Root directory for relative filenames. | |
   * | `lastModified` | Sets the `Last-Modified` header to the last modified date of the file on the OS. Set `false` to disable it. | Enabled |
   * | `headers` | Object containing HTTP headers to serve with the file. | |
   * | `dotfiles` | Option for serving dotfiles. Possible values are "allow", "deny", "ignore". | "ignore" |
   * | `acceptRanges` | Enable or disable accepting ranged requests. | true |
   * | `cacheControl` | Enable or disable setting `Cache-Control` response header. | true |
   * | `immutable` | Enable or disable the `immutable` directive in the `Cache-Control` response header. If enabled, the `maxAge` option should also be specified to enable caching. The `immutable` directive will prevent supported clients from making conditional requests during the life of the `maxAge` option to check if the file has changed. | false |
   *
   * The method invokes the callback function `fn(err)` when the transfer is
   * complete or when an error occurs. If the callback function is specified
   * and an error occurs, the callback function must explicitly handle the
   * response process either by ending the request-response cycle, or by
   * passing control to the next route.
   *
   * Here is an example of using `res.sendFile` with all its arguments.
   *
   * ```javascript
   * app.get('/file/:name', (req, res, next) => {
   *   const options = {
   *     root: path.join(__dirname, 'public'),
   *     dotfiles: 'deny',
   *     headers: {
   *       'x-timestamp': Date.now(),
   *       'x-sent': true
   *     }
   *   }
   *
   *   const fileName = req.params.name
   *   res.sendFile(fileName, options, (err) => {
   *     if (err) {
   *       next(err)
   *     } else {
   *       console.log('Sent:', fileName)
   *     }
   *   })
   * })
   * ```
   *
   * The following example illustrates using `res.sendFile` to provide
   * fine-grained support for serving files:
   *
   * ```javascript
   * app.get('/user/:uid/photos/:file', (req, res) => {
   *   const uid = req.params.uid
   *   const file = req.params.file
   *
   *   req.user.mayViewFilesFrom(uid, (yes) => {
   *     if (yes) {
   *       res.sendFile(`/uploads/${uid}/${file}`)
   *     } else {
   *       res.status(403).send("Sorry! You can't see that.")
   *     }
   *   })
   * })
   * ```
   *
   * For more information, or if you have issues or concerns, see
   * [send](https://github.com/pillarjs/send).
   */
  sendFile(path: string, options?: SendFileOptions | undefined | null): Promise<unknown>
  /**
   * Sets the response HTTP status code to statusCode and sends the registered
   * status message as the text response body. If an unknown status code is
   * specified,`res.statusCode` will throw an error
   *
   * ```javascript
   * res.sendStatus(404)
   * ```
   */
  sendStatus(body: number | StatusCode): void
  /**
   * Sets the response’s HTTP header field to value. To set multiple fields at
   * once, pass an object as the parameter.
   *
   * ```javascript
   * res.set('Content-Type', 'text/plain')
   *
   * res.set({
   *   'Content-Type': 'text/plain',
   *   'Content-Length': '123',
   *   ETag: '12345',
   *   Link: ['<http://localhost/>', '<http://localhost:3000/>']
   * })
   * ```
   *
   * Aliased as res.header(field [, value]).
   */
  set(field: string | object, value?: string | undefined | null): Response
  /**
   * Sets the HTTP status for the response.
   *
   * ```javascript
   * res.status(403).end()
   * res.status(400).send('Bad Request')
   * res.status(404).sendFile('/absolute/path/to/404.png')
   * ```
   */
  status(body: number | StatusCode): Response
  /**
   * Adds the field to the `Vary` response header, if it is not there already.
   *
   * ``` javascript
   * res.vary('User-Agent').render('docs')
   * ```
   */
  vary(field: string): void
  constructor()
  end(data?: string | Buffer | Uint8Array | undefined | null): void
  get req(): Request
}

/** HTTP Server that integrates with JavaScript handlers via Router */
export declare class Server {
  /** Create a new server with a router */
  constructor()
  delete(route: string, handler: JsHandlerFn): void
  get(route: string, handler: JsHandlerFn): void
  post(route: string, handler: JsHandlerFn): void
  put(route: string, handler: JsHandlerFn): void
  use(route: string | undefined | null, middleware: JsHandlerFn): void
  acmeConfigMeta(config: AcmeConfigMeta): void
  listen(addr: string): void
}

/**
 * This is a built-in middleware function. It serves static files and is based
 * on [hyper-staticfile](https://docs.rs/hyper-staticfile/latest/hyper_staticfile/).
 *
 * > NOTE: For best results,
 * > [use a reverse proxy](https://expressjs.com/en/advanced/best-practice-performance.html#use-a-reverse-proxy)
 * > cache to improve performance of serving static assets.
 *
 * The `root` argument specifies the root directory from which to serve static
 * assets. The function determines the file to serve by combining `req.url`
 * with the provided `root` directory. When a file is not found, instead of
 * sending a 404 response, it instead calls `next()` to move on to the next
 * middleware, allowing for stacking and fall-backs.
 *
 * Example of using the StaticMiddleware
 * Here is an example of using the Static middleware with an elaborate options object:
 *
 * ```javascript
 * const options = {
 *   dotfiles: 'ignore',
 *   etag: false,
 *   extensions: ['htm', 'html'],
 *   index: false,
 *   maxAge: '1d',
 *   redirect: false,
 *   setHeaders (res, path, stat) {
 *     res.set('x-timestamp', Date.now())
 *   }
 * }
 *
 * app.use(new StaticMiddleware('public', options))
 * ```
 */
export declare class StaticMiddleware {
  constructor(root: string, options?: JsStaticOptions | undefined | null)
  run(request: Request, response: Response): Promise<unknown>
}

export declare class StatusCode {
  static fromU16(src: number): StatusCode
  static fromBytes(src: Uint8Array): StatusCode
  toString(): string
  canonicalReason(): string | null
  isInformational(): boolean
  isSuccess(): boolean
  isRedirection(): boolean
  isClientError(): boolean
  static continue(): StatusCode
  static switchingProtocols(): StatusCode
  static processing(): StatusCode
  static ok(): StatusCode
  static created(): StatusCode
  static accepted(): StatusCode
  static nonAuthoritativeInformation(): StatusCode
  static noContent(): StatusCode
  static resetContent(): StatusCode
  static partialContent(): StatusCode
  static multiStatus(): StatusCode
  static alreadyReported(): StatusCode
  static imUsed(): StatusCode
  static multipleChoices(): StatusCode
  static movedPermanently(): StatusCode
  static found(): StatusCode
  static seeOther(): StatusCode
  static notModified(): StatusCode
  static useProxy(): StatusCode
  static temporaryRedirect(): StatusCode
  static permanentRedirect(): StatusCode
  static badRequest(): StatusCode
  static unauthorized(): StatusCode
  static paymentRequired(): StatusCode
  static forbidden(): StatusCode
  static notFound(): StatusCode
  static methodNotAllowed(): StatusCode
  static notAcceptable(): StatusCode
  static proxyAuthenticationRequired(): StatusCode
  static requestTimeout(): StatusCode
  static conflict(): StatusCode
  static gone(): StatusCode
  static lengthRequired(): StatusCode
  static preconditionFailed(): StatusCode
  static payloadTooLarge(): StatusCode
  static uriTooLong(): StatusCode
  static unsupportedMediaType(): StatusCode
  static rangeNotSatisfiable(): StatusCode
  static expectationFailed(): StatusCode
  static imATeapot(): StatusCode
  static misdirectedRequest(): StatusCode
  static unprocessableEntity(): StatusCode
  static locked(): StatusCode
  static failedDependency(): StatusCode
  static tooEarly(): StatusCode
  static upgradeRequired(): StatusCode
  static preconditionRequired(): StatusCode
  static tooManyRequests(): StatusCode
  static requestHeaderFieldsTooLarge(): StatusCode
  static unavailableForLegalReasons(): StatusCode
  static internalServerError(): StatusCode
  static notImplemented(): StatusCode
  static badGateway(): StatusCode
  static serviceUnavailable(): StatusCode
  static gatewayTimeout(): StatusCode
  static httpVersionNotSupported(): StatusCode
  static variantAlsoNegotiates(): StatusCode
  static insufficientStorage(): StatusCode
  static loopDetected(): StatusCode
  static notExtended(): StatusCode
  static networkAuthenticationRequired(): StatusCode
}

/**
 * This is a built-in middleware function in Express. It parses incoming
 * request payloads into a string.
 *
 * Returns middleware that parses all bodies as a string and only looks at
 * requests where the `Content-Type` header matches the `type` option. This
 * parser accepts any Unicode encoding of the body and supports automatic
 * inflation of `gzip` and `deflate` encodings.
 *
 * A new `body` string containing the parsed data is populated on the
 * `request` object after the middleware (i.e. `req.body`), or `undefined` if
 * there was no body to parse, the `Content-Type` was not matched, or an error
 * occurred.
 *
 * > As `req.body`’s shape is based on user-controlled input, all properties
 * > and values in this object are untrusted and should be validated before
 * > trusting. For example, `req.body.trim()` may fail in multiple ways, for
 * > example stacking multiple parsers `req.body` may be from a different
 * > parser. Testing that `req.body` is a string before calling string methods
 * > is recommended.
 */
export declare class TextMiddleware {
  constructor(options?: JsTextOptions | undefined | null)
  run(request: Request, response: Response): Promise<boolean>
}

/**
 * This is a built-in middleware function in Express. It parses incoming
 * requests with urlencoded payloads.
 *
 * Returns middleware that only parses urlencoded bodies and only looks at
 * requests where the `Content-Type` header matches the `type` option. This
 * parser accepts only UTF-8 encoding of the body and supports automatic
 * inflation of `gzip` and `deflate` encodings.
 *
 * A new `body` object containing the parsed data is populated on the
 * `request` object after the middleware (i.e. `req.body`), or `undefined` if
 * there was no body to parse, the `Content-Type` was not matched, or an error
 * occurred. This object will contain key-value pairs, where the value can be
 * a string or array (when `extended` is `false`), or any type (when
 * `extended` is `true`).
 *
 * > As `req.body`’s shape is based on user-controlled input, all properties
 * > and values in this object are untrusted and should be validated before
 * > trusting. For example, `req.body.foo.toString()` may fail in multiple
 * > ways, for example `foo` may not be there or may not be a string, and
 * > `toString` may not be a function and instead a string or other
 * > user-input.
 */
export declare class UrlencodedMiddleware {
  constructor(options?: JsUrlencodedOptions | undefined | null)
  run(request: Request, response: Response): Promise<boolean>
}

export declare class Version {
  static http09(): Version
  static http10(): Version
  static http11(): Version
  static http2(): Version
  static http3(): Version
}

export interface AcmeConfigMeta {
  domains: Array<string>
  contactEmail: string
  cacheDir: string
}

export interface ClearCookie {

}

export interface CookieOptions {
  domain?: string
  encode?: (arg: string) => string
  expires?: Date | ClearCookie
  httpOnly?: boolean
  maxAge?: number
  path?: string
  partitioned?: boolean
  priority?: string
  secure?: boolean
  signed?: boolean
  sameSite?: boolean | string
}

export interface DownloadOptions {
  maxAge?: number
  root?: string
  lastModified?: boolean
  headers?: object
  dotfiles?: string
  acceptRanges?: boolean
  cacheControl?: boolean
  immutable?: boolean
}

export interface JsCookieParserOptions {
  /**
   * If `true`, the cookie value will be percent-decoded
   *
   * A cookie whose value is `foo=bar%20baz; HttpOnly` gets parsed into the
   * name-value pair `"foo", "bar baz"`
   */
  percentDecode?: boolean
}

export interface JsJsonOptions {
  /**
   * Enables or disables handling deflated (compressed) bodies; when disabled,
   * deflated bodies are rejected.
   *
   * Default = true
   */
  inflate?: boolean
  /**
   * Controls the maximum request body size. If this is a number, then the
   * value specifies the number of bytes; if it is a string, the value is
   * passed to the [bytes](https://docs.rs/byte-unit/latest/byte_unit/)
   * library for parsing.
   *
   * Default = "100kb"
   */
  limit?: number | string
  /**
   * TODO: Add support for reviver option
   *
   * Default = none
   */
  reviver?: any
  /**
   * Enables or disables only accepting arrays and objects; when disabled will
   * accept anything `serde_json::from_slice` accepts.
   *
   * Default = true
   */
  strict?: boolean
  /**
   * This is used to determine what media type the middleware will parse. This
   * option can be a string, array of strings, or a function. If not a
   * function, `type` option is passed directly to the
   * [mime_guess](https://docs.rs/mime_guess/latest/mime_guess/) library and
   * this can be an extension name (like `json`), a mime type (like
   * `application/json`), or a mime type with a wildcard (like `*\/*` or
   * `*\/json`).
   *
   * If a function, the type option is called as `fn(req)` and the request is
   * parsed if it return `true`.
   *
   * Default = "application/json"
   */
  typ?: string | Array<string> | ((arg: Request) => boolean)
  /**
   * This option, if supplied, is called as `verify(req, res, buf, encoding)`,
   * where `buf` is a `Buffer` of the raw request body and `encoding` is the
   * encoding of the request. The parsing can be aborted by throwing an error.
   *
   * Default = none
   */
  verify?: JsVerifyFn
}

export interface JsRawOptions {
  /**
   * Enables or disables handling deflated (compressed) bodies; when disabled,
   * deflated bodies are rejected.
   *
   * Default = true
   */
  inflate?: boolean
  /**
   * Controls the maximum request body size. If this is a number, then the
   * value specifies the number of bytes; if it is a string, the value is
   * passed to the [bytes](https://docs.rs/byte-unit/latest/byte_unit/)
   * library for parsing.
   *
   * Default = "100kb"
   */
  limit?: number | string
  /**
   * This is used to determine what media type the middleware will parse. This
   * option can be a string, array of strings, or a function. If not a
   * function, `type` option is passed directly to the
   * [mime_guess](https://docs.rs/mime_guess/latest/mime_guess/) library and
   * this can be an extension name (like `bin`), a mime type (like
   * `application/octet-stream`), or a mime type with a wildcard (like `*\/*`
   * or `application/*`).
   *
   * If a function, the type option is called as `fn(req)` and the request is
   * parsed if it return `true`.
   *
   * Default = "application/octet-stream"
   */
  typ?: string | Array<string> | ((arg: Request) => boolean)
  /**
   * This option, if supplied, is called as `verify(req, res, buf, encoding)`,
   * where `buf` is a `Buffer` of the raw request body and `encoding` is the
   * encoding of the request. The parsing can be aborted by throwing an error.
   *
   * Default = none
   */
  verify?: JsVerifyFn
}

export interface JsStaticOptions {
  /**
   * Determines how dotfiles (files or directories that begin with a dot “.”)
   * are treated.
   *
   * Possible values for this option are:
   *
   * - “allow” - No special treatment for dotfiles.
   * - “deny” - Deny a request for a dotfile, respond with `403`, then call
   * `next()`.
   * - “ignore” - Act as if the dotfile does not exist, respond with `404`,
   * then call `next()`.
   *
   * Default: "ignore"
   */
  dotfiles?: string
  /**
   * Enable or disable etag generation
   *
   * Default: true
   */
  etag?: boolean
  /**
   * Sets file extension fallbacks: If a file is not found, search for files
   * with the specified extensions and serve the first one found. Example:
   * `['html', 'htm']`.
   *
   * Default: false
   */
  extensions?: string | Array<string> | boolean
  /**
   * Let client errors fall-through as unhandled requests, otherwise forward a
   * client error.
   *
   * When this option is `true`, client errors such as a bad request or a
   * request to a non-existent file will cause this middleware to simply call
   * `next()` to invoke the next middleware in the stack. When `false`, these
   * errors (even `404`s), will invoke `next(err)`.
   *
   * Set this option to `true` so you can map multiple physical directories to
   * the same web address or for routes to fill in non-existent files.
   *
   * Use `false` if you have mounted this middleware at a path designed to be
   * strictly a single file system directory, which allows for
   * short-circuiting `404`s for less overhead. This middleware will also
   * reply to all methods.
   *
   * Default: true
   */
  fallthrough?: boolean
  /**
   * Enable or disable the `immutable` directive in the `Cache-Control`
   * response header. If enabled, the `maxAge` option should also be specified
   * to enable caching. The `immutable` directive will prevent supported
   * clients from making conditional requests during the life of the `maxAge`
   * option to check if the file has changed.
   *
   * Default: false
   */
  immutable?: boolean
  /**
   * Sends the specified directory index file. Set to `false` to disable
   * directory indexing.
   *
   * Default: "index.html"
   */
  index?: string | Array<string> | boolean
  /**
   * Set the `Last-Modified` header to the last modified date of the file on
   * the OS.
   *
   * Default: true
   */
  lastModified?: boolean
  /**
   * Set the max-age property of the Cache-Control header in milliseconds or a
   * string in [jackdauer](https://docs.rs/jackdauer/0.1.2/jackdauer/) format.
   *
   * Default: 0
   */
  maxAge?: number
  /**
   * Redirect to trailing “/” when the pathname is a directory.
   *
   * Default: true
   */
  redirect?: boolean
  /**
   * Function for setting HTTP headers to serve with the file.
   *
   * For this option, specify a function to set custom response headers.
   * Alterations to the headers must occur synchronously.
   *
   * The signature of the function is:
   *
   * ```javascript
   * fn(res, path, stat)
   * ```
   *
   * Arguments:
   *
   * - `res`, the response object.
   * - `path`, the file path that is being sent.
   * - `stat`, the `stat` object of the file that is being sent.
   *
   * Default: undefined
   */
  setHeaders?: JsSetHeadersFn
  /**
   * Enable or disable accepting ranged requests. Disabling this will not send
   * the `Accept-Ranges` header and will ignore the contents of the `Range`
   * request header.
   *
   * Default: true
   */
  acceptRanges?: boolean
  /**
   * Enable or disable setting the `Cache-Control` response header. Disabling
   * this will ignore the `immutable` and `maxAge` options.
   *
   * Default: true
   */
  cacheControl?: boolean
}

export interface JsTextOptions {
  /**
   * Specify the default character set for the text content if the charset is
   * not specified in the `Content-Type` header of the request.
   *
   * Default = "utf-8"
   */
  defaultCharset?: string
  /**
   * Enables or disables handling deflated (compressed) bodies; when disabled,
   * deflated bodies are rejected.
   *
   * Default = true
   */
  inflate?: boolean
  /**
   * Controls the maximum request body size. If this is a number, then the
   * value specifies the number of bytes; if it is a string, the value is
   * passed to the [bytes](https://docs.rs/byte-unit/latest/byte_unit/)
   * library for parsing.
   *
   * Default = "100kb"
   */
  limit?: number | string
  /**
   * This is used to determine what media type the middleware will parse. This
   * option can be a string, array of strings, or a function. If not a
   * function, `type` option is passed directly to the
   * [mime_guess](https://docs.rs/mime_guess/latest/mime_guess/) library and
   * this can be an extension name (like `txt`), a mime type (like
   * `text/plain`), or a mime type with a wildcard (like `*\/*` or `text/*`).
   * If a function, the type option is called as `fn(req)` and the request is
   * parsed if it returns a truthy value.
   *
   * Default = "text/plain"
   */
  typ?: string
  /**
   * This option, if supplied, is called as `verify(req, res, buf, encoding)`,
   * where `buf` is a `Buffer` of the raw request body and `encoding` is the
   * encoding of the request. The parsing can be aborted by throwing an error.
   */
  verify?: JsVerifyFn
}

export interface JsUrlencodedOptions {
  /**
   * This option allows to choose between parsing the URL-encoded data with
   * the `serde_urlencoded` library (when `false`) or the `serde_qs` library
   * (when `true`). The "extended" syntax allows for rich objects and arrays
   * to be encoded into the URL-encoded format, allowing for a JSON-like
   * experience with URL-encoded. For more information, please
   * [see the serde_qs library](https://docs.rs/serde_qs/1.0.0/serde_qs/index.html).
   *
   * Default = false
   */
  extended?: boolean
  /**
   * Enables or disables handling deflated (compressed) bodies; when disabled,
   * deflated bodies are rejected.
   *
   * Default = true
   */
  inflate?: boolean
  /**
   * Controls the maximum request body size. If this is a number, then the
   * value specifies the number of bytes; if it is a string, the value is
   * passed to the [bytes](https://docs.rs/byte-unit/latest/byte_unit/)
   * library for parsing.
   *
   * Default = "100kb"
   */
  limit?: number | string
  /**
   * This option controls the maximum number of parameters that are allowed in
   * the URL-encoded data. If a request contains more parameters than this
   * value, an error will be raised.
   *
   * Default = 1000
   */
  parameterLimit?: number
  /**
   * This is used to determine what media type the middleware will parse. This
   * option can be a string, array of strings, or a function. If not a
   * function, `type` option is passed directly to the
   * [mime_guess](https://docs.rs/mime_guess/latest/mime_guess/) library and
   * this can be an extension name (like `urlencoded`), a mime type (like
   * `application/x-www-form-urlencoded`), or a mime type with a wildcard
   * (like `*\/x-www-form-urlencoded`). If a function, the type option is
   * called as `fn(req)` and the request is parsed if it returns a truthy
   * value.
   *
   * Default = "application/x-www-form-urlencoded"
   */
  typ?: string | Array<string> | ((arg: Request) => boolean)
  /**
   * This option, if supplied, is called as `verify(req, res, buf, encoding)`,
   * where `buf` is a `Buffer` of the raw request body and `encoding` is the
   * encoding of the request. The parsing can be aborted by throwing an error.
   */
  verify?: JsVerifyFn
  /**
   * Configure the maximum depth of the `serde_qs` library when extended is
   * `true`. This allows you to limit the amount of keys that are parsed and
   * can be useful to prevent certain types of abuse. It is recommended to
   * keep this value as low as possible.
   *
   * Default = 32
   */
  depth?: number
}

/** Represents a single byte range with start and end positions */
export interface Range {
  start: number
  end: number
}

/** Options for range parsing */
export interface RangeOptions {
  combine: boolean
}

/** Represents a collection of ranges with a type identifier */
export interface Ranges {
  ranges: Array<Range>
  rangeType: string
}

export interface SendFileOptions {
  maxAge?: number
  root?: string
  lastModified?: boolean
  headers?: object
  dotfiles?: string
  acceptRanges?: boolean
  cacheControl?: boolean
  immutable?: boolean
}

export declare function serializeNapiObject(obj: object): string