fastify 3.24.0 → 3.25.2

package/docs/{TypeScript.md → Reference/TypeScript.md}

@@ -2,25 +2,40 @@
 
 ## TypeScript
 
-The Fastify framework is written in vanilla JavaScript, and as such type definitions are not as easy to maintain; however, since version 2 and beyond, maintainers and contributors have put in a great effort to improve the types.
-
-The type system was changed in Fastify version 3. The new type system introduces generic constraining and defaulting, plus a new way to define schema types such as a request body, querystring, and more! As the team works on improving framework and type definition synergy, sometimes parts of the API will not be typed or may be typed incorrectly. We encourage you to **contribute** to help us fill in the gaps. Just make sure to read our [`CONTRIBUTING.md`](https://github.com/fastify/fastify/blob/HEAD/CONTRIBUTING.md) file before getting started to make sure things go smoothly!
+The Fastify framework is written in vanilla JavaScript, and as such type
+definitions are not as easy to maintain; however, since version 2 and beyond,
+maintainers and contributors have put in a great effort to improve the types.
+
+The type system was changed in Fastify version 3. The new type system introduces
+generic constraining and defaulting, plus a new way to define schema types such
+as a request body, querystring, and more! As the team works on improving
+framework and type definition synergy, sometimes parts of the API will not be
+typed or may be typed incorrectly. We encourage you to **contribute** to help us
+fill in the gaps. Just make sure to read our
+[`CONTRIBUTING.md`](https://github.com/fastify/fastify/blob/main/CONTRIBUTING.md)
+file before getting started to make sure things go smoothly!
 
 > The documentation in this section covers Fastify version 3.x typings
 
-> Plugins may or may not include typings. See [Plugins](#plugins) for more information. We encourage users to send pull requests to improve typings support.
+> Plugins may or may not include typings. See [Plugins](#plugins) for more
+> information. We encourage users to send pull requests to improve typings
+> support.
 
 🚨 Don't forget to install `@types/node`
 
 ## Learn By Example
 
-The best way to learn the Fastify type system is by example! The following four examples should cover the most common Fastify development cases. After the examples there is further, more detailed documentation for the type system.
+The best way to learn the Fastify type system is by example! The following four
+examples should cover the most common Fastify development cases. After the
+examples there is further, more detailed documentation for the type system.
 
 ### Getting Started
 
-This example will get you up and running with Fastify and TypeScript. It results in a blank http Fastify server.
+This example will get you up and running with Fastify and TypeScript. It results
+in a blank http Fastify server.
 
-1. Create a new npm project, install Fastify, and install typescript & node.js types as peer dependencies:
+1. Create a new npm project, install Fastify, and install typescript & node.js
+   types as peer dependencies:
   ```bash
   npm init -y
   npm i fastify
@@ -36,13 +51,15 @@ This example will get you up and running with Fastify and TypeScript. It results
   }
   ```
 
-*Note: Set `target` property in `tsconfig.json` to `es2017` or greater to avoid [FastifyDeprecation](https://github.com/fastify/fastify/issues/3284) warning.*
-
 3. Initialize a TypeScript configuration file:
   ```bash
   npx tsc --init
   ```
-  or use one of the [recommended ones](https://github.com/tsconfig/bases#node-10-tsconfigjson).
+  or use one of the [recommended
+  ones](https://github.com/tsconfig/bases#node-10-tsconfigjson).
+
+*Note: Set `target` property in `tsconfig.json` to `es2017` or greater to avoid
+[FastifyDeprecation](https://github.com/fastify/fastify/issues/3284) warning.*
 
 4. Create an `index.ts` file - this will contain the server code
 5. Add the following code block to your file:
@@ -63,18 +80,30 @@ This example will get you up and running with Fastify and TypeScript. It results
      console.log(`Server listening at ${address}`)
    })
    ```
-6. Run `npm run build` - this will compile `index.ts` into `index.js` which can be executed using Node.js. If you run into any errors please open an issue in [fastify/help](https://github.com/fastify/help/)
+6. Run `npm run build` - this will compile `index.ts` into `index.js` which can
+   be executed using Node.js. If you run into any errors please open an issue in
+   [fastify/help](https://github.com/fastify/help/)
 7. Run `npm run start` to run the Fastify server
 8. You should see `Server listening at http://127.0.0.1:8080` in your console
-9. Try out your server using `curl localhost:8080/ping`, it should return `pong` 🏓
+9. Try out your server using `curl localhost:8080/ping`, it should return `pong`
+   🏓
 
-🎉 You now have a working Typescript Fastify server! This example demonstrates the simplicity of the version 3.x type system. By default, the type system assumes you are using an `http` server. The later examples will demonstrate how to create more complex servers such as `https` and `http2`, how to specify route schemas, and more!
+🎉 You now have a working Typescript Fastify server! This example demonstrates
+the simplicity of the version 3.x type system. By default, the type system
+assumes you are using an `http` server. The later examples will demonstrate how
+to create more complex servers such as `https` and `http2`, how to specify route
+schemas, and more!
 
-> For more examples on initializing Fastify with TypeScript (such as enabling HTTP2) check out the detailed API section [here][Fastify]
+> For more examples on initializing Fastify with TypeScript (such as enabling
+> HTTP2) check out the detailed API section [here][Fastify]
 
 ### Using Generics
 
-The type system heavily relies on generic properties to provide the most accurate development experience. While some may find the overhead a bit cumbersome, the tradeoff is worth it! This example will dive into implementing generic types for route schemas and the dynamic properties located on the route-level `request` object.
+The type system heavily relies on generic properties to provide the most
+accurate development experience. While some may find the overhead a bit
+cumbersome, the tradeoff is worth it! This example will dive into implementing
+generic types for route schemas and the dynamic properties located on the
+route-level `request` object.
 
 1. If you did not complete the previous example, follow steps 1-4 to get set up.
 2. Inside `index.ts`, define two interfaces `IQuerystring` and `IHeaders`:
@@ -88,7 +117,13 @@ The type system heavily relies on generic properties to provide the most accurat
      'h-Custom': string;
    }
    ```
-3. Using the two interfaces, define a new API route and pass them as generics. The shorthand route methods (i.e. `.get`) accept a generic object `RouteGenericInterface` containing five named properties: `Body`, `Querystring`, `Params`, `Headers` and `Reply`. The interfaces `Body`, `Querystring`, `Params` and `Headers` will be passed down through the route method into the route method handler `request` instance and the `Reply` interface to the `reply` instance.
+3. Using the two interfaces, define a new API route and pass them as generics.
+   The shorthand route methods (i.e. `.get`) accept a generic object
+   `RouteGenericInterface` containing five named properties: `Body`,
+   `Querystring`, `Params`, `Headers` and `Reply`. The interfaces `Body`,
+   `Querystring`, `Params` and `Headers` will be passed down through the route
+   method into the route method handler `request` instance and the `Reply`
+   interface to the `reply` instance.
    ```typescript
    server.get<{
      Querystring: IQuerystring,
@@ -108,7 +143,9 @@ The type system heavily relies on generic properties to provide the most accurat
    curl localhost:8080/auth?username=admin&password=Password123!
    ```
    And it should return back `logged in!`
-6. But wait theres more! The generic interfaces are also available inside route level hook methods. Modify the previous route by adding a `preValidation` hook:
+6. But wait theres more! The generic interfaces are also available inside route
+   level hook methods. Modify the previous route by adding a `preValidation`
+   hook:
    ```typescript
    server.get<{
      Querystring: IQuerystring,
@@ -124,25 +161,38 @@ The type system heavily relies on generic properties to provide the most accurat
      return `logged in!`
    })
    ```
-7. Build and run and query with the `username` query string option set to anything other than `admin`. The API should now return a HTTP 500 error `{"statusCode":500,"error":"Internal Server Error","message":"Must be admin"}`
+7. Build and run and query with the `username` query string option set to
+   anything other than `admin`. The API should now return a HTTP 500 error
+   `{"statusCode":500,"error":"Internal Server Error","message":"Must be
+   admin"}`
 
-🎉 Good work, now you can define interfaces for each route and have strictly typed request and reply instances. Other parts of the Fastify type system rely on generic properties. Make sure to reference the detailed type system documentation below to learn more about what is available.
+🎉 Good work, now you can define interfaces for each route and have strictly
+typed request and reply instances. Other parts of the Fastify type system rely
+on generic properties. Make sure to reference the detailed type system
+documentation below to learn more about what is available.
 
 ### JSON Schema
 
-To validate your requests and responses you can use JSON Schema files. If you didn't know already, defining schemas for your Fastify routes can increase their throughput! Check out the [Validation and Serialization](Validation-and-Serialization.md) documentation for more info.
+To validate your requests and responses you can use JSON Schema files. If you
+didn't know already, defining schemas for your Fastify routes can increase their
+throughput! Check out the [Validation and
+Serialization](./Validation-and-Serialization.md) documentation for more info.
 
-Also it has the advantage to use the defined type within your handlers (including pre-validation, etc.).
+Also it has the advantage to use the defined type within your handlers
+(including pre-validation, etc.).
 
 Here are some options how to achieve this.
 
 
 #### typebox
 
-A useful library for building types and a schema at once is [typebox](https://www.npmjs.com/package/@sinclair/typebox).
-With typebox you define your schema within your code and use them directly as types or schemas as you need them.
+A useful library for building types and a schema at once is
+[typebox](https://www.npmjs.com/package/@sinclair/typebox). With typebox you
+define your schema within your code and use them directly as types or schemas as
+you need them.
 
-When you want to use it for validation of some payload in a fastify route you can do it as follows:
+When you want to use it for validation of some payload in a fastify route you
+can do it as follows:
 
 1. Install `typebox` in your project.
 
@@ -150,8 +200,9 @@ When you want to use it for validation of some payload in a fastify route you ca
     npm i @sinclair/typebox
     ```
 
-2. Define the schema you need with `Type` and create the respective type  with `Static`.
-  
+2. Define the schema you need with `Type` and create the respective type  with
+   `Static`.
+
     ```typescript
     import { Static, Type } from '@sinclair/typebox'
 
@@ -177,8 +228,8 @@ When you want to use it for validation of some payload in a fastify route you ca
           },
         },
       },
-      (req, rep) => {
-        const { body: user } = req;
+      (request, reply) => {
+        const { body: user } = request;
         /* user has type
         * const user: StaticProperties<{
         *  name: TString;
@@ -186,23 +237,29 @@ When you want to use it for validation of some payload in a fastify route you ca
         * }>
         */
         //...
-        rep.status(200).send(user);
+        reply.status(200).send(user);
       }
     );
     ```
 
 #### Schemas in JSON Files
 
-In the last example we used interfaces to define the types for the request querystring and headers. Many users will already be using JSON Schemas to define these properties, and luckily there is a way to transform existing JSON Schemas into TypeScript interfaces!
+In the last example we used interfaces to define the types for the request
+querystring and headers. Many users will already be using JSON Schemas to define
+these properties, and luckily there is a way to transform existing JSON Schemas
+into TypeScript interfaces!
 
-1. If you did not complete the 'Getting Started' example, go back and follow steps 1-4 first.
+1. If you did not complete the 'Getting Started' example, go back and follow
+   steps 1-4 first.
 2. Install the `json-schema-to-typescript` module:
 
    ```bash
    npm i -D json-schema-to-typescript
    ```
 
-3. Create a new folder called `schemas` and add two files `headers.json` and `querystring.json`. Copy and paste the following schema definitions into the respective files:
+3. Create a new folder called `schemas` and add two files `headers.json` and
+   `querystring.json`. Copy and paste the following schema definitions into the
+   respective files:
 
    ```json
    {
@@ -239,8 +296,10 @@ In the last example we used interfaces to define the types for the request query
    }
 ```
 
-   `json2ts` is a CLI utility included in `json-schema-to-typescript`. `schemas` is the input path, and `types` is the output path.
-5. Run `npm run compile-schemas`. Two new files should have been created in the `types` directory.
+   `json2ts` is a CLI utility included in `json-schema-to-typescript`. `schemas`
+   is the input path, and `types` is the output path.
+5. Run `npm run compile-schemas`. Two new files should have been created in the
+   `types` directory.
 6. Update `index.ts` to have the following code:
 
 ```typescript
@@ -309,13 +368,17 @@ In the last example we used interfaces to define the types for the request query
      console.log(`Server listening at ${address}`)
    })
    ```
-   Pay special attention to the imports at the top of this file. It might seem redundant, but you need to import both the schema files and the generated interfaces.
+   Pay special attention to the imports at the top of this file. It might seem
+   redundant, but you need to import both the schema files and the generated
+   interfaces.
 
-Great work! Now you can make use of both JSON Schemas and TypeScript definitions.
+Great work! Now you can make use of both JSON Schemas and TypeScript
+definitions.
 
 #### json-schema-to-ts
 
-If you do not want to generate types from your schemas, but want to use them diretly from your code, you can use the package
+If you do not want to generate types from your schemas, but want to use them
+diretly from your code, you can use the package
 [json-schema-to-ts](https://www.npmjs.com/package/json-schema-to-ts).
 
 You can install it as dev-dependency.
@@ -324,7 +387,8 @@ You can install it as dev-dependency.
 npm install -D json-schema-to-ts
 ```
 
-In your code you can define your schema like a normal object. But be aware of making it *const* like explained in the docs of the module.
+In your code you can define your schema like a normal object. But be aware of
+making it *const* like explained in the docs of the module.
 
 ```typescript
 const todo = {
@@ -338,7 +402,8 @@ const todo = {
 } as const;
 ```
 
-With the provided type `FromSchema` you can build a type from your schema and use it in your handler.
+With the provided type `FromSchema` you can build a type from your schema and
+use it in your handler.
 
 ```typescript
 import { FromSchema } from "json-schema-to-ts";
@@ -357,7 +422,7 @@ fastify.post<{ Body: FromSchema<typeof todo> }>(
   async (request, reply): Promise<void> => {
 
     /*
-    request.body has type 
+    request.body has type
     {
       [x: string]: unknown;
       description?: string;
@@ -368,7 +433,7 @@ fastify.post<{ Body: FromSchema<typeof todo> }>(
 
     request.body.name // will not throw type error
     request.body.notthere // will throw type error
-    
+
     reply.status(201).send();
   },
 );
@@ -376,7 +441,13 @@ fastify.post<{ Body: FromSchema<typeof todo> }>(
 
 ### Plugins
 
-One of Fastify's most distinguishable features is its extensive plugin ecosystem. Plugin types are fully supported, and take advantage of the [declaration merging]() pattern. This example is broken up into three parts: Creating a TypeScript Fastify Plugin, Creating Type Definitions for a Fastify Plugin, and Using a Fastify Plugin in a TypeScript Project.
+One of Fastify's most distinguishable features is its extensive plugin
+ecosystem. Plugin types are fully supported, and take advantage of the
+[declaration
+merging](https://www.typescriptlang.org/docs/handbook/declaration-merging.html)
+pattern. This example is broken up into three parts: Creating a TypeScript
+Fastify Plugin, Creating Type Definitions for a Fastify Plugin, and Using a
+Fastify Plugin in a TypeScript Project.
 
 #### Creating a TypeScript Fastify Plugin
 
@@ -386,7 +457,8 @@ One of Fastify's most distinguishable features is its extensive plugin ecosystem
    npm i fastify fastify-plugin
    npm i -D typescript @types/node
    ```
-2. Add a `build` script to the `"scripts"` section and `'index.d.ts'` to the `"types"` section of the `package.json` file:
+2. Add a `build` script to the `"scripts"` section and `'index.d.ts'` to the
+   `"types"` section of the `package.json` file:
    ```json
    {
      "types": "index.d.ts",
@@ -399,7 +471,8 @@ One of Fastify's most distinguishable features is its extensive plugin ecosystem
    ```bash
    npx typescript --init
    ```
-   Once the file is generated, enable the `"declaration"` option in the `"compilerOptions"` object.
+   Once the file is generated, enable the `"declaration"` option in the
+   `"compilerOptions"` object.
    ```json
    {
      "compileOptions": {
@@ -447,13 +520,20 @@ One of Fastify's most distinguishable features is its extensive plugin ecosystem
    // or
    // export default fp(myPluginAsync, '3.x')
    ```
-6. Run `npm run build` to compile the plugin code and produce both a JavaScript source file and a type definition file.
+6. Run `npm run build` to compile the plugin code and produce both a JavaScript
+   source file and a type definition file.
 7. With the plugin now complete you can [publish to npm] or use it locally.
-   > You do not _need_ to publish your plugin to npm to use it. You can include it in a Fastify project and reference it as you would any piece of code! As a TypeScript user, make sure the declaration override exists somewhere that will be included in your project compilation so the TypeScript interpreter can process it.
+   > You do not _need_ to publish your plugin to npm to use it. You can include
+   > it in a Fastify project and reference it as you would any piece of code! As
+   > a TypeScript user, make sure the declaration override exists somewhere that
+   > will be included in your project compilation so the TypeScript interpreter
+   > can process it.
 
 #### Creating Type Definitions for a Fastify Plugin
 
-This plugin guide is for Fastify plugins written in JavaScript. The steps outlined in this example are for adding TypeScript support for users consuming your plugin.
+This plugin guide is for Fastify plugins written in JavaScript. The steps
+outlined in this example are for adding TypeScript support for users consuming
+your plugin.
 
 1. Initialize a new npm project and install required dependencies
    ```bash
@@ -461,7 +541,9 @@ This plugin guide is for Fastify plugins written in JavaScript. The steps outlin
    npm i fastify-plugin
    ```
 2. Create two files `index.js` and `index.d.ts`
-3. Modify the package json to include these files under the `main` and `types` properties (the name does not have to be `index` explicitly, but it is recommended the files have the same name):
+3. Modify the package json to include these files under the `main` and `types`
+   properties (the name does not have to be `index` explicitly, but it is
+   recommended the files have the same name):
    ```json
    {
      "main": "index.js",
@@ -517,25 +599,48 @@ This plugin guide is for Fastify plugins written in JavaScript. The steps outlin
    export default myPlugin
    ```
 
-__Note__: [fastify-plugin](https://github.com/fastify/fastify-plugin) v2.3.0 and newer, automatically adds `.default` property and a named export to the exported plugin. Be sure to `export default` and `export const myPlugin` in your typings to provide the best developer experience. For a complete example you can check out [fastify-swagger](https://github.com/fastify/fastify-swagger/blob/master/index.d.ts).
+__Note__: [fastify-plugin](https://github.com/fastify/fastify-plugin) v2.3.0 and
+newer, automatically adds `.default` property and a named export to the exported
+plugin. Be sure to `export default` and `export const myPlugin` in your typings
+to provide the best developer experience. For a complete example you can check
+out
+[fastify-swagger](https://github.com/fastify/fastify-swagger/blob/master/index.d.ts).
 
-With those files completed, the plugin is now ready to be consumed by any TypeScript project!
+With those files completed, the plugin is now ready to be consumed by any
+TypeScript project!
 
-The Fastify plugin system enables developers to decorate the Fastify instance, and the request/reply instances. For more information check out this blog post on [Declaration Merging and Generic Inheritance](https://dev.to/ethanarrowood/is-declaration-merging-and-generic-inheritance-at-the-same-time-impossible-53cp).
+The Fastify plugin system enables developers to decorate the Fastify instance,
+and the request/reply instances. For more information check out this blog post
+on [Declaration Merging and Generic
+Inheritance](https://dev.to/ethanarrowood/is-declaration-merging-and-generic-inheritance-at-the-same-time-impossible-53cp).
 
 #### Using a Plugin
 
-Using a Fastify plugin in TypeScript is just as easy as using one in JavaScript. Import the plugin with `import/from` and you're all set -- except there is one exception users should be aware of.
+Using a Fastify plugin in TypeScript is just as easy as using one in JavaScript.
+Import the plugin with `import/from` and you're all set -- except there is one
+exception users should be aware of.
 
-Fastify plugins use declaration merging to modify existing Fastify type interfaces (check out the previous two examples for more details). Declaration merging is not very _smart_, meaning if the plugin type definition for a plugin is within the scope of the TypeScript interpreter, then the plugin types will be included **regardless** of if the plugin is being used or not. This is an unfortunate limitation of using TypeScript and is unavoidable as of right now.
+Fastify plugins use declaration merging to modify existing Fastify type
+interfaces (check out the previous two examples for more details). Declaration
+merging is not very _smart_, meaning if the plugin type definition for a plugin
+is within the scope of the TypeScript interpreter, then the plugin types will be
+included **regardless** of if the plugin is being used or not. This is an
+unfortunate limitation of using TypeScript and is unavoidable as of right now.
 
 However, there are a couple of suggestions to help improve this experience:
-- Make sure the `no-unused-vars` rule is enabled in [ESLint](https://eslint.org/docs/rules/no-unused-vars) and any imported plugin are actually being loaded.
-- Use a module such as [depcheck](https://www.npmjs.com/package/depcheck) or [npm-check](https://www.npmjs.com/package/npm-check) to verify plugin dependencies are being used somewhere in your project.
+- Make sure the `no-unused-vars` rule is enabled in
+  [ESLint](https://eslint.org/docs/rules/no-unused-vars) and any imported plugin
+  are actually being loaded.
+- Use a module such as [depcheck](https://www.npmjs.com/package/depcheck) or
+  [npm-check](https://www.npmjs.com/package/npm-check) to verify plugin
+  dependencies are being used somewhere in your project.
 
 ## Code Completion In Vanilla JavaScript
 
-Vanilla JavaScript can use the published types to provide code completion (e.g. [Intellisense](https://code.visualstudio.com/docs/editor/intellisense)) by following the [TypeScript JSDoc Reference](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html).
+Vanilla JavaScript can use the published types to provide code completion (e.g.
+[Intellisense](https://code.visualstudio.com/docs/editor/intellisense)) by
+following the [TypeScript JSDoc
+Reference](https://www.typescriptlang.org/docs/handbook/jsdoc-supported-types.html).
 
 For example:
 
@@ -548,17 +653,25 @@ module.exports = async function (fastify, { optionA, optionB }) {
 
 ## API Type System Documentation
 
-This section is a detailed account of all the types available to you in Fastify version 3.x
+This section is a detailed account of all the types available to you in Fastify
+version 3.x
 
 All `http`, `https`, and `http2` types are inferred from `@types/node`
 
-[Generics](#generics) are documented by their default value as well as their constraint value(s). Read these articles for more information on TypeScript generics.
-- [Generic Parameter Default](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-3.html#generic-parameter-defaults)
-- [Generic Constraints](https://www.typescriptlang.org/docs/handbook/generics.html#generic-constraints)
+[Generics](#generics) are documented by their default value as well as their
+constraint value(s). Read these articles for more information on TypeScript
+generics.
+- [Generic Parameter
+  Default](https://www.typescriptlang.org/docs/handbook/release-notes/typescript-2-3.html#generic-parameter-defaults)
+- [Generic
+  Constraints](https://www.typescriptlang.org/docs/handbook/generics.html#generic-constraints)
 
 #### How to import
 
-The Fastify API is powered by the `fastify()` method. In JavaScript you would import it using `const fastify = require('fastify')`. In TypeScript it is recommended to use the `import/from` syntax instead so types can be resolved. There are a couple supported import methods with the Fastify type system.
+The Fastify API is powered by the `fastify()` method. In JavaScript you would
+import it using `const fastify = require('fastify')`. In TypeScript it is
+recommended to use the `import/from` syntax instead so types can be resolved.
+There are a couple supported import methods with the Fastify type system.
 
 1. `import fastify from 'fastify'`
    - Types are resolved but not accessible using dot notation
@@ -585,7 +698,8 @@ The Fastify API is powered by the `fastify()` method. In JavaScript you would im
      ```
 2. `import * as Fastify from 'fastify'`
    - Types are resolved and accessible using dot notation
-   - Calling the main Fastify API method requires a slightly different syntax (see example)
+   - Calling the main Fastify API method requires a slightly different syntax
+     (see example)
    - Example:
      ```typescript
      import * as Fastify from 'fastify'
@@ -594,7 +708,8 @@ The Fastify API is powered by the `fastify()` method. In JavaScript you would im
      f.listen(8080, () => { console.log('running') })
      ```
 3. `const fastify = require('fastify')`
-   - This syntax is valid and will import fastify as expected; however, types will **not** be resolved
+   - This syntax is valid and will import fastify as expected; however, types
+     will **not** be resolved
    - Example:
      ```typescript
      const fastify = require('fastify')
@@ -612,7 +727,8 @@ The Fastify API is powered by the `fastify()` method. In JavaScript you would im
 
 #### Generics
 
-Many type definitions share the same generic parameters; they are all documented, in detail, within this section.
+Many type definitions share the same generic parameters; they are all
+documented, in detail, within this section.
 
 Most definitions depend on `@node/types` modules `http`, `https`, and `http2`
 
@@ -621,9 +737,11 @@ Underlying Node.js server type
 
 Default: `http.Server`
 
-Constraints: `http.Server`, `https.Server`, `http2.Http2Server`, `http2.Http2SecureServer`
+Constraints: `http.Server`, `https.Server`, `http2.Http2Server`,
+`http2.Http2SecureServer`
 
-Enforces generic parameters: [`RawRequest`][RawRequestGeneric], [`RawReply`][RawReplyGeneric]
+Enforces generic parameters: [`RawRequest`][RawRequestGeneric],
+[`RawReply`][RawReplyGeneric]
 
 ##### RawRequest
 Underlying Node.js request type
@@ -660,9 +778,16 @@ Constraints: `string | Buffer`
 #### Fastify
 
 ##### fastify<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [Logger][LoggerGeneric]>(opts?: [FastifyServerOptions][FastifyServerOptions]): [FastifyInstance][FastifyInstance]
-[src](./../fastify.d.ts#L19)
+[src](https://github.com/fastify/fastify/blob/main/fastify.d.ts#L19)
 
-The main Fastify API method. By default creates an HTTP server. Utilizing discriminant unions and overload methods, the type system will automatically infer which type of server (http, https, or http2) is being created purely based on the options based to the method (see the examples below for more information). It also supports an extensive generic type system to allow the user to extend the underlying Node.js Server, Request, and Reply objects. Additionally, the `Logger` generic exists for custom log types. See the examples and generic breakdown below for more information.
+The main Fastify API method. By default creates an HTTP server. Utilizing
+discriminant unions and overload methods, the type system will automatically
+infer which type of server (http, https, or http2) is being created purely based
+on the options based to the method (see the examples below for more
+information). It also supports an extensive generic type system to allow the
+user to extend the underlying Node.js Server, Request, and Reply objects.
+Additionally, the `Logger` generic exists for custom log types. See the examples
+and generic breakdown below for more information.
 
 ###### Example 1: Standard HTTP server
 
@@ -672,7 +797,8 @@ import fastify from 'fastify'
 
 const server = fastify()
 ```
-Check out the Learn By Example - [Getting Started](#getting-started) example for a more detailed http server walkthrough.
+Check out the Learn By Example - [Getting Started](#getting-started) example for
+a more detailed http server walkthrough.
 
 ###### Example 2: HTTPS sever
 
@@ -682,7 +808,9 @@ Check out the Learn By Example - [Getting Started](#getting-started) example for
    import path from 'path'
    import fastify from 'fastify'
    ```
-2. Follow the steps in this official [Node.js https server guide](https://nodejs.org/en/knowledge/HTTP/servers/how-to-create-a-HTTPS-server/) to create the `key.pem` and `cert.pem` files
+2. Follow the steps in this official [Node.js https server
+   guide](https://nodejs.org/en/knowledge/HTTP/servers/how-to-create-a-HTTPS-server/)
+   to create the `key.pem` and `cert.pem` files
 3. Instantiate a Fastify https server and add a route:
    ```typescript
    const server = fastify({
@@ -704,11 +832,15 @@ Check out the Learn By Example - [Getting Started](#getting-started) example for
      console.log(`Server listening at ${address}`)
    })
    ```
-4. Build and run! Test your server out by querying with: `curl -k https://localhost:8080`
+4. Build and run! Test your server out by querying with: `curl -k
+   https://localhost:8080`
 
 ###### Example 3: HTTP2 server
 
-There are two types of HTTP2 server types, insecure and secure. Both require specifying the `http2` property as `true` in the `options` object. The `https` property is used for creating a secure http2 server; omitting the `https` property will create an insecure http2 server.
+There are two types of HTTP2 server types, insecure and secure. Both require
+specifying the `http2` property as `true` in the `options` object. The `https`
+property is used for creating a secure http2 server; omitting the `https`
+property will create an insecure http2 server.
 
 ```typescript
 const insecureServer = fastify({ http2: true })
@@ -718,11 +850,15 @@ const secureServer = fastify({
 })
 ```
 
-For more details on using HTTP2 check out the Fastify [HTTP2](HTTP2.md) documentation page.
+For more details on using HTTP2 check out the Fastify [HTTP2](./HTTP2.md)
+documentation page.
 
 ###### Example 4: Extended HTTP server
 
-Not only can you specify the server type, but also the request and reply types. Thus, allowing you to specify special properties, methods, and more! When specified at server instantiation, the custom type becomes available on all further instances of the custom type.
+Not only can you specify the server type, but also the request and reply types.
+Thus, allowing you to specify special properties, methods, and more! When
+specified at server instantiation, the custom type becomes available on all
+further instances of the custom type.
 ```typescript
 import fastify from 'fastify'
 import http from 'http'
@@ -741,9 +877,15 @@ server.get('/', async (request, reply) => {
 
 ###### Example 5: Specifying logger types
 
-Fastify uses [Pino](https://getpino.io/#/) logging library under the hood. Some of it's properties can be configured via `logger` field when constructing Fastify's instance. If properties you need aren't exposed, it's also possible to pass a preconfigured external instance of Pino (or any other compatible logger) to Fastify via the same field. This allows creating custom serializers as well, see the [Logging](Logging.md) documentation for more info.
+Fastify uses [Pino](https://getpino.io/#/) logging library under the hood. Some
+of it's properties can be configured via `logger` field when constructing
+Fastify's instance. If properties you need aren't exposed, it's also possible to
+pass a preconfigured external instance of Pino (or any other compatible logger)
+to Fastify via the same field. This allows creating custom serializers as well,
+see the [Logging](./Logging.md) documentation for more info.
 
-To use an external instance of Pino, add `@types/pino` to devDependencies and pass the instance to `logger` field:
+To use an external instance of Pino, add `@types/pino` to devDependencies and
+pass the instance to `logger` field:
 
 ```typescript
 import fastify from 'fastify'
@@ -766,19 +908,21 @@ server.get('/', async (request, reply) => {
 ---
 
 ##### fastify.HTTPMethods
-[src](./../types/utils.d.ts#L8)
+[src](https://github.com/fastify/fastify/blob/main/types/utils.d.ts#L8)
 
-Union type of: `'DELETE' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' | 'OPTIONS'`
+Union type of: `'DELETE' | 'GET' | 'HEAD' | 'PATCH' | 'POST' | 'PUT' |
+'OPTIONS'`
 
 ##### fastify.RawServerBase
-[src](./../types/utils.d.ts#L13)
+[src](https://github.com/fastify/fastify/blob/main/types/utils.d.ts#L13)
 
 Dependant on `@types/node` modules `http`, `https`, `http2`
 
-Union type of: `http.Server | https.Server | http2.Http2Server | http2.Http2SecureServer`
+Union type of: `http.Server | https.Server | http2.Http2Server |
+http2.Http2SecureServer`
 
 ##### fastify.RawServerDefault
-[src](./../types/utils.d.ts#L18)
+[src](https://github.com/fastify/fastify/blob/main/types/utils.d.ts#L18)
 
 Dependant on `@types/node` modules `http`
 
@@ -788,34 +932,53 @@ Type alias for `http.Server`
 
 ##### fastify.FastifyServerOptions<[RawServer][RawServerGeneric], [Logger][LoggerGeneric]>
 
-[src](../fastify.d.ts#L29)
+[src](https://github.com/fastify/fastify/blob/main/fastify.d.ts#L29)
 
-An interface of properties used in the instantiation of the Fastify server. Is used in the main [`fastify()`][Fastify] method. The `RawServer` and `Logger` generic parameters are passed down through that method.
+An interface of properties used in the instantiation of the Fastify server. Is
+used in the main [`fastify()`][Fastify] method. The `RawServer` and `Logger`
+generic parameters are passed down through that method.
 
-See the main [fastify][Fastify] method type definition section for examples on instantiating a Fastify server with TypeScript.
+See the main [fastify][Fastify] method type definition section for examples on
+instantiating a Fastify server with TypeScript.
 
 ##### fastify.FastifyInstance<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RequestGeneric][FastifyRequestGenericInterface], [Logger][LoggerGeneric]>
 
-[src](../types/instance.d.ts#L16)
+[src](https://github.com/fastify/fastify/blob/main/types/instance.d.ts#L16)
 
-Interface that represents the Fastify server object. This is the returned server instance from the [`fastify()`][Fastify] method. This type is an interface so it can be extended via [declaration merging](https://www.typescriptlang.org/docs/handbook/declaration-merging.html) if your code makes use of the `decorate` method.
+Interface that represents the Fastify server object. This is the returned server
+instance from the [`fastify()`][Fastify] method. This type is an interface so it
+can be extended via [declaration
+merging](https://www.typescriptlang.org/docs/handbook/declaration-merging.html)
+if your code makes use of the `decorate` method.
 
-Through the use of generic cascading, all methods attached to the instance inherit the generic properties from instantiation. This means that by specifying the server, request, or reply types, all methods will know how to type those objects.
+Through the use of generic cascading, all methods attached to the instance
+inherit the generic properties from instantiation. This means that by specifying
+the server, request, or reply types, all methods will know how to type those
+objects.
 
-Check out the main [Learn by Example](#learn-by-example) section for detailed guides, or the more simplified [fastify][Fastify] method examples for additional details on this interface.
+Check out the main [Learn by Example](#learn-by-example) section for detailed
+guides, or the more simplified [fastify][Fastify] method examples for additional
+details on this interface.
 
 ---
 
 #### Request
 
 ##### fastify.FastifyRequest<[RequestGeneric][FastifyRequestGenericInterface], [RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric]>
-[src](./../types/request.d.ts#L15)
+[src](https://github.com/fastify/fastify/blob/main/types/request.d.ts#L15)
 
-This interface contains properties of Fastify request object. The properties added here disregard what kind of request object (http vs http2) and disregard what route level it is serving; thus calling `request.body` inside a GET request will not throw an error (but good luck sending a GET request with a body 😉).
+This interface contains properties of Fastify request object. The properties
+added here disregard what kind of request object (http vs http2) and disregard
+what route level it is serving; thus calling `request.body` inside a GET request
+will not throw an error (but good luck sending a GET request with a body 😉).
 
-If you need to add custom properties to the `FastifyRequest` object (such as when using the [`decorateRequest`][DecorateRequest] method) you need to use declaration merging on this interface.
+If you need to add custom properties to the `FastifyRequest` object (such as
+when using the [`decorateRequest`][DecorateRequest] method) you need to use
+declaration merging on this interface.
 
-A basic example is provided in the [`FastifyRequest`][FastifyRequest] section. For a more detailed example check out the Learn By Example section: [Plugins](#plugins)
+A basic example is provided in the [`FastifyRequest`][FastifyRequest] section.
+For a more detailed example check out the Learn By Example section:
+[Plugins](#plugins)
 
 ###### Example
 ```typescript
@@ -848,9 +1011,14 @@ server.get('/typedRequest', async (request: CustomRequest, reply: FastifyReply)
 ```
 
 ##### fastify.RequestGenericInterface
-[src](./../types/request.d.ts#L4)
+[src](https://github.com/fastify/fastify/blob/main/types/request.d.ts#L4)
 
-Fastify request objects have four dynamic properties: `body`, `params`, `query`, and `headers`. Their respective types are assignable through this interface. It is a named property interface enabling the developer to ignore the properties they do not want to specify. All omitted properties are defaulted to `unknown`. The corresponding property names are: `Body`, `Querystring`, `Params`, `Headers`.
+Fastify request objects have four dynamic properties: `body`, `params`, `query`,
+and `headers`. Their respective types are assignable through this interface. It
+is a named property interface enabling the developer to ignore the properties
+they do not want to specify. All omitted properties are defaulted to `unknown`.
+The corresponding property names are: `Body`, `Querystring`, `Params`,
+`Headers`.
 
 ```typescript
 import fastify, { RequestGenericInterface } from 'fastify'
@@ -869,16 +1037,19 @@ server.get<requestGeneric>('/', async (request, reply) => {
 })
 ```
 
-If you want to see a detailed example of using this interface check out the Learn by Example section: [JSON Schema](#jsonschema).
+If you want to see a detailed example of using this interface check out the
+Learn by Example section: [JSON Schema](#jsonschema).
 
 ##### fastify.RawRequestDefaultExpression\<[RawServer][RawServerGeneric]\>
-[src](./../types/utils.d.ts#L23)
+[src](https://github.com/fastify/fastify/blob/main/types/utils.d.ts#L23)
 
 Dependant on `@types/node` modules `http`, `https`, `http2`
 
 Generic parameter `RawServer` defaults to [`RawServerDefault`][RawServerDefault]
 
-If `RawServer` is of type `http.Server` or `https.Server`, then this expression returns `http.IncomingMessage`, otherwise, it returns `http2.Http2ServerRequest`.
+If `RawServer` is of type `http.Server` or `https.Server`, then this expression
+returns `http.IncomingMessage`, otherwise, it returns
+`http2.Http2ServerRequest`.
 
 ```typescript
 import http from 'http'
@@ -894,13 +1065,19 @@ RawRequestDefaultExpression<http2.Http2Server> // -> http2.Http2ServerRequest
 #### Reply
 
 ##### fastify.FastifyReply<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>
-[src](./../types/reply.d.ts#L32)
+[src](https://github.com/fastify/fastify/blob/main/types/reply.d.ts#L32)
 
-This interface contains the custom properties that Fastify adds to the standard Node.js reply object. The properties added here disregard what kind of reply object (http vs http2).
+This interface contains the custom properties that Fastify adds to the standard
+Node.js reply object. The properties added here disregard what kind of reply
+object (http vs http2).
 
-If you need to add custom properties to the FastifyReply object (such as when using the `decorateReply` method) you need to use declaration merging on this interface.
+If you need to add custom properties to the FastifyReply object (such as when
+using the `decorateReply` method) you need to use declaration merging on this
+interface.
 
-A basic example is provided in the [`FastifyReply`][FastifyReply] section. For a more detailed example check out the Learn By Example section: [Plugins](#plugins)
+A basic example is provided in the [`FastifyReply`][FastifyReply] section. For a
+more detailed example check out the Learn By Example section:
+[Plugins](#plugins)
 
 ###### Example
 ```typescript
@@ -924,13 +1101,15 @@ declare module 'fastify' {
 ```
 
 ##### fastify.RawReplyDefaultExpression<[RawServer][RawServerGeneric]>
-[src](./../types/utils.d.ts#L27)
+[src](https://github.com/fastify/fastify/blob/main/types/utils.d.ts#L27)
 
 Dependant on `@types/node` modules `http`, `https`, `http2`
 
 Generic parameter `RawServer` defaults to [`RawServerDefault`][RawServerDefault]
 
-If `RawServer` is of type `http.Server` or `https.Server`, then this expression returns `http.ServerResponse`, otherwise, it returns `http2.Http2ServerResponse`.
+If `RawServer` is of type `http.Server` or `https.Server`, then this expression
+returns `http.ServerResponse`, otherwise, it returns
+`http2.Http2ServerResponse`.
 
 ```typescript
 import http from 'http'
@@ -945,44 +1124,61 @@ RawReplyDefaultExpression<http2.Http2Server> // -> http2.Http2ServerResponse
 
 #### Plugin
 
-Fastify allows the user to extend its functionalities with plugins. A plugin can be a set of routes, a server decorator or whatever. To activate plugins, use the [`fastify.register()`][FastifyRegister] method.
+Fastify allows the user to extend its functionalities with plugins. A plugin can
+be a set of routes, a server decorator or whatever. To activate plugins, use the
+[`fastify.register()`][FastifyRegister] method.
 
-When creating plugins for Fastify, it is recommended to use the `fastify-plugin` module. Additionally, there is a guide to creating plugins with TypeScript and Fastify available in the Learn by Example, [Plugins](#plugins) section.
+When creating plugins for Fastify, it is recommended to use the `fastify-plugin`
+module. Additionally, there is a guide to creating plugins with TypeScript and
+Fastify available in the Learn by Example, [Plugins](#plugins) section.
 
 ##### fastify.FastifyPluginCallback<[Options][FastifyPluginOptions]>
-[src](../types/plugin.d.ts#L9)
+[src](https://github.com/fastify/fastify/blob/main/types/plugin.d.ts#L9)
 
-Interface method definition used within the [`fastify.register()`][FastifyRegister] method.
+Interface method definition used within the
+[`fastify.register()`][FastifyRegister] method.
 
 ##### fastify.FastifyPluginAsync<[Options][FastifyPluginOptions]>
-[src](../types/plugin.d.ts#L20)
+[src](https://github.com/fastify/fastify/blob/main/types/plugin.d.ts#L20)
 
-Interface method definition used within the [`fastify.register()`][FastifyRegister] method.
+Interface method definition used within the
+[`fastify.register()`][FastifyRegister] method.
 
 ##### fastify.FastifyPlugin<[Options][FastifyPluginOptions]>
-[src](../types/plugin.d.ts#L29)
+[src](https://github.com/fastify/fastify/blob/main/types/plugin.d.ts#L29)
 
-Interface method definition used within the [`fastify.register()`][FastifyRegister] method.
-Document deprecated in favor of `FastifyPluginCallback` and `FastifyPluginAsync` since general
-`FastifyPlugin` doesn't properly infer types for async functions.
+Interface method definition used within the
+[`fastify.register()`][FastifyRegister] method. Document deprecated in favor of
+`FastifyPluginCallback` and `FastifyPluginAsync` since general `FastifyPlugin`
+doesn't properly infer types for async functions.
 
 ##### fastify.FastifyPluginOptions
-[src](../types/plugin.d.ts#L31)
+[src](https://github.com/fastify/fastify/blob/main/types/plugin.d.ts#L31)
 
-A loosely typed object used to constrain the `options` parameter of [`fastify.register()`][FastifyRegister] to an object. When creating a plugin, define its options as an extension of this interface (`interface MyPluginOptions extends FastifyPluginOptions`) so they can be passed to the register method.
+A loosely typed object used to constrain the `options` parameter of
+[`fastify.register()`][FastifyRegister] to an object. When creating a plugin,
+define its options as an extension of this interface (`interface MyPluginOptions
+extends FastifyPluginOptions`) so they can be passed to the register method.
 
 ---
 
 #### Register
 
 ##### fastify.FastifyRegister(plugin: [FastifyPluginCallback][FastifyPluginCallback], opts: [FastifyRegisterOptions][FastifyRegisterOptions])
-[src](../types/register.d.ts#L9)
+[src](https://github.com/fastify/fastify/blob/main/types/register.d.ts#L9)
 ##### fastify.FastifyRegister(plugin: [FastifyPluginAsync][FastifyPluginAsync], opts: [FastifyRegisterOptions][FastifyRegisterOptions])
-[src](../types/register.d.ts#L9)
+[src](https://github.com/fastify/fastify/blob/main/types/register.d.ts#L9)
 ##### fastify.FastifyRegister(plugin: [FastifyPlugin][FastifyPlugin], opts: [FastifyRegisterOptions][FastifyRegisterOptions])
-[src](../types/register.d.ts#L9)
+[src](https://github.com/fastify/fastify/blob/main/types/register.d.ts#L9)
 
-This type interface specifies the type for the [`fastify.register()`](Server.md#register) method. The type interface returns a function signature with an underlying generic `Options` which is defaulted to [FastifyPluginOptions][FastifyPluginOptions]. It infers this generic from the FastifyPlugin parameter when calling this function so there is no need to specify the underlying generic. The options parameter is the intersection of the plugin's options and two additional optional properties: `prefix: string` and `logLevel`: [LogLevel][LogLevel].
+This type interface specifies the type for the
+[`fastify.register()`](./Server.md#register) method. The type interface returns
+a function signature with an underlying generic `Options` which is defaulted to
+[FastifyPluginOptions][FastifyPluginOptions]. It infers this generic from the
+FastifyPlugin parameter when calling this function so there is no need to
+specify the underlying generic. The options parameter is the intersection of the
+plugin's options and two additional optional properties: `prefix: string` and
+`logLevel`: [LogLevel][LogLevel].
 
 Below is an example of the options inference in action:
 
@@ -998,34 +1194,43 @@ fastify().register(plugin, {}) // Error - options object is missing required pro
 fastify().register(plugin, { option1: '', option2: true }) // OK - options object contains required properties
 ```
 
-See the Learn By Example, [Plugins](#plugins) section for more detailed examples of creating TypeScript plugins in Fastify.
+See the Learn By Example, [Plugins](#plugins) section for more detailed examples
+of creating TypeScript plugins in Fastify.
 
-##### fastify.FastifyRegisterOptions<Options>
-[src](../types/register.d.ts#L16)
+##### fastify.FastifyRegisterOptions
+[src](https://github.com/fastify/fastify/blob/main/types/register.d.ts#L16)
 
-This type is the intersection of the `Options` generic and a non-exported interface `RegisterOptions` that specifies two optional properties: `prefix: string` and `logLevel`: [LogLevel][LogLevel]. This type can also be specified as a function that returns the previously described intersection.
+This type is the intersection of the `Options` generic and a non-exported
+interface `RegisterOptions` that specifies two optional properties: `prefix:
+string` and `logLevel`: [LogLevel][LogLevel]. This type can also be specified as
+a function that returns the previously described intersection.
 
 ---
 
 #### Logger
 
-Check out the [Specifying Logger Types](#example-5-specifying-logger-types) example for more details on specifying a custom logger.
+Check out the [Specifying Logger Types](#example-5-specifying-logger-types)
+example for more details on specifying a custom logger.
 
 ##### fastify.FastifyLoggerOptions<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric]>
 
-[src](../types/logger.d.ts#L17)
+[src](https://github.com/fastify/fastify/blob/main/types/logger.d.ts#L17)
 
-An interface definition for the internal Fastify logger. It is emulative of the [Pino.js](https://getpino.io/#/) logger. When enabled through server options, use it following the general [logger](Logging.md) documentation.
+An interface definition for the internal Fastify logger. It is emulative of the
+[Pino.js](https://getpino.io/#/) logger. When enabled through server options,
+use it following the general [logger](./Logging.md) documentation.
 
 ##### fastify.FastifyLogFn
 
-[src](../types/logger.d.ts#L7)
+[src](https://github.com/fastify/fastify/blob/main/types/logger.d.ts#L7)
 
-An overload function interface that implements the two ways Fastify calls log methods. This interface is passed to all associated log level properties on the FastifyLoggerOptions object.
+An overload function interface that implements the two ways Fastify calls log
+methods. This interface is passed to all associated log level properties on the
+FastifyLoggerOptions object.
 
 ##### fastify.LogLevel
 
-[src](../types/logger.d.ts#L12)
+[src](https://github.com/fastify/fastify/blob/main/types/logger.d.ts#L12)
 
 Union type of: `'info' | 'error' | 'debug' | 'fatal' | 'warn' | 'trace'`
 
@@ -1033,54 +1238,73 @@ Union type of: `'info' | 'error' | 'debug' | 'fatal' | 'warn' | 'trace'`
 
 #### Context
 
-The context type definition is similar to the other highly dynamic pieces of the type system. Route context is available in the route handler method.
+The context type definition is similar to the other highly dynamic pieces of the
+type system. Route context is available in the route handler method.
 
 ##### fastify.FastifyContext
 
-[src](../types/context.d.ts#L6)
+[src](https://github.com/fastify/fastify/blob/main/types/context.d.ts#L6)
 
-An interface with a single required property `config` that is set by default to `unknown`. Can be specified either using a generic or an overload.
+An interface with a single required property `config` that is set by default to
+`unknown`. Can be specified either using a generic or an overload.
 
-This type definition is potentially incomplete. If you are using it and can provide more details on how to improve the definition, we strongly encourage you to open an issue in the main [fastify/fastify](https://github.com/fastify/fastify) repository. Thank you in advanced!
+This type definition is potentially incomplete. If you are using it and can
+provide more details on how to improve the definition, we strongly encourage you
+to open an issue in the main
+[fastify/fastify](https://github.com/fastify/fastify) repository. Thank you in
+advanced!
 
 ---
 
 #### Routing
 
-One of the core principles in Fastify is its routing capabilities. Most of the types defined in this section are used under-the-hood by the Fastify instance `.route` and `.get/.post/.etc` methods.
+One of the core principles in Fastify is its routing capabilities. Most of the
+types defined in this section are used under-the-hood by the Fastify instance
+`.route` and `.get/.post/.etc` methods.
 
 ##### fastify.RouteHandlerMethod<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>
 
-[src](../types/route.d.ts#L105)
+[src](https://github.com/fastify/fastify/blob/main/types/route.d.ts#L105)
 
-A type declaration for the route handler methods. Has two arguments, `request` and `reply` which are typed by `FastifyRequest` and `FastifyReply` respectfully. The generics parameters are passed through to these arguments. The method returns either `void` or `Promise<any>` for synchronous and asynchronous handlers respectfully.
+A type declaration for the route handler methods. Has two arguments, `request`
+and `reply` which are typed by `FastifyRequest` and `FastifyReply` respectfully.
+The generics parameters are passed through to these arguments. The method
+returns either `void` or `Promise<any>` for synchronous and asynchronous
+handlers respectfully.
 
 ##### fastify.RouteOptions<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>
 
-[src](../types/route.d.ts#L78)
+[src](https://github.com/fastify/fastify/blob/main/types/route.d.ts#L78)
 
-An interface than extends RouteShorthandOptions and adds the follow three required properties:
-1. `method` which corresponds to a singular [HTTPMethod][HTTPMethods] or a list of [HTTPMethods][HTTPMethods]
+An interface than extends RouteShorthandOptions and adds the follow three
+required properties:
+1. `method` which corresponds to a singular [HTTPMethod][HTTPMethods] or a list
+   of [HTTPMethods][HTTPMethods]
 2. `url` a string for the route
-3. `handler` the route handler method, see [RouteHandlerMethod][] for more details
+3. `handler` the route handler method, see [RouteHandlerMethod][] for more
+   details
 
 ##### fastify.RouteShorthandMethod<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric]>
 
-[src](../types/route.d.ts#12)
+[src](https://github.com/fastify/fastify/blob/main/types/route.d.ts#12)
 
-An overloaded function interface for three kinds of shorthand route methods to be used in conjunction with the `.get/.post/.etc` methods.
+An overloaded function interface for three kinds of shorthand route methods to
+be used in conjunction with the `.get/.post/.etc` methods.
 
 ##### fastify.RouteShorthandOptions<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>
 
-[src](../types/route.d.ts#55)
+[src](https://github.com/fastify/fastify/blob/main/types/route.d.ts#55)
 
-An interface that covers all of the base options for a route. Each property on this interface is optional, and it serves as the base for the RouteOptions and RouteShorthandOptionsWithHandler interfaces.
+An interface that covers all of the base options for a route. Each property on
+this interface is optional, and it serves as the base for the RouteOptions and
+RouteShorthandOptionsWithHandler interfaces.
 
 ##### fastify.RouteShorthandOptionsWithHandler<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>
 
-[src](../types/route.d.ts#93)
+[src](https://github.com/fastify/fastify/blob/main/types/route.d.ts#93)
 
-This interface adds a single, required property to the RouteShorthandOptions interface `handler` which is of type RouteHandlerMethod
+This interface adds a single, required property to the RouteShorthandOptions
+interface `handler` which is of type RouteHandlerMethod
 
 ---
 
@@ -1092,25 +1316,30 @@ A generic type that is either a `string` or `Buffer`
 
 ##### fastify.FastifyBodyParser<[RawBody][RawBodyGeneric], [RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric]>
 
-[src](../types/content-type-parser.d.ts#L7)
+[src](https://github.com/fastify/fastify/blob/main/types/content-type-parser.d.ts#L7)
 
-A function type definition for specifying a body parser method. Use the `RawBody` generic to specify the type of the body being parsed.
+A function type definition for specifying a body parser method. Use the
+`RawBody` generic to specify the type of the body being parsed.
 
 ##### fastify.FastifyContentTypeParser<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric]>
 
-[src](../types/content-type-parser.d.ts#L17)
+[src](https://github.com/fastify/fastify/blob/main/types/content-type-parser.d.ts#L17)
 
-A function type definition for specifying a body parser method. Content is typed via the `RawRequest` generic.
+A function type definition for specifying a body parser method. Content is typed
+via the `RawRequest` generic.
 
 ##### fastify.AddContentTypeParser<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric]>
 
-[src](../types/content-type-parser.d.ts#L46)
+[src](https://github.com/fastify/fastify/blob/main/types/content-type-parser.d.ts#L46)
 
-An overloaded interface function definition for the `addContentTypeParser` method. If `parseAs` is passed to the `opts` parameter, the definition uses [FastifyBodyParser][] for the `parser` parameter; otherwise, it uses [FastifyContentTypeParser][].
+An overloaded interface function definition for the `addContentTypeParser`
+method. If `parseAs` is passed to the `opts` parameter, the definition uses
+[FastifyBodyParser][] for the `parser` parameter; otherwise, it uses
+[FastifyContentTypeParser][].
 
 ##### fastify.hasContentTypeParser
 
-[src](../types/content-type-parser.d.ts#L63)
+[src](https://github.com/fastify/fastify/blob/main/types/content-type-parser.d.ts#L63)
 
 A method for checking the existence of a type parser of a certain content type
 
@@ -1120,17 +1349,20 @@ A method for checking the existence of a type parser of a certain content type
 
 ##### fastify.FastifyError
 
-[src](../types/error.d.ts#L17)
+[src](https://github.com/fastify/fastify/blob/main/types/error.d.ts#L17)
 
-FastifyError is a custom error object that includes status code and validation results.
+FastifyError is a custom error object that includes status code and validation
+results.
 
-It extends the Node.js `Error` type, and adds two additional, optional properties: `statusCode: number` and `validation: ValiationResult[]`.
+It extends the Node.js `Error` type, and adds two additional, optional
+properties: `statusCode: number` and `validation: ValiationResult[]`.
 
 ##### fastify.ValidationResult
 
-[src](../types/error.d.ts#L4)
+[src](https://github.com/fastify/fastify/blob/main/types/error.d.ts#L4)
 
-The route validation internally relies upon Ajv, which is a high-performance JSON schema validator.
+The route validation internally relies upon Ajv, which is a high-performance
+JSON schema validator.
 
 This interface is passed to instance of FastifyError.
 
@@ -1140,91 +1372,119 @@ This interface is passed to instance of FastifyError.
 
 ##### fastify.onRequestHookHandler<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>(request: [FastifyRequest][FastifyRequest], reply: [FastifyReply][FastifyReply], done: (err?: [FastifyError][FastifyError]) => void): Promise\<unknown\> | void
 
-[src](../types/hooks.d.ts#L17)
+[src](https://github.com/fastify/fastify/blob/main/types/hooks.d.ts#L17)
 
-`onRequest` is the first hook to be executed in the request lifecycle. There was no previous hook, the next hook will be `preParsing`.
+`onRequest` is the first hook to be executed in the request lifecycle. There was
+no previous hook, the next hook will be `preParsing`.
 
-Notice: in the `onRequest` hook, request.body will always be null, because the body parsing happens before the `preHandler` hook.
+Notice: in the `onRequest` hook, request.body will always be null, because the
+body parsing happens before the `preHandler` hook.
 
 ##### fastify.preParsingHookHandler<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>(request: [FastifyRequest][FastifyRequest], reply: [FastifyReply][FastifyReply], done: (err?: [FastifyError][FastifyError]) => void): Promise\<unknown\> | void
 
-[src](../types/hooks.d.ts#L35)
+[src](https://github.com/fastify/fastify/blob/main/types/hooks.d.ts#L35)
 
-preParsing` is the second hook to be executed in the request lifecycle. The previous hook was `onRequest`, the next hook will be `preValidation`.
+preParsing` is the second hook to be executed in the request lifecycle. The
+previous hook was `onRequest`, the next hook will be `preValidation`.
 
-Notice: in the `preParsing` hook, request.body will always be null, because the body parsing happens before the `preValidation` hook.
+Notice: in the `preParsing` hook, request.body will always be null, because the
+body parsing happens before the `preValidation` hook.
 
-Notice: you should also add `receivedEncodedLength` property to the returned stream. This property is used to correctly match the request payload with the `Content-Length` header value. Ideally, this property should be updated on each received chunk.
+Notice: you should also add `receivedEncodedLength` property to the returned
+stream. This property is used to correctly match the request payload with the
+`Content-Length` header value. Ideally, this property should be updated on each
+received chunk.
 
 ##### fastify.preValidationHookHandler<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>(request: [FastifyRequest][FastifyRequest], reply: [FastifyReply][FastifyReply], done: (err?: [FastifyError][FastifyError]) => void): Promise\<unknown\> | void
 
-[src](../types/hooks.d.ts#L53)
+[src](https://github.com/fastify/fastify/blob/main/types/hooks.d.ts#L53)
 
-`preValidation` is the third hook to be executed in the request lifecycle. The previous hook was `preParsing`, the next hook will be `preHandler`.
+`preValidation` is the third hook to be executed in the request lifecycle. The
+previous hook was `preParsing`, the next hook will be `preHandler`.
 
 ##### fastify.preHandlerHookHandler<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>(request: [FastifyRequest][FastifyRequest], reply: [FastifyReply][FastifyReply], done: (err?: [FastifyError][FastifyError]) => void): Promise\<unknown\> | void
 
-[src](../types/hooks.d.ts#L70)
+[src](https://github.com/fastify/fastify/blob/main/types/hooks.d.ts#L70)
 
-`preHandler` is the fourth hook to be executed in the request lifecycle. The previous hook was `preValidation`, the next hook will be `preSerialization`.
+`preHandler` is the fourth hook to be executed in the request lifecycle. The
+previous hook was `preValidation`, the next hook will be `preSerialization`.
 
 ##### fastify.preSerializationHookHandler<PreSerializationPayload, [RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>(request: [FastifyRequest][FastifyRequest], reply: [FastifyReply][FastifyReply], payload: PreSerializationPayload, done: (err: [FastifyError][FastifyError] | null, res?: unknown) => void): Promise\<unknown\> | void
 
-[src](../types/hooks.d.ts#L94)
+[src](https://github.com/fastify/fastify/blob/main/types/hooks.d.ts#L94)
 
-`preSerialization` is the fifth hook to be executed in the request lifecycle. The previous hook was `preHandler`, the next hook will be `onSend`.
+`preSerialization` is the fifth hook to be executed in the request lifecycle.
+The previous hook was `preHandler`, the next hook will be `onSend`.
 
-Note: the hook is NOT called if the payload is a string, a Buffer, a stream or null.
+Note: the hook is NOT called if the payload is a string, a Buffer, a stream or
+null.
 
 ##### fastify.onSendHookHandler<OnSendPayload, [RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>(request: [FastifyRequest][FastifyRequest], reply: [FastifyReply][FastifyReply], payload: OnSendPayload, done: (err: [FastifyError][FastifyError] | null, res?: unknown) => void): Promise\<unknown\> | void
 
-[src](../types/hooks.d.ts#L114)
+[src](https://github.com/fastify/fastify/blob/main/types/hooks.d.ts#L114)
 
-You can change the payload with the `onSend` hook. It is the sixth hook to be executed in the request lifecycle. The previous hook was `preSerialization`, the next hook will be `onResponse`.
+You can change the payload with the `onSend` hook. It is the sixth hook to be
+executed in the request lifecycle. The previous hook was `preSerialization`, the
+next hook will be `onResponse`.
 
-Note: If you change the payload, you may only change it to a string, a Buffer, a stream, or null.
+Note: If you change the payload, you may only change it to a string, a Buffer, a
+stream, or null.
 
 ##### fastify.onResponseHookHandler<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>(request: [FastifyRequest][FastifyRequest], reply: [FastifyReply][FastifyReply], done: (err?: [FastifyError][FastifyError]) => void): Promise\<unknown\> | void
 
-[src](../types/hooks.d.ts#L134)
+[src](https://github.com/fastify/fastify/blob/main/types/hooks.d.ts#L134)
 
-`onResponse` is the seventh and last hook in the request hook lifecycle. The previous hook was `onSend`, there is no next hook.
+`onResponse` is the seventh and last hook in the request hook lifecycle. The
+previous hook was `onSend`, there is no next hook.
 
-The onResponse hook is executed when a response has been sent, so you will not be able to send more data to the client. It can however be useful for sending data to external services, for example to gather statistics.
+The onResponse hook is executed when a response has been sent, so you will not
+be able to send more data to the client. It can however be useful for sending
+data to external services, for example to gather statistics.
 
 ##### fastify.onErrorHookHandler<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>(request: [FastifyRequest][FastifyRequest], reply: [FastifyReply][FastifyReply], error: [FastifyError][FastifyError], done: () => void): Promise\<unknown\> | void
 
-[src](../types/hooks.d.ts#L154)
+[src](https://github.com/fastify/fastify/blob/main/types/hooks.d.ts#L154)
 
-This hook is useful if you need to do some custom error logging or add some specific header in case of error.
+This hook is useful if you need to do some custom error logging or add some
+specific header in case of error.
 
-It is not intended for changing the error, and calling reply.send will throw an exception.
+It is not intended for changing the error, and calling reply.send will throw an
+exception.
 
-This hook will be executed only after the customErrorHandler has been executed, and only if the customErrorHandler sends an error back to the user (Note that the default customErrorHandler always sends the error back to the user).
+This hook will be executed only after the customErrorHandler has been executed,
+and only if the customErrorHandler sends an error back to the user (Note that
+the default customErrorHandler always sends the error back to the user).
 
-Notice: unlike the other hooks, pass an error to the done function is not supported.
+Notice: unlike the other hooks, pass an error to the done function is not
+supported.
 
 ##### fastify.onRouteHookHandler<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [RequestGeneric][FastifyRequestGenericInterface], [ContextConfig][ContextConfigGeneric]>(opts: [RouteOptions][RouteOptions] & { path: string; prefix: string }): Promise\<unknown\> | void
 
-[src](../types/hooks.d.ts#L174)
+[src](https://github.com/fastify/fastify/blob/main/types/hooks.d.ts#L174)
 
-Triggered when a new route is registered. Listeners are passed a routeOptions object as the sole parameter. The interface is synchronous, and, as such, the listener does not get passed a callback
+Triggered when a new route is registered. Listeners are passed a routeOptions
+object as the sole parameter. The interface is synchronous, and, as such, the
+listener does not get passed a callback
 
 ##### fastify.onRegisterHookHandler<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [Logger][LoggerGeneric]>(instance: [FastifyInstance][FastifyInstance], done: (err?: [FastifyError][FastifyError]) => void): Promise\<unknown\> | void
 
-[src](../types/hooks.d.ts#L191)
+[src](https://github.com/fastify/fastify/blob/main/types/hooks.d.ts#L191)
 
-Triggered when a new plugin is registered and a new encapsulation context is created. The hook will be executed before the registered code.
+Triggered when a new plugin is registered and a new encapsulation context is
+created. The hook will be executed before the registered code.
 
-This hook can be useful if you are developing a plugin that needs to know when a plugin context is formed, and you want to operate in that specific context.
+This hook can be useful if you are developing a plugin that needs to know when a
+plugin context is formed, and you want to operate in that specific context.
 
 Note: This hook will not be called if a plugin is wrapped inside fastify-plugin.
 
 ##### fastify.onCloseHookHandler<[RawServer][RawServerGeneric], [RawRequest][RawRequestGeneric], [RawReply][RawReplyGeneric], [Logger][LoggerGeneric]>(instance: [FastifyInstance][FastifyInstance], done: (err?: [FastifyError][FastifyError]) => void): Promise\<unknown\> | void
 
-[src](../types/hooks.d.ts#L206)
+[src](https://github.com/fastify/fastify/blob/main/types/hooks.d.ts#L206)
 
-Triggered when fastify.close() is invoked to stop the server. It is useful when plugins need a "shutdown" event, for example to close an open connection to a database.
+Triggered when fastify.close() is invoked to stop the server. It is useful when
+plugins need a "shutdown" event, for example to close an open connection to a
+database.
 
 
 <!-- Links -->
@@ -1247,7 +1507,7 @@ Triggered when fastify.close() is invoked to stop the server. It is useful when
 [FastifyInstance]: #fastifyfastifyinstance
 [FastifyLoggerOptions]: #fastifyfastifyloggeroptions
 [ContextConfigGeneric]: #ContextConfigGeneric
-[FastifyPlugin]: ##fastifyfastifypluginoptions-rawserver-rawrequest-requestgeneric
+[FastifyPlugin]: #fastifyfastifypluginoptions-rawserver-rawrequest-requestgeneric
 [FastifyPluginCallback]: #fastifyfastifyplugincallbackoptions
 [FastifyPluginAsync]: #fastifyfastifypluginasyncoptions
 [FastifyPluginOptions]: #fastifyfastifypluginoptions