diff --git a/docs/cli/_category_.json b/docs/cli/_category_.json
index ac3132a1..55995471 100644
--- a/docs/cli/_category_.json
+++ b/docs/cli/_category_.json
@@ -1,8 +1,8 @@
 {
-  "label": "CLI",
-  "position": 4,
-  "link": {
-    "type": "generated-index",
-    "description": "Expresso TS CLI Tool."
-  }
+    "label": "CLI",
+    "position": 3,
+    "link": {
+        "type": "generated-index",
+        "description": "Expresso TS CLI Tool Overview."
+    }
 }
diff --git a/docs/cli/generate.md b/docs/cli/generate.md
deleted file mode 100644
index 2aaae698..00000000
--- a/docs/cli/generate.md
+++ /dev/null
@@ -1,86 +0,0 @@
----
-sidebar_position: 2
----
-
-# Generate
-
-In order to provide a better developer experience, the ExpressoTS CLI provides a set of commands to help you scaffold the application resources such as use cases, controllers, DTO's, providers and services.
-
-This command allows developers to stay ahead of the curve by generating the boilerplate code for the application, so they can focus on the business logic.
-
-## Command Syntax
-
-The generate command can be executed as follows:
-
-```bash
-expressots generate <resource> <structure> [options]
-```
-
-Or in its short form:
-
-```bash
-expressots g <resource> <structure> [options]
-```
-
-### Command Structure
-
-We provide two different structures to scaffold the resources:
-
--   **[shorthand]**: `expressots generate service user-create`
-    This will create this folder structure: `/user/create` and the file: `user-create.[resource].ts`
-
--   **[folder/subfolder/resource]**: `expressots generate service user/create`
-    This will create this folder structure: `/user/create` and the file: `create.[resource].ts`
-
-    If you add `/` at the end of the structure, the CLI will create the resource inside of the folder. Example: `expressots generate service user/create/`
-    Structure: `user/create/` and the file: `create.[resource].ts`
-
-### Resource Root Folder
-
--   The root folder for all resources is the `src` folder. This can be changed in the `expressots.config.ts` file.
--   In the opinionated mode, the root folder is the `src` folder and the resources scaffolded with `service, usecase, dto, controller` are created inside of the `useCases` folder.
--   Entities are created inside of the `entities` folder, and providers inside of the `providers` folder.
-
-## Resource Types
-
-Current available resources:
-
-| Long form  | short | Command                    | Expected result                                                                          |
-| ---------- | ----- | -------------------------- | ---------------------------------------------------------------------------------------- |
-| usecase    | u     | expressots g u user/find   | Use case to be created in the folder `useCases` with this folder structure: user/find    |
-| controller | c     | expressots g c user/find   | Controller to be created in the folder `useCases` inside of user/find                    |
-| dto        | d     | expressots g d user/find   | DTO to be created in the folder `useCases` inside of user/find                           |
-| provider   | p     | expressots g p email/email | Provider to be created in the folder `providers` inside of user/find                     |
-| service    | s     | expressots g s user/find   | Service creates usecase, controller and DTO and add them in the desired folder user/find |
-| entity     | e     | expressots g e user        | Entity to be created in the folder `entities` with this folder structure: user           |
-| middleware | mi    | expressots g mi auth       | Middleware to be created in the folder `middlewares` with this folder structure: auth    |
-| module     | mo    | expressots g mo user       | Module to be created in the folder where `controllers` and `usecases` are located        |
-
-All resources can be created using the structure `folder/subfolder/resource`.
-
-## Scaffolding Using Shorthand Operation
-
-For services, you can take advantage of creating the use case, controller and DTO at once using the structure `entity_action` or `entity-action`. Example:
-
-```bash
-expressots g s user-create
-```
-
-:::info
-The `expressots.config.ts` configuration file, located in the project root folder, determines where all resources will be created. Also determine the resource names for each type of resource.
-:::
-
-Read more about the [ExpressoTS Config File](/docs/overview/expressots-config.md).
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
diff --git a/docs/cli/generate.mdx b/docs/cli/generate.mdx
new file mode 100644
index 00000000..96b41cbf
--- /dev/null
+++ b/docs/cli/generate.mdx
@@ -0,0 +1,166 @@
+---
+sidebar_position: 1
+title: Generate
+description: Scaffold ExpressoTS resources using the CLI.
+---
+
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+
+# Generate
+
+In order to provide a better developer experience, the ExpressoTS CLI provides a set of commands to help you scaffold the application resources such as use cases, controllers, DTO's, providers and services.
+
+This command allows developers to stay ahead of the curve by generating the boilerplate code for the application, so they can focus on the business logic.
+
+## Command syntax
+
+One big advantage of the ExpressoTS CLI is the ability to scaffold resources using two different structures: the <span class="span-table">shorthand</span> and
+the <span class="span-table">folder/subfolder/resource</span>. The shorthand operation is a more concise way to scaffold resources (recommended to be used in the opinionated template), while
+the folder/subfolder/resource structure is more flexible and can be used in both templates.
+
+The generate command can be executed as follows:
+
+```bash
+expressots generate <resource> <structure> [options]
+```
+
+Or in its short form:
+
+```bash
+expressots g <resource-alias> <structure> [options]
+```
+
+<Tabs>
+    <TabItem label="Non Opinionated" value="non-opinionated">
+```bash title="Full form"
+expressots generate service user/create
+```
+
+```bash title="Short form"
+expressots g s user/create
+```
+
+    </TabItem>
+    <TabItem label="Opinionated" value="opinionated">
+
+```bash title="Full form"
+expressots generate service user-create
+```
+
+```bash title="Short form"
+expressots g s user-create
+```
+
+```bash title="Passing http parameter as option"
+expressots g s user-create -m post
+```
+
+    </TabItem>
+
+</Tabs>
+
+## Command structure
+
+We provide two different structures to scaffold the resources, the **shorthand** and the **folder/subfolder/resource**.
+These scaffold strategies work differently based on the project template used. The `opinionated` template provides a more structured project, while the `non-opinionated` template provides a more flexible project structure.
+
+#### Using single name
+
+```bash
+expressots g c user
+```
+
+```bash title="Output"
+src
+└── user.controller.ts
+```
+
+#### Using the shorthand operation
+
+```bash
+expressots g c user-create
+```
+
+```bash title="Output"
+src
+└── user
+    └── create
+        └── user-create.controller.ts
+```
+
+#### Using the folder/subfolder/resource structure
+
+```bash
+expressots g c user/create
+```
+
+```bash title="Output"
+src
+└── user
+    └── create.controller.ts
+```
+
+If you add `/` at the end of the structure, the CLI will create the resource inside of the folder. Example: `expressots g c user/create/`
+
+```bash title="Output"
+src
+└── user
+    └── create
+        └── create.controller.ts
+```
+
+:::info
+Opinionated templates come with predefined folder structures for each resource type, ensuring that resources are always created in the following designated folders:
+
+    -   useCases
+    -   entities
+    -   providers
+
+:::
+
+The root folder for all resources is the `src` folder. This can be changed in the `expressots.config.ts` file.
+
+## Resource types
+
+Resources available to be scaffolded are:
+
+| Long form  | short | Command                    | Expected result                                                                          |
+| ---------- | ----- | -------------------------- | ---------------------------------------------------------------------------------------- |
+| usecase    | u     | expressots g u user/find   | Use case to be created in the folder `useCases` with this folder structure: user/find    |
+| controller | c     | expressots g c user/find   | Controller to be created in the folder `useCases` inside of user/find                    |
+| dto        | d     | expressots g d user/find   | DTO to be created in the folder `useCases` inside of user/find                           |
+| provider   | p     | expressots g p email/email | Provider to be created in the folder `providers` inside of user/find                     |
+| service    | s     | expressots g s user/find   | Service creates usecase, controller and DTO and add them in the desired folder user/find |
+| entity     | e     | expressots g e user        | Entity to be created in the folder `entities` with this folder structure: user           |
+| middleware | mi    | expressots g mi auth       | Middleware to be created in the folder `middlewares` with this folder structure: auth    |
+| module     | mo    | expressots g mo user       | Module to be created in the folder where `controllers` and `usecases` are located        |
+
+For services, you can take advantage of creating the use case, controller and DTO at once.
+
+```bash
+expressots g s user-create
+```
+
+```bash title="Output for the non opinionated template"
+src
+└── user
+    └── create
+        ├── user-create.controller.ts
+        ├── user-create.dto.ts
+        ├── user-create.usecase.ts
+        └── user-create.usecase.ts
+```
+
+:::info
+The `expressots.config.ts` file, located in the project root folder, defines where all resources will be created and specifies the naming conventions for each type of resource.
+:::
+
+Read more about the [ExpressoTS Config File](../features/expressots-config.mdx).
+
+---
+
+## Support us ❤️
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/cli/overview.md b/docs/cli/overview.mdx
similarity index 51%
rename from docs/cli/overview.md
rename to docs/cli/overview.mdx
index b6e875b4..04a95b28 100644
--- a/docs/cli/overview.md
+++ b/docs/cli/overview.mdx
@@ -1,14 +1,17 @@
 ---
-sidebar_position: 1
+sidebar_position: 0
+title: Overview
+description: ExpressoTS CLI overview.
 ---
 
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+
 # Overview
 
-ExpressoTS CLI is a command-line interface tool that helps you to `create` ExpressoTS projects and `scaffold` ExpressoTS resources.
+The CLI (command-line interface) tool helps you to create ExpressoTS projects and scaffold ExpressoTS resources.
 
-:::info
-We use the `npm` package manager in this tutorial for simplicity. However, you can use `yarn` or `pnpm` as well.
-:::
+We use the `npm` in this tutorial for simplicity. However, you can use your preferred package manager (`yarn` or `pnpm`) by replacing `npm` with the appropriate command.
 
 ## Installation
 
@@ -18,26 +21,29 @@ First install the CLI globally using the command below:
 npm install -g @expressots/cli
 ```
 
-## Commands Available
+## Commands available
+
+The CLI provides the following commands:
 
-| Name        | Alias  | Description                                           |
-| ----------- | ------ | ----------------------------------------------------- |
-| new project | new    | Generate a new project                                |
-| info        | i      | Provides project information                          |
-| resources   | r      | Displays CLI commands and resources                   |
-| help        | h      | Show command help                                     |
-| service     | g s    | Generate a service [controller, usecase, dto, module] |
-| controller  | g c    | Generate a controller                                 |
-| usecase     | g u    | Generate a usecase                                    |
-| dto         | g d    | Generate a DTO                                        |
-| entity      | g e    | Generate an entity                                    |
-| provider    | g p    | Generate internal provider                            |
-| provider    | add    | Add external provider to the project                  |
-| provider    | create | Create external provider                              |
-| module      | g mo   | Generate a module                                     |
-| middleware  | g mi   | Generate a middleware                                 |
+| Name        | Alias   | Description                                           |
+| ----------- | ------- | ----------------------------------------------------- |
+| new project | new     | Generate a new project                                |
+| info        | i       | Provides project information                          |
+| resources   | r       | Displays CLI commands and resources                   |
+| scripts     | scripts | Run scripts list or a specific script                 |
+| help        | help    | Show command help                                     |
+| service     | g s     | Generate a service [controller, usecase, dto, module] |
+| controller  | g c     | Generate a controller                                 |
+| usecase     | g u     | Generate a usecase                                    |
+| dto         | g d     | Generate a DTO                                        |
+| entity      | g e     | Generate an entity                                    |
+| provider    | g p     | Generate internal provider                            |
+| provider    | add     | Add external provider to the project                  |
+| provider    | create  | Create external provider                              |
+| module      | g mo    | Generate a module                                     |
+| middleware  | g mi    | Generate a middleware                                 |
 
-## Usage Examples
+## Usage examples
 
 The CLI has the following syntax:
 
@@ -45,7 +51,7 @@ The CLI has the following syntax:
 expressots <command> [options]
 ```
 
-### Help
+## Help command
 
 Verify the available commands and options:
 
@@ -53,7 +59,7 @@ Verify the available commands and options:
 expressots help
 ```
 
-### Info
+## Info command
 
 Providers information about your Operational System, Project and CLI version:
 
@@ -61,7 +67,7 @@ Providers information about your Operational System, Project and CLI version:
 expressots info
 ```
 
-### Resources list
+## Resources list
 
 List all available resources to scaffold:
 
@@ -69,12 +75,12 @@ List all available resources to scaffold:
 expressots resources (Alias: r)
 ```
 
-### Create a Project
+## Create a project
 
 There are two options to create a new project, interactively or silently (passing the options as arguments).
 Here is the complete command syntax:
 
-```bash
+```bash title="Create project command options"
 expressots new <project-name> -p <package-manager> -t <template> -d <directory>
 ```
 
@@ -96,7 +102,7 @@ expressots new <project-name> -p <package-manager> -t <template> -d <directory>
 
 The flag `-d` is optional and is used to specify the directory where the project will be created. If not specified, the project will be created in the current directory.
 
-### Add a Provider
+## Add a provider
 
 Add an external provider to the project:
 
@@ -104,15 +110,20 @@ Add an external provider to the project:
 expressots add <provider-name>
 ```
 
-### Create a Provider
+Although you can add npm registry packages, the primary use case for this command is to add providers that were built specifically for ExpressoTS.
+
+:::info Watch for updates of our Providers App Store.
+:::
+
+## Create a provider
 
-Create a new ExpressoTS provider. For more information about providers, check the [Providers](/docs/overview/providers.md#creating-and-registering-an-external-provider) section.
+Create a new ExpressoTS provider. For more information about providers, check the [Providers](../core/providers.mdx#create-external-provider) section.
 
 ```bash
 expressots create <provider-name>
 ```
 
-## Scaffold Resources
+## Scaffold resources
 
 The CLI provides commands to scaffold resources like `controller`, `usecase`, `dto`, `entity`, `module` and `middleware`.
 
@@ -126,38 +137,36 @@ Resources are created in the `src` directory by default. They also can be scaffo
 The resource scaffolding operations produce different results based on the project template used. The `opinionated` template provides a more structured project, while the `non-opinionated` template provides a more flexible project structure.
 :::
 
-### Non Opinionated Scaffold
+<Tabs>
+    <TabItem value="non-opinionated" label="Non Opinionated">
 
-#### Passing the Path
+#### Passing the path
 
-```bash
+```bash title="Create a controller named user inside the services directory"
 expressots g c services/user
 ```
 
-The command above will create a controller named `user` inside the `services` directory.
-
-```bash
+```bash title="Output"
 src
 └── services
     └── user.controller.ts
 ```
 
-#### Shorthand Operation
+#### Shorthand operation
 
-```bash
+```bash title="Create a controller named services-user inside the services/user directory"
 expressots g c services-user
 ```
 
-The command above will create a controller named `services-user` inside the `services/user` directory.
-
-```bash
+```bash title="Output"
 src
 └── services
     └── user
         └── services-user.controller.ts
 ```
 
-### Opinionated Scaffold
+    </TabItem>
+    <TabItem value="opinionated" label="Opinionated">
 
 In the `opinionated` template, the scaffolded resources are created following a predefined structure.
 
@@ -166,34 +175,33 @@ In the `opinionated` template, the scaffolded resources are created following a
 -   [@useCases](/docs/overview/usecase.md)
 -   [@repositories](/docs/overview/repositories.md)
 
-#### Passing the Path
+#### Passing the path
 
-```bash
+```bash title="Create a controller named user inside the useCases/services directory"
 expressots g c services/user
 ```
 
 The command above will create a controller named `user` inside the `useCases/services` directory.
 
-```bash
+```bash title="Output"
 src
 └── useCases
     └── services
         └── user.controller.ts
 ```
 
-:::info
-dto, usecase, controller, modules will be created in the `useCases` directory.
+:::note dto, usecase, controller, modules will be created in the `useCases` directory.
 :::
 
-#### Shorthand Operation
+#### Shorthand operation
 
-```bash
+```bash title="Create a controller named services-user inside the useCases/services/user directory"
 expressots g c services-user
 ```
 
 The command above will create a controller named `services-user` inside the `useCases/services/user` directory.
 
-```bash
+```bash title="Output"
 src
 └── useCases
     └── services
@@ -205,27 +213,13 @@ src
 Using the shorthand operation in the opinionated template offers significant benefits. It creates a well-structured project that's easier to navigate and understand. When you scaffold with the shorthand, the CLI automatically places resources in the correct directories, adds controllers to their modules, and integrates the module into the container.
 :::
 
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
-
-```
-
-```
+</TabItem>
 
-```
+</Tabs>
 
-```
+---
 
-```
+## Support us ❤️
 
-```
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/codebyexample/_category_.json b/docs/codebyexample/_category_.json
deleted file mode 100644
index cc77186d..00000000
--- a/docs/codebyexample/_category_.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "label": "Code By Example",
-  "position": 3,
-  "link": {
-    "type": "generated-index",
-    "description": "ExpressoTS Code by Example"
-  }
-}
diff --git a/docs/codebyexample/app-container.md b/docs/codebyexample/app-container.md
deleted file mode 100644
index 81512f2a..00000000
--- a/docs/codebyexample/app-container.md
+++ /dev/null
@@ -1,69 +0,0 @@
----
-sidebar_position: 1
----
-
-# Application Container
-
-The application container is a dependency injection container. See [Application Container](../overview/app-container.md) for more information.
-
-```typescript
-const appContainer = new AppContainer();
-
-export const container: Container = appContainer.create([
-    // Add your modules here
-    AppModule,
-]);
-```
-
-## Creating AppContainer
-
-The `AppContainer` class takes one optional parameter:
-
--   `defaultScope` is the default binding scope. Use `BindingScopeEnum` to set the default scope (Request, Singleton, Transient).
--   `skipBaseClassChecks` is a boolean value that indicates if the container should skip the base class checks. This is useful when you are using abstract classes as binding identifiers or you are extending classes from third-party libraries. Set this value to `true` to skip the base class checks.
--   `autoBindInjectable` is a boolean value that indicates if the container should automatically bind injectable classes. Set this value to `true` to automatically bind injectable classes.
-
-:::info
-The default scope is `BindingScopeEnum.Request` and `skipBaseClassChecks` is `false`.
-:::
-
-```typescript
-const appContainer = new AppContainer({
-    defaultScope: BindingScopeEnum.Request,
-    skipBaseClassChecks: true,
-    autoBindInjectable: false,
-});
-```
-
-The `AppContainer` instance returns an instance of `AppContainer` that gives you access to the following methods:
-
--   `create()` creates the application container.
--   `Container` is the dependency injection container instance.
--   `getBindingDictionary()` returns the binding dictionary map of classes injected in the dependency injection system.
--   `getContainerOptions()` returns the container options.
-
-### Method Create
-
-The `create` method takes one mandatory parameter (array of modules);
-
-```typescript
-export const container: Container = appContainer.create([
-    // Add your modules here
-    AppModule,
-    UserModule,
-    ProductModule,
-]);
-```
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
diff --git a/docs/codebyexample/bootstrap.md b/docs/codebyexample/bootstrap.md
deleted file mode 100644
index 99290529..00000000
--- a/docs/codebyexample/bootstrap.md
+++ /dev/null
@@ -1,98 +0,0 @@
----
-sidebar_position: 0
----
-
-# Bootstrap Method
-
-The `bootstrap` method is the entry point of your application. It is responsible for loading the application configuration, registering middlewares, and starting the application.
-
-- `AppFactory.create()` method is responsible for creating the application instance. It takes two parameters:
-  - `container` is the dependency injection container. See [App Container](../overview/app-container.md) for more information.
-  - `middlewares` or `App`
-- `Return:` `IApplicationExpress` instance that gives you access to two methods:
-  - `app.listen()` starts the application.
-  - `app.setEngine()` sets the application render view engine.
-
-:::info
-**`middlewares`** is an array of middlewares that will be registered in the application. (Non-opinionated template)
-
-**`App`** is the application class responsible for all application configuration. (Opinionated template)
-:::
-
-## Bootstrap with array of middlewares
-
-Use this method if you are using the non-opinionated template. You have the freedom create your own application class and register your middlewares in your own way.
-
-```typescript
-async function bootstrap() {
-  const app = await AppFactory.create(container, [cors(), helmet()]);
-  await app.listen(3000, ServerEnvironment.Development);
-}
-
-bootstrap();
-```
-
-:::tip
-**`AppFactory.create(container, [])`** returns an instance of `ApplicationExpress` that gives you direct access to the `ExpressApp` instance.
-:::
-
-## Bootstrap with the Application Class
-
-Use this method if you are using the opinionated template. Your application class will be responsible for all application configuration.
-
-```typescript
-async function bootstrap() {
-  const app = await AppFactory.create(container, App);
-  await app.listen(3000, ServerEnvironment.Development);
-}
-
-bootstrap();
-```
-
-:::tip
-**`AppFactory.create(container, App)`** returns an instance of `IApplicationExpress` that gives you access to `listen()` and `setEngine()` methods.
-:::
-
-## Method Listen
-
-The `listen` method is responsible for starting the application. It takes two mandatory parameters and one optional parameter:
-
-- `port` is the port number where the application will be listening. (Mandatory)
-- `environment` is the environment where the application will be running. It can be `development` or `production`. Use the enum called `ServerEnvironment`. (Mandatory)
-- `consoleMessage` is the message object that will be displayed in the console when the application starts. (Optional)
-
-```typescript
-await app.listen(3000, ServerEnvironment.Development, {
-  appName: "Expressots",
-  appVersion: "1.0.0",
-});
-```
-
-:::tip
-The ServerEnvironment enum defines the NODE_ENV environment variable automatically. It can be `development` or `production`.
-:::
-
-## Method Set Engine
-
-The `setEngine` method is responsible for setting the application render view engine. For now ExpressoTS only supports Handlebars.
-
-```typescript
-app.setEngine<IHandlebars>({
-  extName: "hbs",
-  viewPath: path.join(__dirname, "..", "views"),
-  engine: engine({ defaultLayout: "layout", extname: "hbs" }),
-});
-```
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
-- Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
-- Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
-- Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Join our **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Share the project with your friends and colleagues
diff --git a/docs/codebyexample/controller.md b/docs/codebyexample/controller.md
deleted file mode 100644
index 5f1c003a..00000000
--- a/docs/codebyexample/controller.md
+++ /dev/null
@@ -1,112 +0,0 @@
----
-sidebar_position: 3
----
-
-# Controllers
-
-Controllers are responsible for handling incoming requests and returning responses to the client.
-
-- For information about `BaseController`, see [BaseController](../overview/controller.md#basecontroller-class).
-- For information about HTTP and parameters decorators, see [HTTP and Parameter Decorators](../overview/decorators.md).
-- Controllers make use of DTOs to validate the request body, query parameters, and route parameters. See [DTOs](../overview/controller#dto-pattern) for more information.
-
-```typescript
-@controller("/")
-export class UserGetController extends BaseController {
-  constructor() {
-    super();
-  }
-
-  @Get("/")
-  execute() {
-    return "Getting a user...";
-  }
-}
-```
-
-To create a controller, you need to create a class and decorate it with `@controller` decorator. The `@controller` decorator takes two parameters:
-
-- `path` is the path of the controller. (Mandatory)
-- `middlewares` is an array of middlewares. (Optional)
-
-```typescript
-@controller("/", express.json(), express.urlencoded({ extended: true }))
-```
-
-:::info
-Defining middlewares in the controller will apply to all routes of the controller.
-:::
-
-## Example of a Controller with Multiple Routes
-
-```typescript
-@controller("/user")
-export class UserController extends BaseController {
-  constructor() {
-    super();
-  }
-
-  @Get("/")
-  get() {
-    return "Getting a user...";
-  }
-
-  @Post("/create")
-  create() {
-    return "Creating a user...";
-  }
-}
-```
-
-## Example of Route with Multiple Middlewares
-
-```typescript
-@Get("app", express.json(), express.urlencoded({ extended: true }))
-```
-
-:::info
-Defining middlewares in the route will apply only to the specific route.
-:::
-
-:::info
-The controller route path will be concatenated with the individual route path.
-
-```typescript
-@controller("/user")
-  @Post("/create")
-```
-
-Final route is `/user/create`.
-:::
-
-## Injecting Dependencies into Controllers Constructor
-
-You can inject dependencies into controllers constructor as follows:
-
-```typescript
-@controller("/")
-class AppController extends BaseController {
-  constructor(private yourProvider: YourProvider) {
-    super();
-  }
-
-  @Get("/")
-  get() {
-    this.yourProvider.doSomething();
-    return "Hello ExpressoTS!";
-  }
-}
-```
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
-- Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
-- Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
-- Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Join our **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Share the project with your friends and colleagues
diff --git a/docs/codebyexample/entities.md b/docs/codebyexample/entities.md
deleted file mode 100644
index dd3f08d4..00000000
--- a/docs/codebyexample/entities.md
+++ /dev/null
@@ -1,44 +0,0 @@
----
-sidebar_position: 5
----
-
-# Entities
-
-Entities are the core of your application. They are the representation of your business objects. For more information about entities, see [Entities](../overview/entities.md).
-
-```typescript
-@provide(User)
-export class User {
-  id: string;
-  name: string;
-  email: string;
-
-  constructor() {
-    this.id = randomUUID();
-  }
-}
-```
-
-:::caution
-Don't pass primitive types as parameters to the constructor of your entities. The Dependency Injection Container will not be able to resolve them.
-
-```typescript
-constructor(name: string) {
-    this.name = name;
-}
-```
-
-:::
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
-- Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
-- Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
-- Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Join our **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Share the project with your friends and colleagues
diff --git a/docs/codebyexample/modules.md b/docs/codebyexample/modules.md
deleted file mode 100644
index 788ba8ab..00000000
--- a/docs/codebyexample/modules.md
+++ /dev/null
@@ -1,47 +0,0 @@
----
-sidebar_position: 2
----
-
-# Modules
-
-Modules are responsible for registering controllers. See [Modules](../overview/module.md) for more information.
-
-## Creating a Module
-
-The `CreateModule` decorator takes two parameters:
-
-- `controllers` is an array of controllers. (Mandatory)
-- `scope` is the binding scope. Use `BindingScopeEnum` to set the scope (Request, Singleton, Transient). (Optional)
-
-:::info
-The default scope is `BindingScopeEnum.Request` inherited from `AppContainer`.
-:::
-
-```typescript
-export const UserModule = CreateModule([], BindingScopeEnum.Request);
-```
-
-Example of a module with controllers:
-
-```typescript
-export const UserModule = CreateModule([
-  UserCreateController,
-  UserDeleteController,
-  UserUpdateController,
-  UserFindController,
-  UserFindallController,
-]);
-```
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
-- Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
-- Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
-- Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Join our **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Share the project with your friends and colleagues
diff --git a/docs/codebyexample/usecase.md b/docs/codebyexample/usecase.md
deleted file mode 100644
index 54856fa1..00000000
--- a/docs/codebyexample/usecase.md
+++ /dev/null
@@ -1,43 +0,0 @@
----
-sidebar_position: 4
----
-
-# Use Cases
-
-Uses cases are the implementation of the business logic of your application. For more information about use cases, see [Use Cases](../overview/usecase.md).
-
-```typescript
-@provide(YourUseCase)
-export class YourUseUseCase {
-  execute() {
-    return "Hello ExpressoTS!";
-  }
-}
-```
-
-## Injecting Dependencies into Use Cases Constructor
-
-```typescript
-@provide(YourUseCase)
-export class YourUseUseCase {
-  constructor(private yourProvider: YourProvider) {}
-
-  execute() {
-    this.yourProvider.doSomething();
-    return "Hello ExpressoTS!";
-  }
-}
-```
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
-- Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
-- Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
-- Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Join our **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Share the project with your friends and colleagues
diff --git a/docs/codebyexample/utils.md b/docs/codebyexample/utils.md
deleted file mode 100644
index 44937779..00000000
--- a/docs/codebyexample/utils.md
+++ /dev/null
@@ -1,127 +0,0 @@
----
-sidebar_position: 6
----
-
-# ExpressoTS Utilities
-
-## Status Codes
-
-It is an enum that contains all HTTP status codes.
-
-```typescript
-StatusCode.OK;
-```
-
-## Reporting Errors
-
-For more information about Error Handling, see [Error Handling](../overview/error-handling.md).
-
-Here are the parameters of the `error` method:
-
-- error: An instance of Error or a string that describes the error.
-- statusCode: The HTTP status code associated with the error (default is 500).
-- service: The service name associated with the error.
-- @throws: An object of the custom type AppError, which includes details about the error.
-
-```typescript
-@provide(YourUseCase)
-export class YourUseUseCase {
-  constructor(private report: Report) {}
-
-  execute() {
-    this.report.error("Something went wrong!");
-    return "Hello ExpressoTS!";
-  }
-}
-```
-
-## Logging
-
-Logger is a class that provides a set of methods to log messages using native node modules for better performance.
-
-Logger take two parameters:
-
-- message: The message to be logged.
-- module: The service name associated with the log.
-
-```typescript
-export class YourUseUseCase {
-  constructor(private log: Logger) {}
-
-  execute() {
-    this.log.info("Testing log message", "YourUseUseCase");
-    return "Hello ExpressoTS!";
-  }
-}
-```
-
-There are 4 methods available:
-
-- **info**: Logs an informational message.
-- **warn**: Logs a warning message.
-- **error**: Logs an error message.
-- **msg**: Logs a message.
-
-## Setting the Route Global Prefix
-
-You can set a global prefix for all routes in your application. This is useful when you want to version your APIs.
-
-### Non Opinionated Template
-
-You can set the global prefix in the `bootstrap` method of your application.
-
-```typescript
-async function bootstrap() {
-  const app = await AppFactory.create(container, []);
-
-  app.setGlobalRoutePrefix("/api");
-
-  await app.listen(3000, ServerEnvironment.Development);
-}
-```
-
-### Opinionated Template
-
-You can set the global prefix in the `configureServices` method of your application.
-
-```typescript
-@provide(App)
-class App extends AppExpress {
-  private middleware: IMiddleware;
-  private provider: IProvider;
-
-  constructor() {
-    super();
-    this.middleware = container.get<IMiddleware>(Middleware);
-    this.provider = container.get<IProvider>(Provider);
-  }
-
-  protected configureServices(): void {
-    this.setGlobalRoutePrefix("/v1");
-
-    this.middleware.addBodyParser();
-    this.middleware.setErrorHandler();
-  }
-
-  protected postServerInitialization(): void {
-    if (this.isDevelopment()) {
-      this.provider.envValidator.checkAll();
-    }
-  }
-
-  protected serverShutdown(): void {}
-}
-```
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
-- Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
-- Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
-- Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Join our **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Share the project with your friends and colleagues
diff --git a/docs/core/_category_.json b/docs/core/_category_.json
new file mode 100644
index 00000000..54367676
--- /dev/null
+++ b/docs/core/_category_.json
@@ -0,0 +1,8 @@
+{
+    "label": "CORE",
+    "position": 1,
+    "link": {
+        "type": "generated-index",
+        "description": "ExpressoTS Core Concepts."
+    }
+}
diff --git a/docs/core/app-container.mdx b/docs/core/app-container.mdx
new file mode 100644
index 00000000..9d0414c5
--- /dev/null
+++ b/docs/core/app-container.mdx
@@ -0,0 +1,92 @@
+---
+sidebar_position: 2
+title: App container
+description: The AppContainer simplifies module registration.
+---
+
+# App container
+
+ExpressoTS uses **[InversifyJS](https://inversify.io/)** for dependency injection, making it easy to manage object creation, resolution, and lifecycle.
+The use of `appContainer` abstracts away the intricacies of InversifyJS direct usage, providing a straightforward path to integrating and managing modules within ExpressoTS applications.
+
+## Setup
+
+The application container can be customized to enhance flexibility in dependency management through the following options:
+
+-   **defaultScope**:
+    -   Request Scope: Creates a new instance of a dependency for each request.
+    -   Singleton Scope: Creates a single instance shared across all requests.
+    -   Transient Scope: Creates a new instance every time the dependency is requested.
+-   **skipBaseClassChecks**: When enabled, the container skips base class checks for derived classes, providing more flexibility.
+-   **autoBindInjectable**: When enabled, the container automatically injects classes that are not explicitly bound.
+
+Here is the interface options definition:
+
+```typescript
+interface ContainerOptions {
+    defaultScope?: interfaces.BindingScope;
+    skipBaseClassChecks?: boolean;
+    autoBindInjectable: false;
+}
+```
+
+## Creating the container
+
+```typescript title="app.container.ts"
+export const appContainer: AppContainer = new AppContainer({
+    defaultScope: BindingScopeEnum.Singleton,
+    skipBaseClassChecks: true,
+    autoBindInjectable: false,
+});
+
+const container = appContainer.create([
+    // Add your modules here
+    AppModule,
+]);
+
+export { container };
+```
+
+## Modules registration
+
+The `appContainer` facilitates module registration via its `create([])` method, which accepts an array of modules.
+
+Here an example of PaymentModule creation:
+
+```typescript title="payment.module.ts"
+export const PaymentModule: ContainerModule = CreateModule([CreatePaymentController]);
+```
+
+```typescript title="Module registration"
+// Create a new container
+const appContainer: AppContainer = new AppContainer();
+
+const container: Container = appContainer.create([UserModule, PaymentModule]);
+```
+
+:::tip
+When scaffolding a new module using the Opinionated template, the module is automatically registered in the container.
+:::
+
+## Container options
+
+After creating the container, you have the following options available:
+
+-   <span class="span-table">Container Object</span>: Access the container and manage its bindings.
+-   <span class="span-table">View Container Bindings</span>: Check the injected classes and their
+    scopes. The container can be used to view all the bindings that have been registered. This can
+    be useful for debugging purposes or to understand the dependencies that have been registered.
+-   <span class="span-table">View Container Options</span>: Review the container's defined options
+
+See below image for a visual representation of the container bindings.
+
+```typescript title="app.container.ts"
+appContainer.viewContainerBindings();
+```
+
+![Container Bindings View](./img/container-bindings.png)
+
+## Support us ❤️
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/core/app-provider.mdx b/docs/core/app-provider.mdx
new file mode 100644
index 00000000..e278794c
--- /dev/null
+++ b/docs/core/app-provider.mdx
@@ -0,0 +1,142 @@
+---
+sidebar_position: 1
+title: App provider
+description: The App class is the core of an ExpressoTS application.
+---
+
+import imgAppLifecycle from "./img/app-life-cycle.png";
+
+# Application
+
+The `App` class is the core of an ExpressoTS application, handling server creation and configuration.
+It allows you to set up middleware and providers during the bootstrapping process and offers lifecycle hooks
+to run code before, after, and during server shutdown.
+
+## App express
+
+`AppExpress` is the [Express.js](https://expressjs.com/) platform implementation specifically designed for ExpressoTS.
+It integrates seamlessly with the Express.js ecosystem, providing a robust foundation for building
+and configuring applications within ExpressoTS.
+
+With full support for Express.js middleware, `AppExpress` enables developers to efficiently manage application setup, execution, and shutdown processes,
+all while leveraging the familiar Express.js environment.
+
+:::info
+The framework currently supports Express as its primary adapter, with Fastify and other possible in house server under development.
+:::
+
+Here is the `App` class extending the `AppExpress` adapter:
+
+```typescript title="app.provider.ts"
+export class App extends AppExpress {
+    private middleware: IMiddleware;
+    private provider: ProviderManager;
+
+    constructor() {
+        super();
+        this.middleware = container.get<IMiddleware>(Middleware);
+        this.provider = container.get(ProviderManager);
+    }
+
+    protected configureServices(): void {
+        this.provider.register(Env);
+
+        this.middleware.addBodyParser();
+        this.middleware.setErrorHandler();
+    }
+
+    protected postServerInitialization(): void {
+        if (this.isDevelopment()) {
+            this.provider.get(Env).checkAll();
+        }
+    }
+
+    protected serverShutdown(): void {}
+}
+```
+
+-   `this.provider`: an object containing a register method that allows developers to register internal
+    or external ExpressoTS-compatible providers. This method registers classes in the ExpressoTS container
+    to be part of the dependency injection system, enabling the use of different scopes such as Transient, Scoped, and Singleton.
+
+-   `this.middleware`: offers a set of out-of-the-box middlewares that can be used to configure your application.
+    See the complete list in the **[Middleware section](../features/middleware.mdx)**
+
+:::tip
+Be sure to explore other functionalities available in the class through `this`, like setGlobalRoutePrefix(), setEngine(), and more.
+:::
+
+## Lifecycle hooks
+
+An ExpressoTS application and its components follow a lifecycle managed by the framework.
+ExpressoTS offers lifecycle hooks that let developers track important events and run specific
+code within modules, providers, or controllers as these events happen.
+
+The diagram below shows the sequence of key lifecycle events, from application startup to when the Node.js process exits.
+
+```typescript title="Add any service to initialize before the server starts."
+protected configureServices(): void | Promise<void> { }
+```
+
+```typescript title="Add any service to run after the server starts."
+protected postServerInitialization(): void | Promise<void> { }
+```
+
+```typescript title="Add any service to run after the server shuts down."
+protected serverShutdown(): void | Promise<void> { }
+```
+
+## Hooks execution order
+
+<div style={{ textAlign: "center" }}>
+    <img src={imgAppLifecycle} width="700px" height="700px" alt="Lifecycle events" />
+</div>
+
+## Method isDevelopment
+
+It is a helper method that returns a boolean value indicating whether the application is running in development mode.
+This method is useful for running specific code only in development environments.
+
+```typescript title="Check if the application is running in development mode."
+this.isDevelopment(): boolean
+```
+
+Currently this method is being used in the `postServerInitialization` method to check if the application is running in development mode.
+If it is, the `Env` provider is used to check all environment variables.
+
+```typescript title="Check all environment variables in development mode."
+protected postServerInitialization(): void {
+    if (this.isDevelopment()) {
+        this.provider.get(Env).checkAll();
+    }
+}
+```
+
+## Set global route prefix
+
+You can set a global prefix for all routes in your application. This is useful when you want to version your APIs.
+
+```typescript
+@provide(App)
+class App extends AppExpress {
+    private middleware: IMiddleware;
+    private provider: IProvider;
+
+    constructor() {
+        super();
+        this.middleware = container.get<IMiddleware>(Middleware);
+        this.provider = container.get<IProvider>(Provider);
+    }
+
+    protected configureServices(): void {
+        this.setGlobalRoutePrefix("/v1");
+    }
+}
+```
+
+---
+
+## Support us ❤️
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/core/controller.mdx b/docs/core/controller.mdx
new file mode 100644
index 00000000..44c5faef
--- /dev/null
+++ b/docs/core/controller.mdx
@@ -0,0 +1,346 @@
+---
+sidebar_position: 4
+title: Controllers
+description: Controllers the mediator between the client and server.
+---
+
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+
+# Controllers
+
+Controllers act as the primary interface between the client and server.
+They handle incoming requests, validate payloads against an input DTO, and emit responses in the DTO pattern.
+In essence, controllers bridge the communication between clients and service layers, also known as use-cases.
+
+## Create a controller
+
+In order to create a controller use the CLI tool with the following command:
+
+```bash
+expressots g c controller-name
+```
+
+Example of a generated controller:
+
+```bash
+expressots g c product
+```
+
+```typescript title="ProductController.ts"
+import { controller } from "@expressots/adapter-express";
+
+@controller("/")
+export class ProductController {}
+```
+
+## Patterns
+
+As mentioned before, controllers can be created in two different patterns: **SOLID** and **MVC**.
+The choice between these patterns depends on the project's requirements and the developer's preference.
+
+<Tabs>
+    <TabItem label="SOLID" value="solid">
+```ts title="One controller, one execution method, and one use case"
+    @controller("/product/create")
+    export class ProductCreateController {
+        @Post("")
+        exeute() {
+            return "Product created!";
+        }
+    }
+```
+    </TabItem>
+
+    <TabItem label="MVC" value="mvc">
+
+```ts title="Several routes in a single controller"
+@controller("/product")
+export class ProductController {
+    @Post("/")
+    createProduct() {
+        return "Product created!";
+    }
+    @Get("/")
+    readProduct() {
+        return "Product read!";
+    }
+    @Patch("/:id")
+    updateProduct() {
+        return "Product updated!";
+    }
+    @Delete("/:id")
+    deleteProduct() {
+        return "Product deleted!";
+    }
+}
+```
+
+    </TabItem>
+
+</Tabs>
+
+## Routing
+
+Routing in ExpressoTS is handled with decorators. The `@controller()` decorator sets the base route,
+while HTTP method decorators like `@Get()` and `@Post()` define specific routes.
+
+You can also apply middleware at the controller level which affects all methods, while applying it to a method affects only that specific route.
+This approach ensures a clean and structured way to manage routing and middleware in your application.
+
+Example of controller routing concatenation:
+
+```typescript title="BASE_URL/product/create"
+@controller("/product")
+export class ProductController {
+    @Post("/create")
+    createProduct() {
+        return "Product created!";
+    }
+}
+```
+
+Example of middleware usage:
+
+```typescript title="Middleware usage in a controller and in a specific route"
+@controller("/product", authMiddleware)
+export class ProductController {
+    @Post("/create", bodyParsingMiddleware)
+    createProduct() {
+        return "Product created!";
+    }
+}
+```
+
+## Route string patterns
+
+Routes based on string patterns can be defined as well. This feature is useful when you need to define a route with a dynamic parameter.
+
+```typescript title="Route with a dynamic parameter"
+@controller("/ab?cd")
+export class AppController {
+    @Get("")
+    stringPattern(): string {
+        return "Routes to be used in the following paths: /acd or /abcd";
+    }
+}
+```
+
+Read more about route string patterns and all the possibilities [here](https://expressjs.com/en/guide/routing.html#route-paths).
+
+## Scope
+
+The default scope of a controller is `Request`, as it is inherited from the `AppContainer` and default `Module` class scope.
+However, you can override the scope of a controller by using the `@scope()` decorator. This decorator accepts the same BindingScopeEnum values.
+
+:::caution
+If you define the module scope you can not override it in a specific controller by using the `@scope` decorator.
+The `@scope` decorator can only be used in specific controllers if the module scope is not defined.
+:::
+
+Here is an example of usage:
+
+Use `BindingScopeEnum.Singleton` or simply a string "Singleton".
+
+```typescript
+@scope("Singleton")
+@controller("/")
+class ProductController {}
+```
+
+The controller above will be scoped as `Singleton` and will be shared across all requests.
+
+## Base controller
+
+In ExpressoTS, we enhance controller classes with a `BaseController` class, which offers two methods—`callUseCase()`
+and `callUseCaseAsync()`—to simplify the interaction between controllers and use cases.
+These methods reinforce the principle of "one use case per controller" by focusing the controller's role
+on invoking the business logic encapsulated within a use case.
+
+:::info
+`BaseController` class is only a syntatic sugar to help developers to call use cases in a more organized way.
+:::
+
+```typescript title="Method signature"
+callUseCase(usecase: unknown, res: Response, successStatusCode: number);
+
+```
+
+-   `useCase`: The use case that will be called. This use case is injected in the controller constructor.
+-   `res`: The response object from the express request.
+-   `successStatusCode`: The status code that will be sent to the client if the use case is executed successfully.
+    Please see the **[Http status code](../features/status-code.mdx)** type for more information.
+
+```typescript title="Default response format"
+return res.status(successStatusCode).json(dataReturn);
+```
+
+```typescript title="Complete example"
+@controller("/")
+class AppController extends BaseController {
+    constructor(private appUseCase: AppUseCase) {}
+
+    @Get("")
+    execute(@response() res: Response) {
+        return this.callUseCase(this.appUseCase.execute(), res, StatusCode.OK);
+    }
+}
+```
+
+## Request object
+
+In order to access the request object, you can use the `@request()` decorator.
+
+```typescript title="Request object example"
+import { controller, Get, request } from "@expressots/adapter-express";
+import { Request } from "express";
+
+@controller("/product")
+export class ProductController {
+    @Get("/")
+    getAllProducts(@request() req: Request) {
+        return "Return all products";
+    }
+}
+```
+
+:::tip
+You can take advantage of the express types to access the request object as they are already imported in the `@expressots/adapter-express` package.
+:::
+
+The request object is just one of the decorators available in ExpressoTS. See more in the below section.
+
+## Controller decorators
+
+HTTP methods and parameters decorators are a set of annotations used in ExpressoTS applications to define the routing
+and request handling for HTTP requests. Using the decorators listed below can simplify the routing and handling of HTTP requests
+in ExpressoTS applications, and make the code more readable and maintainable.
+
+<Tabs>
+    <TabItem label="Parameter Decorators" value="parameter-decorators">
+
+Here's a list of all available parameter decorators in ExpressoTS, along with their description and usage:
+
+| Decorator                     | Description                                            | Usage                                            |
+| ----------------------------- | ------------------------------------------------------ | ------------------------------------------------ |
+| @request()                    | Injects the Express Request object.                    | execute(@request() req: Request)                 |
+| @response()                   | Injects the Express Response object.                   | execute(@response() res: Response)               |
+| @param(paramName?: string)    | Injects a parameter from the request URL path.         | execute(@param('id') id: string)                 |
+| @query(paramName?: string)    | Injects a parameter from the request URL query string. | execute(@query('searchTerm') searchTerm: string) |
+| @body()                       | Injects the request body payload.                      | execute(@body() body: MyDTO)                     |
+| @headers(headerName?: string) | Injects a header from the request headers.             | execute(@headers('authorization') auth: string)  |
+| @cookies(cookieName?: string) | Injects a cookie from the request cookies.             | execute(@cookies('session') session: string)     |
+| @next()                       | Injects the Express NextFunction object.               | execute(@next() next: NextFunction)              |
+
+    </TabItem>
+
+    <TabItem label="Method Decorators" value="method-decorators">
+
+Here's a list of all available `@httpMethods()` decorators in ExpressoTS, along with their description and usage:
+
+| Decorator | Description                                         | Usage                    |
+| --------- | --------------------------------------------------- | ------------------------ |
+| @Get      | Binds a controller method to a GET HTTP verb.       | @Get("/path")            |
+| @Post     | Binds a controller method to a POST HTTP verb.      | @Post("/path")           |
+| @Put      | Binds a controller method to a PUT HTTP verb.       | @Put("/path")            |
+| @Patch    | Binds a controller method to a PATCH HTTP verb.     | @Patch("/path")          |
+| @Head     | Binds a controller method to a HEAD HTTP verb.      | @Head("/path")           |
+| @Delete   | Binds a controller method to a DELETE HTTP verb.    | @Delete("/path")         |
+| @Method   | Binds a controller method to a specified HTTP verb. | @Method("verb", "/path") |
+
+    </TabItem>
+
+</Tabs>
+
+For a full list of available decorators, please refer to the **[Decorators](../features/decorators.mdx)**.
+
+## Status code
+
+By default, all HTTP response status codes are set to 200, except for the Post method, which defaults to 201.
+
+```typescript title="Using the @Http() decorator"
+import { controller, Get, Http } from "@expressots/adapter-express";
+
+@controller("/")
+export class AppController {
+    @Get("")
+    @Http(204)
+    execute() {
+        return "App is running!";
+    }
+}
+```
+
+:::tip You can import <span class="span-table">StatusCode</span> from `@expressots/core` to use the default status codes.
+:::
+
+Read more about status codes in the **[Status Code](../features/status-code.mdx)** section.
+
+```typescript title="Using the StatusCode to improve the code readability"
+import { StatusCode } from "@expressots/core";
+
+@Http(StatusCode.NoContent)
+```
+
+## Payloads
+
+In a request, payloads refer to the data sent between the client and server, typically in the body of the request. This data is crucial for operations like creating, updating, or querying resources.
+
+The DTO pattern standardizes these payloads for communication between different application layers. By providing clear and consistent data structures for input and output, DTOs separate business logic from data exchange, reducing complexity, improving performance, and enhancing scalability.
+
+For example, imagine a user registration scenario where name, email, and password are collected, and ID is auto-generated. The user object DTO for Input and Response could have possible formats, as shown below:
+
+```typescript title="user-create.dto.ts"
+interface UserCreateRequestDTO {
+    name: string;
+    email: string;
+    password: string;
+}
+
+interface UserCreateResponseDTO {
+    id: string;
+    name: string;
+    message: string;
+}
+```
+
+Having two different DTO formats is essential in this case because while registering a user, we don't want to return the password
+to the client due to security concerns. Therefore, we created a different DTO for the response, adding a complementary field called message,
+where a message is typically sent to the client, indicating that the user was created successfully.
+
+As a result, DTOs help to segregate and filter the data being sent to the client, reducing the amount of data processed by the application.
+
+Using DTOs in ExpressoTS is straightforward. You can use the `@body()` decorator to inject the request body payload into the controller method.
+
+```typescript title="Using the @body() decorator"
+@controller("/user")
+export class UserController {
+    @Post("")
+    register(@body() payload: UserCreateRequestDTO): UserCreateResponseDTO {
+        return {
+            id: "1",
+            name: payload.name,
+            message: "User created successfully",
+        };
+    }
+}
+```
+
+## Error handling
+
+For error handling, ExpressoTS provides a built-in error handler middleware that can be used to catch errors thrown in the application.
+This middleware is automatically added to the application when it is initialized in the `app.provider.ts` file.
+
+Read more about error handling in ExpressoTS in the **[Error Handling](../features/error-handling.mdx)** section.
+
+:::warning Initializing the Application without a controller
+ExpressoTS will prevent you from initializing the Application without a controller since there are no listeners to handle incoming requests. You will see the following message in the console:
+**_No controllers have been found! Please ensure that you have register at least one Controller._**
+:::
+
+---
+
+## Support us ❤️
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/overview/di.md b/docs/core/di.mdx
similarity index 52%
rename from docs/overview/di.md
rename to docs/core/di.mdx
index 0bc6548e..9774d4b0 100644
--- a/docs/overview/di.md
+++ b/docs/core/di.mdx
@@ -1,12 +1,16 @@
 ---
-sidebar_position: 12
+sidebar_position: 8
+title: Injection
+description: Dependency Injection in ExpressoTS.
 ---
 
+import diImg from "./img/di.png";
+
 # Dependency Injection
 
 Dependency Injection (DI) is a design pattern used in software development that involves providing an object with the instances of the classes it needs to perform its tasks, rather than having it construct these instances itself. This process of `providing` instances is called `injecting` them, hence the term Dependency Injection.
 
-## Benefits of DI
+## Benefits
 
 Here are some of the key benefits of using Dependency Injection:
 
@@ -26,58 +30,44 @@ Here are some of the key benefits of using Dependency Injection:
 
 In conclusion, DI is a technique that facilitates loose coupling, increased testability, and more maintainable and flexible code.
 
-## DI on ExpressoTS
-
-Here is how ExpressoTS implements DI:
-
-![Application Overview](./img/di.png)
+## Architecture
 
-## DI components breakdown
+In the image below, we ensure that each controller is responsible for a single task, which is why
+you see multiple controllers within a module. This architecture showcases the flexibility of the container
+system, enabling developers to define scopes at various levels, including the container, module, and controller.
+Even services like use cases and providers can have their own distinct scopes within the container.
 
-Here is a breakdown of the DI components used in ExpressoTS:
-
-| Components | Description                                                                                        |
-| ---------- | -------------------------------------------------------------------------------------------------- |
-| Container  | The DI container of the ExpressoTS application.                                                    |
-| Module     | A container module is typically used to group related controllers and their dependencies together. |
-| Controller | Primary interface between the client and server. Responsible to handle incoming requests.          |
-| Classes    | Any other class part of the ExpressoTS ecosystem, for example, providers, entities, helpers, etc.  |
+<div style={{ textAlign: "center" }}>
+    <img src={diImg} alt="Container" />
+</div>
 
-### Resume
+---
 
 -   Container have its default scope that can be override by the module. The default scope is `Request` scope.
 -   Defining a scope for a module forces all controllers under that module to have the same scope.
 -   Not defining a scope for a module allow controllers to have their own scope using `@scope()` decorator.
 -   All other registered classes such as providers, entities, helpers can have their specific scope based on the decorator used.
--   Decorators:
-
-| Decorator         | Description                                                        |
-| ----------------- | ------------------------------------------------------------------ |
-| @provide          | Binds a class to a dependency injection container as RequestScope. |
-| @provideSingleton | Binds a class to a dependency injection container as Singleton.    |
-| @provideTransient | Binds a class to a dependency injection container as Transient.    |
 
-### Container
+## Components
 
-The container is the main component of the DI system. It is responsible for managing the lifecycle of the objects it creates, and for injecting dependencies into those objects.
+The DI system in ExpressoTS is composed of the following components:
 
-The default scope of the container is `Request` scope. This means that the container will create a new instance of a class for each request. For more information about **[Containers](app-container.md)** please refer to the app container section.
-
-### Modules
-
-A container module is used to organize related controllers and their dependencies and coherent units. Modules can also have their own specific scope definition. For more information about modules please refer to the **[Modules](module.md)** section.
-
-### Controllers
-
-Controllers are grouped into modules that usually represents a feature of the application. Controllers are always associated with modules. If a module has a specific scope defined, all controllers within that module will be created with the module scope. If the module doesn't have a scope defined, it inherits the scope of the Application container, which is `Request` scope.
-
-In this particular case, individual controllers can have their own scope defined by using `@scope()` decorator. For more information about controllers please refer to the **[Controllers](controller.md)** section.
+| Components | Description                                                                                        |
+| ---------- | -------------------------------------------------------------------------------------------------- |
+| Container  | The DI container of the ExpressoTS application.                                                    |
+| Module     | A container module is typically used to group related controllers and their dependencies together. |
+| Controller | Primary interface between the client and server. Responsible to handle incoming requests.          |
+| Classes    | Any other class part of the ExpressoTS ecosystem, for example, providers, entities, helpers, etc.  |
 
-### Classes
+## Decorators
 
-Any other class part of the ExpressoTS ecosystem, for example, providers, entities, helper classes, etc are injected automatically to the Application Container through the decorator `@provide()` in which injects the classes as `Request` by default.
+Injection is done through decorators. The following decorators are used to define the scope of a class:
 
-If you want to define a different scope for your class, you can use the `@provideSingleton()` decorator to inject the class as a singleton or `@provideTransient()` to inject the class as transient.
+| Decorator           | Description                                                        |
+| ------------------- | ------------------------------------------------------------------ |
+| @provide()          | Binds a class to a dependency injection container as RequestScope. |
+| @provideSingleton() | Binds a class to a dependency injection container as Singleton.    |
+| @provideTransient() | Binds a class to a dependency injection container as Transient.    |
 
 Example of usage:
 
@@ -102,23 +92,68 @@ class MySingleton {}
 class MyTransient {}
 ```
 
-:::tip
-To define scope bindings the enum BindingScopeEnum can be used.
+## Controller scope
+
+Controllers can have their own scope using the `@scope()` decorator. This decorator can be used to define the scope of a controller.
+
+Example of usage:
+
+```typescript
+@scope("Singleton")
+@controller()
+class MyController {}
+```
+
+:::info
+You can't define a scope for a controller if the module has a scope defined.
 :::
 
--   `BindingScopeEnum.Singleton` - The dependency will be created once and will be shared across all requests.
--   `BindingScopeEnum.Request` - The dependency will be created once per request.
--   `BindingScopeEnum.Transient` - The dependency will be created every time it is requested.
+## Circular dependencies
 
----
+Circular dependencies occur when two or more modules depend on each other, leading to a potentially infinite loop or other issues during dependency injection.
+
+ExpressoTS circular dependencies can be resolved using the following methods:
+
+<span class="span-table">Lazy Injection: </span> (@inject with LazyServiceIdentifier)
+
+One common approach to handle circular dependencies in ExpressoTS is to use lazy injection. This allows the IoC container to inject a proxy or a function
+that retrieves the dependency only when it's actually needed. This postpones the resolution of the dependency,
+avoiding the immediate circular reference issue.
 
-## Support the project
+To implement this, you can use the `LazyServiceIdentifier` utility provided by the framework.
+
+```typescript title="Lazy Injection"
+import { inject, LazyServiceIdentifier } from "inversify";
+
+@provide(ServiceA)
+class ServiceA {
+    constructor(
+        @inject(new LazyServiceIdentifier(() => ServiceB))
+        private serviceB: ServiceB
+    ) {}
+}
+
+@provide(ServiceB)
+class ServiceB {
+    constructor(@inject(ServiceA) private serviceA: ServiceA) {}
+}
+```
+
+In this example, ServiceA and ServiceB depend on each other. By using `LazyServiceIdentifier`, ServiceB
+is injected into ServiceA in a lazy manner, breaking the circular dependency loop.
+
+:::caution Factory Injection is under development.
+:::
+
+<span class="span-table">Factory Injection: </span> Use factory functions to create instances on demand,
+thus avoiding circular dependencies at construction time.
+
+<span class="span-table">Proxies: </span> Employ proxies to delay the resolution of dependencies, giving
+more control over when and how the dependency is resolved.
+
+---
 
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
+## Support us ❤️
 
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/core/entities.mdx b/docs/core/entities.mdx
new file mode 100644
index 00000000..2c7e61d2
--- /dev/null
+++ b/docs/core/entities.mdx
@@ -0,0 +1,156 @@
+---
+sidebar_position: 7
+title: Entities
+description: Entities are objects that represent data.
+---
+
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+
+# Entities
+
+Entities are the core components of an ExpressoTS application, representing the data that the application manipulates.
+When an entity changes, it's likely that use cases and controllers will need to be updated as well, since they
+are responsible for handling and processing the data represented by these entities.
+
+## Create an entity
+
+To create an entity, you can use the CLI with the following command:
+
+```bash
+expressots g e user
+```
+
+<Tabs>
+    <TabItem value="non-opinionated" label="Non Opinionated">
+
+```ts
+import { provide } from "@expressots/core";
+
+@provide(UserEntity)
+export class UserEntity {}
+```
+
+    </TabItem>
+    <TabItem value="opinionated" label="Opinionated">
+
+```typescript
+import { provide } from "@expressots/core";
+import { randomUUID } from "node:crypto";
+
+@provide(UserEntity)
+export class UserEntity {
+    id: string;
+
+    constructor() {
+        this.id = randomUUID();
+    }
+}
+```
+
+    </TabItem>
+
+</Tabs>
+
+## Entity injection
+
+If your entity has dependencies, you can inject them using the `@inject()` decorator.
+
+```typescript
+@provide(UserEntity)
+class UserEntity {
+    constructor(@inject(Logger) private logger: Logger) {}
+}
+```
+
+## Injecting primitive parameters
+
+Avoid marking constructors with primitive parameters as injectable. This is because it can be difficult for the DI container
+to infer what values to provide for these parameters. Here is an example of what you should avoid:
+
+```typescript
+@provide(UserEntity)
+class UserEntity {
+    name: string;
+    constructor(name: string) {
+        this.name = name;
+    }
+}
+```
+
+:::info
+In many dependency injection (DI) systems, including `InversifyJS`, the DI container is responsible for constructing
+objects and injecting dependencies. When a class constructor contains primitive parameters, it can be difficult
+for the DI container to infer what values to provide for these parameters. This is because primitive values
+(like strings, numbers, and booleans) do not carry any inherent semantic meaning that the container can understand.
+:::
+
+Here are some of the reasons why constructors with primitive parameters can be problematic in DI:
+
+-   Ambiguity: If a class has a constructor that requires primitive types, the DI container won't know what values to inject. For example, if a class requires a number in its constructor, the DI container doesn't know what this number represents and what value it should have.
+
+-   Inflexibility: A primitive value in the constructor implies that the value is a fixed part of the class. However, DI is often used to manage interchangeable parts of an application (e.g., different implementations of an interface).
+
+-   Non-descriptive: Primitive values are often non-descriptive and can lead to confusing code. For example, a constructor that takes two string parameters might raise questions like: What do these strings represent? Are there any specific formats or constraints on these strings?
+
+## Primitive injection alternative
+
+If you need to inject a primitive into your class, it's worth reconsidering your design. If primitive parameters are essential
+in your constructor, consider using factories to create your entities or applying the Repository pattern.
+
+Here is an example of a factory:
+
+```typescript title="user.entity.ts"
+@provide(UserEntity)
+class UserEntity {
+    public id: string;
+    public name: string;
+    public email: string;
+
+    constructor() {
+        this.id = randomUUID();
+    }
+}
+```
+
+```typescript title="user.factory.interface.ts"
+interface IUserEntityFactory {
+    create(name: string, email: string): User;
+}
+```
+
+```typescript title="user.factory.ts"
+@provide(UserEntityFactory)
+class UserEntityFactory implements IUserEntityFactory {
+    create(name: string, email: string): User {
+        const user = new User();
+        user.name = name;
+        user.email = email;
+        return user;
+    }
+}
+```
+
+Now `UserEntityFactory` can be easily injected into other classes.
+
+As mentioned above, there are several other approaches, as long as you remain strong 😁 of not using constructors with primitives parameters in classes that you are planning to inject.
+
+## Entities are just data 💡
+
+For years we have been told that entities or classes properties should be encapsulated, its methods should abstract the internal implementation and expose only the necessary information to the outside world. This is a good practice when thinking about Object Oriented Programming Paradigm, however this is not always the best approach.
+
+If you think about it, classes, or entities, whatever you call it, are just a way to represent data. They are just a way to group data together.
+With this in mind, classes or entities became much more simple to maintain and understand, as they don't contain any logic.
+
+This way of thinking is called **[Anemic Domain Model](https://martinfowler.com/bliki/AnemicDomainModel.html)** and it's a very controversial topic. It's not the purpose of this documentation to discuss this topic, but it's important to mention it, as it's a very important concept when thinking about ExpressoTS entities.
+
+<span class="span-table">
+    Say good bye to God classes, and say hello to simple entities, say hello to data.
+</span>
+
+---
+
+## Support us ❤️
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/core/first-steps.mdx b/docs/core/first-steps.mdx
new file mode 100644
index 00000000..a92f52e7
--- /dev/null
+++ b/docs/core/first-steps.mdx
@@ -0,0 +1,202 @@
+---
+sidebar_position: 0
+title: First steps
+description: Begin your journey with ExpressoTS!
+---
+
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+
+# First steps
+
+Begin your journey with ExpressoTS! These guides will help you learn and get familiarized with the essential building blocks of ExpressoTS.
+
+## Philosophy
+
+ExpressoTS streamlines server-side development by emphasizing clear and structured code. Ideal
+for both simple APIs and complex systems, ExpressoTS accelerates development and ensures timely, high-quality delivery.
+
+ExpressoTS is a [TypeScript](https://www.typescriptlang.org/) framework fully integrated with the [Node.js](https://nodejs.org/en) and [Expressjs](https://expressjs.com/) ecosystem. While TypeScript is the primary language,
+ExpressoTS is fully compatible with JavaScript, and we plan to support other runtimes soon.
+
+In this tutorial, we’ll use TypeScript for most examples, but feel free to switch to vanilla JavaScript if that suits you better.
+
+## Architecture
+
+ExpressoTS architecture centers on the **[Inversify](https://inversify.io/)** IoC container,
+which manages dependency injection in class constructors or in properties.
+This setup ensures that all necessary modules, including routes (controllers), are loaded.
+Routers then handle incoming requests using use-cases and providers as required.
+
+Here’s an overview of an ExpressoTS application:
+
+![Application Overview](./img/app-overview.png)
+
+> -   **DTO IN/OUT**: Defines the structure for incoming and outgoing data.
+> -   **Controller**: Manages request processing.
+> -   **Use Case**: Executes specific logic for handling requests.
+> -   **Provider**: Supplies external functionalities like database access.
+> -   **Repository**: Handles direct communication with the database.
+
+## Pre-requisites
+
+Please make sure that [Node.js](https://nodejs.org) `version >=18.0.0` is installed on your operating system.
+
+## Setup
+
+Install the **[ExpressoTS CLI](../cli/overview.mdx)** globally using NPM to get started with your project setup:
+
+Setting up a new ExpressoTS project is quite simple with **[ExpressoTS CLI](../cli/overview.mdx)**. First install the CLI globally with `NPM`:
+
+```bash
+npm i -g @expressots/cli
+```
+
+Create a new project by running:
+
+```bash
+expressots new project-name
+```
+
+## Project templates
+
+ExpressoTS provides two project templates to cater to different development needs:
+
+-   Non-opinionated: Provides flexibility in project structure and resource scaffolding, with minimal setup.
+-   Opinionated: Pre-configured for complex projects, enforcing a specific structure and scaffolding pattern.
+
+<Tabs>
+    <TabItem label="Non Opinionated" value="non-opinionated">
+
+#### Non-opinionated project structure
+
+```tree
+project-name/
+├── src/
+│   ├── app.container.ts
+│   ├── app.controller.ts
+│   ├── app.module.ts
+│   ├── app.provider.ts
+│   ├── main.ts
+├── test/
+│   ├── app.controller.spec.ts
+```
+
+| File Name                                               | Description                                                        |
+| ------------------------------------------------------- | ------------------------------------------------------------------ |
+| <span class="span-table"> app.container.ts</span>       | Dependency injection container. Organizes the application modules. |
+| <span class="span-table"> app.controller.ts</span>      | A basic controller with a single route.                            |
+| <span class="span-table"> app.module.ts</span>          | Application root module.                                           |
+| <span class="span-table"> app.provider.ts</span>        | Application global configuration file.                             |
+| <span class="span-table"> main.ts</span>                | The main entry point of an ExpressoTS application.                 |
+| <span class="span-table"> app.controller.spec.ts</span> | Unit test for the app.controller.                                  |
+
+    </TabItem>
+
+    <TabItem label="Opinionated" value="opinionated">
+
+#### Opinionated project structure
+
+```tree
+project-name/
+├── src/
+│   ├── providers/
+│   │   └── app/
+│   │       └── app.provider.ts
+│   ├── useCases/
+│   │   └── app/
+│   │       └── app.controller.ts
+│   │       └── app.module.ts
+│   │       └── app.usecase.ts
+│   ├── app.container.ts
+│   ├── env.ts
+│   ├── main.ts
+├── test/
+│   ├── app.usecase.spec.ts
+```
+
+| File Name                                            | Description                                                                                   |
+| ---------------------------------------------------- | --------------------------------------------------------------------------------------------- |
+| <span class="span-table"> app.provider.ts</span>     | Application global configuration file.                                                        |
+| <span class="span-table"> providers/\*</span>        | This folder contains the layer responsible to provide externals resources to the application. |
+| <span class="span-table"> useCases/\*</span>         | The use case folder holds the implementation of operations for the application.               |
+| <span class="span-table"> app.container.ts</span>    | Dependency injection container. Organizes the application modules.                            |
+| <span class="span-table"> env.ts</span>              | This is an utility resource that maps .env variables.                                         |
+| <span class="span-table"> main.ts</span>             | The main entry point of an ExpressoTS application.                                            |
+| <span class="span-table"> app.usecase.spec.ts</span> | A basic unit test for the app.usecase.                                                        |
+
+    </TabItem>
+
+</Tabs>
+:::info
+Opinionated projects have a different scaffold pattern in addition to the non-opinionated projects. They are pre-configured for complex projects, enforcing
+a specific structure and name convention.
+:::
+
+## Main
+
+The main entry point `main.ts` of an ExpressoTS application is where the application is initialized. This file is responsible for bootstrapping
+the application and starting the server.
+
+```typescript
+async function bootstrap() {
+    const app = await AppFactory.create(container, App);
+    await app.listen(3000, ServerEnvironment.Development);
+}
+
+bootstrap();
+```
+
+The `AppFactory` class is responsible for creating the application instance. The `AppFactory` was designed to support multiple web servers like Express.js, Fastify, and more. Currently, it only supports Express.js.
+
+The `create` method accepts the container and the application class as parameters.
+The `listen` method starts the server on the specified port and environment. You can also pass an object specifying the app's name and version.
+
+The `App` class is the application root module, which is responsible for initializing the application and its dependencies.
+All application configuration and setup are handled in the [App class](./app-provider.mdx) - (`app.provider.ts`) file.
+
+The `ServerEnvironment` is defined through the enum, with support for `development` and `production` modes.
+
+## Running the application
+
+With your application set up, you can start your development server, build your application, or run it in production mode.
+
+Development mode
+
+```bash
+✔️ npm run dev
+```
+
+Build the application
+
+```bash
+✔️ npm run build
+```
+
+Production mode
+
+```bash
+✔️ npm run prod
+```
+
+Once the application is up and running, you can access it by navigating to <span class="span-table">http://localhost:3000/</span>.
+You should see <span class="span-table">Hello from ExpressoTS!</span> displayed on the screen.
+
+## Linter and formatter
+
+ExpressoTS uses [ESLint](https://eslint.org/) and [Prettier](https://prettier.io/) to enforce code quality and consistency. You can run the following commands to lint and format your code:
+
+```bash
+✔️ npm run lint
+```
+
+```bash
+✔️ npm run format
+```
+
+---
+
+## Support us ❤️
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/core/img/Module.png b/docs/core/img/Module.png
new file mode 100644
index 00000000..36552167
Binary files /dev/null and b/docs/core/img/Module.png differ
diff --git a/docs/overview/img/app-life-cycle.png b/docs/core/img/app-life-cycle.png
similarity index 100%
rename from docs/overview/img/app-life-cycle.png
rename to docs/core/img/app-life-cycle.png
diff --git a/docs/overview/img/app-overview.png b/docs/core/img/app-overview.png
similarity index 100%
rename from docs/overview/img/app-overview.png
rename to docs/core/img/app-overview.png
diff --git a/docs/overview/img/container-bindings.png b/docs/core/img/container-bindings.png
similarity index 100%
rename from docs/overview/img/container-bindings.png
rename to docs/core/img/container-bindings.png
diff --git a/docs/core/img/di.png b/docs/core/img/di.png
new file mode 100644
index 00000000..906a9582
Binary files /dev/null and b/docs/core/img/di.png differ
diff --git a/docs/overview/img/inMemoryDB.png b/docs/core/img/inMemoryDB.png
similarity index 100%
rename from docs/overview/img/inMemoryDB.png
rename to docs/core/img/inMemoryDB.png
diff --git a/docs/overview/img/middleware-view.png b/docs/core/img/middleware-view.png
similarity index 100%
rename from docs/overview/img/middleware-view.png
rename to docs/core/img/middleware-view.png
diff --git a/docs/core/img/module-mvc.png b/docs/core/img/module-mvc.png
new file mode 100644
index 00000000..d4056a2a
Binary files /dev/null and b/docs/core/img/module-mvc.png differ
diff --git a/docs/core/img/plugin-pattern.png b/docs/core/img/plugin-pattern.png
new file mode 100644
index 00000000..041f72f6
Binary files /dev/null and b/docs/core/img/plugin-pattern.png differ
diff --git a/docs/overview/img/project-demo-msg.png b/docs/core/img/project-demo-msg.png
similarity index 100%
rename from docs/overview/img/project-demo-msg.png
rename to docs/core/img/project-demo-msg.png
diff --git a/docs/core/img/roadmap-component.png b/docs/core/img/roadmap-component.png
new file mode 100644
index 00000000..b551ce0a
Binary files /dev/null and b/docs/core/img/roadmap-component.png differ
diff --git a/docs/overview/img/scaffold-resources.png b/docs/core/img/scaffold-resources.png
similarity index 100%
rename from docs/overview/img/scaffold-resources.png
rename to docs/core/img/scaffold-resources.png
diff --git a/docs/core/img/usecase.png b/docs/core/img/usecase.png
new file mode 100644
index 00000000..449df479
Binary files /dev/null and b/docs/core/img/usecase.png differ
diff --git a/docs/core/module.mdx b/docs/core/module.mdx
new file mode 100644
index 00000000..170d5607
--- /dev/null
+++ b/docs/core/module.mdx
@@ -0,0 +1,146 @@
+---
+sidebar_position: 3
+title: Modules
+description: Modules are collections of controllers.
+---
+
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+import moduleImg from "./img/module.png";
+import moduleMVCImg from "./img/module-mvc.png";
+
+# Modules
+
+Modules, or container modules in ExpressoTS, are collections of services—primarily Controllers and
+their dependencies—managed by the framework's container. These modules help organize your application
+into logical domains, register components, and resolve Controllers efficiently.
+
+<Tabs>
+    <TabItem label="SOLID" value="solid">
+        <div style={{ textAlign: "center" }}>
+            <img src={moduleImg} alt="Lifecycle events" />
+        </div>
+
+        ---
+
+        ExpressoTS encourages the creation of controllers following the SOLID principles. In this approach, each controller
+        is responsible for a specific action, such as creating, updating, or deleting a product. For example, within a Product
+        Module, you might have separate controllers like CreateController, UpdateController, and DeleteController. Each of these
+        controllers would then call their unique service or use case, which contains the actual implementation logic. This structure
+        helps maintain a clean and organized codebase, where each controller has a single responsibility.
+    </TabItem>
+
+    <TabItem label="MVC" value="mvc">
+        <div style={{ textAlign: "center" }}>
+            <img src={moduleMVCImg} alt="Lifecycle events" />
+        </div>
+
+        ---
+
+        ExpressoTS also supports the traditional MVC (Model-View-Controller) pattern. In this approach,
+        a single controller can manage multiple routes related to a specific resource. For instance, within a
+        Product Module, you could have a ProductController that handles various routes like create, update, and delete.
+        This style is beneficial for smaller applications or when you prefer to group related actions within the same controller,
+        providing a more compact and centralized structure.
+    </TabItem>
+
+</Tabs>
+
+:::info
+ExpressoTS provides the flexibility to choose the approach that best fits your project’s needs, whether it's adhering to SOLID principles
+for maximum maintainability or following the MVC pattern for simplicity and clarity.
+:::
+
+## Creating a module
+
+To create a module using the CLI tool, run the following command:
+
+```bash
+expressots g mo module-name
+```
+
+This command will generate a new module with the following structure:
+
+```typescript
+import { CreateModule } from "@expressots/core";
+
+export const ProductModule = CreateModule([]);
+```
+
+## Registering controllers
+
+To register controllers within a module, pass them as an array to the `CreateModule` function. For example:
+
+```typescript
+import { CreateModule } from "@expressots/core";
+import { ProductController } from "./product.controller";
+
+export const ProductModule = CreateModule([ProductController]);
+```
+
+## Module scope
+
+Very similar to the `Container`, developers can set the scope of a module using the same `BindingScopeEnum` enum. All controllers registered
+within the module will inherit the module's scope.
+
+Here are the possible scope values:
+
+-   `BindingScopeEnum.Singleton` - The dependency will be created once and will be shared across all requests.
+-   `BindingScopeEnum.Request` - The dependency will be created once per request.
+-   `BindingScopeEnum.Transient` - The dependency will be created every time it is requested.
+
+When creating a module, you can pass the scope as a second argument to the `CreateModule` function.
+It is optional and if not provided, the default scope is acquired from the `AppContainer` which is `RequestScope`.
+
+```typescript
+export const ProductModule: ContainerModule = CreateModule([], BindingScopeEnum.Singleton);
+```
+
+This flexibility allows for tailored dependency management strategies, such as combining Singleton scope modules for shared services
+with Request scope modules for request-specific services.
+
+In the example above, all controllers registered within the `ProductModule` will have a Singleton scope.
+
+## Scope precedence
+
+The hierarchy of scope precedence is:
+`AppContainer` > `Module` > `Controller`, ensuring a versatile and hierarchical approach
+to dependency scope management. This layered structure permits precise control over service
+instantiation and lifecycle across the entire application.
+
+1. AppContainer
+
+-   Scope: Global
+-   Role: The AppContainer is at the top of the hierarchy. It manages dependencies and services that need to be available throughout the entire application. Services registered here have the broadest scope and are shared across all modules and controllers.
+
+2. Module
+
+-   Scope: Modular
+-   Role: Within the AppContainer, each Module represents a distinct domain or feature in your application. Dependencies registered in a module are available to all controllers and services within that specific module, allowing for modular separation of concerns.
+
+3. Controller
+
+-   Scope: Specific
+-   Role: The most specific layer is the Controller. Dependencies registered at this level are only available within the individual controller. This scope is ideal for services or logic that are only relevant to a particular controller’s operations.
+
+:::tip
+To override controller scope within a module, you can use `@scope()` decorator.
+:::
+
+```typescript title="@scope( ) decorator example"
+@scope("Singleton")
+@controller("/")
+export class ProductController {
+    @Get("/")
+    execute() {
+        return "ProductController";
+    }
+}
+```
+
+---
+
+## Support us ❤️
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/overview/providers.md b/docs/core/providers.mdx
similarity index 50%
rename from docs/overview/providers.md
rename to docs/core/providers.mdx
index fed3d727..896418f3 100644
--- a/docs/overview/providers.md
+++ b/docs/core/providers.mdx
@@ -1,14 +1,15 @@
 ---
-sidebar_position: 8
+sidebar_position: 6
+title: Providers
+description: Providers are modular components.
 ---
 
-# Providers
-
-In ExpressoTS, providers serve as modular enhancements to an application, encapsulating specific functionalities such as email services, authentication mechanisms, or database connections. This encapsulation is essential for preserving a loosely coupled architecture, enabling seamless swapping or updating of these functionalities without affecting the overall system.
+import pluginPatternImg from "./img/plugin-pattern.png";
 
-## The role of providers
+# Providers
 
-Providers encapsulate the operations of infrastructure components such as databases, web services, and file systems, presenting a unified interface to the application. This setup not only simplifies the codebase but also enhances its testability, maintainability, and scalability.
+In ExpressoTS, providers act as modular components that encapsulate specific functionalities, such as email services, authentication, or database connections.
+This approach supports a loosely coupled architecture, allowing you to update or swap out these functionalities without impacting the rest of the system.
 
 ### Key advantages
 
@@ -20,36 +21,39 @@ Providers encapsulate the operations of infrastructure components such as databa
 ExpressoTS harnesses providers to augment application capabilities, facilitating functionalities like email dispatching, data storage, and more, without tying the application logic to specific implementations.
 :::
 
-## Implementing a provider: An email service example
+## Create a provider
 
-Consider an application needing to send emails under various circumstances, such as user registration or password recovery. By implementing an email provider, ExpressoTS can send emails without directly interacting with the mailing service in the business logic.
+Consider an application needing to send emails under various circumstances, such as user registration or password recovery.
+By implementing an email provider, ExpressoTS can send emails without directly interacting with the mailing service in the business logic.
 
-### Setting up the provider
+In this example we will create a `MailSenderProvider` to send emails using the `nodemailer` library.
 
-First, run the CLI command to scaffold a new provider in your ExpressoTS project:
+Let's use the CLI to scaffold a new provider named `MailSenderProvider`:
 
 ```bash
-expressots g p mailtrap
+expressots g p mailSender
 ```
 
+#### Setting up the provider
+
 The CLI will add the suffix `Provider` to the provider name, creating a new file in the `providers` directory. This file will contain the provider class, which you can then customize to suit your application's needs.
 
 Here is the default provider file generated by the CLI:
 
 ```typescript
-import { provide } from "inversify-binding-decorators";
+import { provide } from "@expressots/core";
 
-@provide(MailTrapProvider)
-class MailTrapProvider {}
+@provide(MailSenderProvider)
+class MailSenderProvider {}
 ```
 
-### Implementing the provider
+#### Implementing the provider
 
 ```typescript
 import nodemailer from "nodemailer";
 import Mail from "nodemailer/lib/mailer";
 
-const enum EmailType {
+export const enum EmailType {
     Welcome = 0,
     CreateUser,
     ChangePassword,
@@ -57,8 +61,8 @@ const enum EmailType {
     RecoveryPassword,
 }
 
-@provide(MailTrapProvider)
-class MailTrapProvider {
+@provide(MailSenderProvider)
+export class MailSenderProvider {
     private transporter: Mail;
 
     constructor() {
@@ -114,20 +118,19 @@ class MailTrapProvider {
         }
     }
 }
-
-export { MailTrapProvider, EmailType };
 ```
 
-This `MailTrapProvider` abstracts the complexity of configuring and using nodemailer for email operations, providing a straightforward method sendEmail to send different types of emails.
+This `MailSenderProvider` abstracts the complexity of configuring and using nodemailer for email operations,
+providing a straightforward method sendEmail to send different types of emails.
 
-### Consuming the provider in a use case
+## Using the provider
 
-Here is the use case implementation making use of the mailtrap provider:
+Here is the use case implementation making use of the `MailSenderProvider` provider:
 
-```typescript
+```typescript title=" User sending email if login fails"
 @provide(LoginUserUseCase)
-class LoginUserUseCase {
-    constructor(private mailTrapProvider?: MailTrapProvider) {}
+export class LoginUserUseCase {
+    constructor(private mailSender: MailSenderProvider) {}
 
     execute(payload: ILoginUserRequestDTO): boolean {
         const { email, password } = payload;
@@ -136,61 +139,59 @@ class LoginUserUseCase {
             return true;
         }
 
-        // Implementation of the use case logic
-        mailTrapProvider?.sendEmail(EmailType.Login);
+        mailSender.sendEmail(EmailType.Login);
 
         return false;
     }
 }
-
-export { LoginUserUseCase };
 ```
 
-In this use case, the `MailTrapProvider` is injected through the constructor, leveraging ExpressoTS's dependency injection. This decouples the email sending process from the authentication logic, illustrating the provider's role in maintaining clean and maintainable code.
+In this use case, the `MailSenderProvider` is injected through the constructor, leveraging ExpressoTS's dependency injection.
+This decouples the email sending process from the authentication logic, illustrating the provider's role in maintaining clean and maintainable code.
 
-## Available providers in ExpressoTS
+## Decorators for provider
 
-ExpressoTS offers built-in providers for common functionalities, further extending the application's capabilities:
+ExpressoTS facilitates the registration of providers in its dependency injection system through the use of fluent decorators:
 
-| Provider Name | Description                         |
-| ------------- | ----------------------------------- |
-| envValidator  | Validate the environment variables. |
-| logger        | Add logger to the application.      |
+-   @provide (default scope is request)
+-   @provideSingleton (singleton scope)
+-   @provideTransient (transient scope)
 
-Providers are essential for building scalable, maintainable applications with ExpressoTS, emphasizing clean architecture and separation of concerns.
+These decorators ensure that providers are automatically registered and resolved within the application's dependency injection system.
 
-## Automatic registration with fluent decorators
+## External providers
 
-ExpressoTS facilitates the registration of providers in its dependency injection system through the use of fluent decorators:
+ExpressoTS promotes extensibility through the use of external providers. Developers can create reusable packages using the plugin design pattern to add new functionalities to an ExpressoTS application. This approach is ideal for sharing features across multiple projects or integrating third-party services.
 
--   @provide
--   @provideSingleton
--   @provideTransient
+The goal is to keep the core framework lean while enabling developers to extend their applications' capabilities with external providers.
 
-These decorators ensure that providers are automatically registered, streamlining their integration and reducing boilerplate.
+## Plugin pattern
 
-## Creating and registering an external provider
+The diagram illustrates the ExpressoTS plugin design pattern, demonstrating how external providers are seamlessly integrated into the client application
+through the Provider Manager.
 
-ExpressoTS encourages extensibility through the use of external providers. Developers can create reusable packages, following the plugin design pattern, to introduce new functionalities into an ExpressoTS application. This is particularly useful for features that need to be shared across multiple projects or for integrating third-party services.
+It showcases the process of registering new providers and their respective lifecycle scopes, which can be singleton, request, or scoped.
 
-### Creating an external provider
+<div style={{ textAlign: "center" }}>
+    <img src={pluginPatternImg} alt="Plugin pattern" />
+</div>
 
-An external provider should be a CommonJS package implementing the IProvider interface:
+## Create external provider
 
-```typescript
-import { IProvider } from "expressots";
+The CLI can be used to scaffold a new external provider ( plugin ). Here's the command:
 
-@injectable()
-class Logger implements IProvider {
-    log(message: string): void {
-        console.log(message);
-    }
-}
+```bash
+expressots create provider-name
 ```
 
-Interface `IProvider`:
+This command generates a new directory with the provider's name and all the necessary files to start developing an external provider.
+The generated `package.json` file includes scripts for building, testing, and publishing the package.
 
-```typescript
+An external provider should be a CommonJS package that meets the following requirements:
+
+1. Implement the `IProvider` interface in your provider class.
+
+```typescript title="IProvider interface"
 export interface IProvider {
     name: string;
     version: string;
@@ -199,13 +200,28 @@ export interface IProvider {
 }
 ```
 
+2. Annotate your provider class with the `@injectable()` decorator for dependency injection.
+3. Export your provider class in the `index.ts` file.
+4. Publish your package to the npm registry.
+
+```typescript title="Example of a Logger provider"
+import { IProvider } from "expressots";
+
+@injectable()
+class Logger implements IProvider {
+    log(message: string): void {
+        console.log(message);
+    }
+}
+```
+
 Once the package is developed and published to the npm registry, it can be easily integrated into any ExpressoTS application.
 
-### Registering Providers at Runtime
+## Using external providers
 
-Providers are registered in the `App` class of an ExpressoTS application using the `ProviderManager`. The `@injectable` decorator from InversifyJS makes the provider available for registration and resolution within the app's dependency injection system.
+Providers are registered in the `App` class of an ExpressoTS application using the `ProviderManager`.
 
-```typescript
+```typescript title="Registering external Logger provider in the App class"
 @provide(App)
 export class App extends AppExpress {
     private provider: ProviderManager;
@@ -216,35 +232,24 @@ export class App extends AppExpress {
     }
 
     protected configureServices(): void {
-        // Registering core and external providers
         this.provider.register(Logger);
     }
-
-    protected postServerInitialization(): void {}
-
-    protected serverShutdown(): void {}
 }
 ```
 
 :::info
-By default provider registration binds the provider as request-scoped. To change the scope, use the `BindingScopeEnum`.
+By default provider registration binds the provider as request-scoped. To change the scope, use the `BindingScopeEnum` or string representation of the scope.
 :::
 
 Example of registering a provider as a singleton:
 
 ```typescript
-this.provider.register(Logger, BindingScopeEnum.Singleton);
+this.provider.register(Logger, "Singleton");
 ```
 
-This process grants the flexibility to enhance the application at runtime by integrating additional providers, enabling dynamic scaling and extension of the application's capabilities.
-
-## Visualizing the plugin design pattern
+Adding external providers to an ExpressoTS application is a straightforward process that enhances the application's capabilities without bloating the core framework.
 
-The diagram illustrates the ExpressoTS plugin design pattern, demonstrating how external providers are seamlessly integrated into the client application through the Provider Manager. It showcases the process of registering new providers and their respective lifecycle scopes, which can be singleton, request, or scoped.
-
-![Plugin Design Pattern](./img/plugin-pattern.png)
-
-## Recommendations for using external providers
+## External provider best practices
 
 When developing external providers for ExpressoTS, consider the following best practices:
 
@@ -252,18 +257,13 @@ When developing external providers for ExpressoTS, consider the following best p
 -   **Lifecycle Management**: Choose the appropriate scope for the provider based on its intended usage pattern.
 -   **Testing**: Thoroughly test providers in isolation before integrating them into the main application.
 -   **Documentation**: Provide detailed usage instructions and configuration options for the external provider.
+-   **Versioning**: Follow semantic versioning practices to manage changes and updates to the provider.
+-   **Error Handling**: Implement robust error handling and logging mechanisms to ensure the provider's reliability.
+-   **Security**: Follow security best practices to protect sensitive data and prevent vulnerabilities in the provider, especially in the provider dependencies.
 
 By adhering to these practices, developers can ensure that their external providers are robust, maintainable, and easily integrated into any ExpressoTS application.
 
----
-
-## Support the project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
+## Support us ❤️
 
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/core/usecase.mdx b/docs/core/usecase.mdx
new file mode 100644
index 00000000..8fe16cb0
--- /dev/null
+++ b/docs/core/usecase.mdx
@@ -0,0 +1,114 @@
+---
+sidebar_position: 5
+title: Use cases
+description: Use cases represents the business logic of the application.
+---
+
+import usecaseIMG from "./img/usecase.png";
+
+# Use cases
+
+From a UML perspective, use cases model interactions between users, systems, and an application, outlining specific scenarios and outcomes.
+In ExpressoTS, use cases encapsulate business logic, clearly separating it from controllers, which handle
+routing and request management. This keeps the core functionality and business rules distinct from request handling.
+
+While you can use any design pattern, such as **[MVC](./controller.mdx#patterns)**, the ExpressoTS opinionated template emphasizes
+the use of a clean architecture. We believe this approach leads to more maintainable and scalable applications.
+
+## Case study
+
+Here is an example of a use case diagram for a project x:
+
+<div style={{ textAlign: "center" }}>
+    <img src={usecaseIMG} alt="Project X Use Case" />
+</div>
+
+In the use case diagram above, the actor represents the user interacting with the system. To execute the Login use case, the user must provide specific information known as the payload or, in the case of ExpressoTS, the request DTO. This information is necessary to trigger the use case and for the system to deliver the desired outcome.
+
+:::info
+It is important to note that the use case should exclusively contain the business logic of the application, with no additional or unrelated functionalities.
+This approach helps to ensure a clear separation of concerns, promoting maintainability, and scalability of the system.
+:::
+
+## Create use case
+
+You can create use cases using the ExpressoTS CLI. To create a new use case, run the following command:
+
+```bash
+expressots g u use-case-name
+```
+
+Here is a simple implementation of the use case:
+
+```typescript title="Login User Use Case"
+@provide(LoginUserUseCase)
+class LoginUserUseCase {
+    execute(payload: ILoginUserRequestDTO): boolean {
+        const { email, password } = payload;
+
+        if (isAuthenticated(email, password)) {
+            return true;
+        }
+
+        return false;
+    }
+}
+
+export { LoginUserUseCase };
+```
+
+## Explanation
+
+The implementation of use cases in ExpressoTS follows the best practices of software design, where each use case is responsible for implementing a specific business logic. As shown in the example code snippet, a use case typically contains only one function, called execute, which is responsible for executing the business logic defined in that use case. The use case may also include a response DTO that defines the format of the response for that particular use case.
+
+Also, it is common to use constructors in use cases to inject dependencies such as providers and repositories. This allows for better code modularity and testability.
+
+## Injection
+
+ExpressoTS's **[Dependency Injection](./di.mdx)** system allows you to inject dependencies like providers, repositories, entities,
+or helper classes directly into use cases via constructors or properties. This enhances modularity and makes the code more testable.
+
+See examples below:
+
+## Constructor Injection
+
+```typescript title="Example of constructor injection in a use case"
+@provide(ExampleUseCase)
+class ExampleUseCase {
+    constructor(private email: EmailProvider, private repo: RepositoryProvider) {}
+
+    execute() {
+        this.email.foo();
+        this.repo.bar();
+    }
+}
+```
+
+## Property Injection
+
+```typescript title="Example of property injection in a use case"
+@provide(ExampleUseCase)
+class ExampleUseCase {
+    @inject(EmailProvider)
+    private email: EmailProvider;
+
+    @inject(RepositoryProvider)
+    private repo: RepositoryProvider;
+
+    execute() {
+        this.email.foo();
+        this.repo.bar();
+    }
+}
+```
+
+:::tip
+It is important to adhere to the principle of single responsibility when implementing use cases. Each use case should only handle a specific business logic, and if you find yourself implementing multiple use cases in a single class, it is time to review your implementation to ensure that each use case has a clear and concise responsibility.
+:::
+
+---
+
+## Support us ❤️
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/features/_category_.json b/docs/features/_category_.json
new file mode 100644
index 00000000..465cf131
--- /dev/null
+++ b/docs/features/_category_.json
@@ -0,0 +1,8 @@
+{
+    "label": "FEATURES",
+    "position": 2,
+    "link": {
+        "type": "generated-index",
+        "description": "ExpressoTS Features."
+    }
+}
diff --git a/docs/overview/decorators.md b/docs/features/decorators.mdx
similarity index 51%
rename from docs/overview/decorators.md
rename to docs/features/decorators.mdx
index f6dbf4ec..9a58d691 100644
--- a/docs/overview/decorators.md
+++ b/docs/features/decorators.mdx
@@ -1,12 +1,25 @@
 ---
-sidebar_position: 11
+sidebar_position: 1
+title: Decorators
+description: Decorators extends framework functionality.
 ---
 
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+
 # Decorators
 
+Decorators are a feature of TypeScript and are used to extend the functionality of a class or method adding metadata to them.
+ExpressoTS uses decorators to refine the user experience and make the code more readable and maintainable.
+
+## List of decorators
+
 Here is a complete list of all decorators available in ExpressoTS as well as a brief description of what they do.
 
-## Class Decorators
+<Tabs>
+    <TabItem label="Class" value="class">
+
+#### Class Decorators
 
 Decorators available for your classes.
 
@@ -18,31 +31,43 @@ Decorators available for your classes.
 | @injectable       | Marks a class as available to be injected.                                     |
 | @inject           | Marks a class as available to be injected in the constructor of another class. |
 
-## Controller Decorators
+    </TabItem>
+    <TabItem label="Controller" value="controller">
+
+#### Controller Decorators
 
 Decorators available for your controllers.
 
-| Decorator   | Description                    | Usage example                                                |
-| ----------- | ------------------------------ | ------------------------------------------------------------ |
-| @controller | Marks a class as a controller. | @controller("/path", middleware[])                           |
-| @scope      | Binds a controller to a scope. | @scope(BindingScopeEnum.Singleton, or Request, or Transient) |
+| Decorator   | Description                    | Usage example                     |
+| ----------- | ------------------------------ | --------------------------------- |
+| @controller | Marks a class as a controller. | @controller("/path", middlewares) |
+| @scope      | Binds a controller to a scope. | @scope("Scope")                   |
 
-### HTTP Method Decorators
+    </TabItem>
+    <TabItem label="Method" value="method">
 
-Decorators available for your controller methods.
+#### Method Decorators
 
-| Decorator | Description                                         | Usage                    |
-| --------- | --------------------------------------------------- | ------------------------ |
-| @Get      | Binds a controller method to a GET HTTP verb.       | @Get("/path")            |
-| @Post     | Binds a controller method to a POST HTTP verb.      | @Post("/path")           |
-| @Put      | Binds a controller method to a PUT HTTP verb.       | @Put("/path")            |
-| @Patch    | Binds a controller method to a PATCH HTTP verb.     | @Patch("/path")          |
-| @Head     | Binds a controller method to a HEAD HTTP verb.      | @Head("/path")           |
-| @Delete   | Binds a controller method to a DELETE HTTP verb.    | @Delete("/path")         |
-| @Method   | Binds a controller method to a specified HTTP verb. | @Method("verb", "/path") |
-| @Http     | Sets the HTTP status code for the response.         | @Http(200)               |
+Decorators available for your controller methods.
 
-### Parameter Decorators
+| Decorator   | Description                                           | Usage                                        |
+| ----------- | ----------------------------------------------------- | -------------------------------------------- |
+| @Get        | Binds a controller method to a GET HTTP verb.         | @Get("/path", "/middlewares")                |
+| @Post       | Binds a controller method to a POST HTTP verb.        | @Post("/path", "/middlewares")               |
+| @Put        | Binds a controller method to a PUT HTTP verb.         | @Put("/path", "/middlewares")                |
+| @Patch      | Binds a controller method to a PATCH HTTP verb.       | @Patch("/path", "/middlewares")              |
+| @Head       | Binds a controller method to a HEAD HTTP verb.        | @Head("/path", "/middlewares")               |
+| @Delete     | Binds a controller method to a DELETE HTTP verb.      | @Delete("/path", "/middlewares")             |
+| @Method     | Binds a controller method to a specified HTTP verb.   | @Method("verb", "/path", "/middlewares")     |
+| @Http       | Sets the HTTP status code for the response.           | @Http(200)                                   |
+| @FileUpload | Injects the file upload object for multer middleware. | @FileUpload('fieldOptions', "multerOptions") |
+| @Render     | Renders a view using the specified view engine.       | @Render("view", data )                       |
+| @All        | Binds a controller method to all HTTP verbs.          | @All("/path", "/middlewares")                |
+
+        </TabItem>
+        <TabItem label="Parameter" value="parameter">
+
+#### Parameter Decorators
 
 Here is a list of all parameter decorators available in ExpressoTS, along with their description and usage:
 
@@ -57,15 +82,16 @@ Here is a list of all parameter decorators available in ExpressoTS, along with t
 | @cookies(cookieName?: string) | Injects a cookie from the request cookies.             | execute(@cookies('session') session: string)     |
 | @next()                       | Injects the Express NextFunction object.               | execute(@next() next: NextFunction)              |
 
----
+        </TabItem>
+        </Tabs>
 
-## Support the Project
+:::info
+In a future release, we will add the capability to create custom decorators.
+:::
+
+---
 
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
+## Support us ❤️
 
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star тнР the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/features/dto-validator.mdx b/docs/features/dto-validator.mdx
new file mode 100644
index 00000000..1f2c52e6
--- /dev/null
+++ b/docs/features/dto-validator.mdx
@@ -0,0 +1,107 @@
+---
+sidebar_position: 7
+title: DTO validator
+description: DTO validator provider.
+---
+
+# Payload
+
+A payload in a web application refers to the data sent between the client and server, typically within a request body. This data is essential for performing operations like creating, updating, or retrieving resources. Payloads contain the information that the server needs to process a request and return an appropriate response.
+
+## DTO pattern
+
+The Data Transfer Object (DTO) pattern is used to standardize the structure of this payload data as it moves between different layers of the application. DTOs ensure that the data being transferred adheres to specific formats, making it easier to manage and validate. By separating the data structure from business logic, DTOs help keep the application modular, maintainable, and less prone to errors.
+
+## DTO validator
+
+The DTO Validator in ExpressoTS plays a critical role in ensuring the integrity of incoming payloads. This provider validates the data sent by the client, checking for required fields, data types, and overall consistency. By doing so, it helps developers avoid runtime errors that could occur due to missing or invalid data.
+
+When you scaffold a new ExpressoTS project, the DTO Validator is included as middleware named validateDTO. This middleware can be applied to any endpoint to automatically validate incoming data against the defined DTO structure before the request is processed further. This validation step ensures that only well-formed, valid data enters your application's processing pipeline, enhancing reliability and security.
+
+## Pre requisites
+
+The DTO validator is based on the [class-validator](https://www.npmjs.com/package/class-validator) and [class-transformer](https://www.npmjs.com/package/class-transformer) packages. It uses decorators to validate the DTOs.
+
+:::caution
+If you don't have class-validator and class-transformer installed and try to use the DTO validator, you will get an warning message in the console mentioning that you need to install the packages.
+:::
+
+Another key point is that the DTO Validator works exclusively with classes, as interfaces do not exist at runtime. Therefore, if you want to use the DTO Validator, you'll need to change the interface provided by ExpressoTS to a class that represents your DTO instead. This allows the validator to properly validate the incoming data, ensuring it adheres to the defined structure.
+
+## Usage example
+
+You can use the DTO validator in any endpoint by adding the `validateDTO` middleware in the endpoint route.
+
+Endpoint that creates a new user:
+
+```typescript
+@httpPost("/", ValidateDTO(CreateUserDTO))
+execute(@requestBody() payload: CreateUserDTO, @response() res: Response) {
+  return res.status(StatusCode.Created).json(this.createUserUseCase.execute(payload));
+}
+```
+
+Here it is the `CreateUserDTO` class:
+
+```typescript
+import { IsEmail, IsNotEmpty, MinLength } from "class-validator";
+
+class CreateUserDTO {
+    @IsNotEmpty()
+    @MinLength(10)
+    name: string;
+    @IsNotEmpty()
+    @IsEmail({}, { message: "Invalid email" })
+    email: string;
+}
+
+export { CreateUserDTO };
+```
+
+:::info
+For more information about the decorators, please check the [class-validator](https://www.npmjs.com/package/class-validator) package.
+:::
+
+## Error messages
+
+If you submit a payload that doesn't match the DTO `CreateUserDTO` above, the DTO validator will return an error message with the following format:
+
+**Payload:**
+
+```json title="Invalid payload"
+{
+    "name": "",
+    "email": ""
+}
+```
+
+**Response:**
+
+```json
+{
+    "errorCode": 400,
+    "errorMessage": "Bad Request",
+    "DTO": [
+        {
+            "property": "name",
+            "messages": [
+                "name must be longer than or equal to 10 characters",
+                "name should not be empty"
+            ]
+        },
+        {
+            "property": "email",
+            "messages": ["invalid email", "email should not be empty"]
+        }
+    ]
+}
+```
+
+Messages are split by property, so you can easily identify which property has an error and what is the error message. This is useful when you have a DTO with a lot of properties, as you can easily identify which property has an error. It also helps the frontend application on getting the error messages more easily.
+
+---
+
+## Support us ❤️
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/features/envvalidator.mdx b/docs/features/envvalidator.mdx
new file mode 100644
index 00000000..bea06691
--- /dev/null
+++ b/docs/features/envvalidator.mdx
@@ -0,0 +1,76 @@
+---
+sidebar_position: 8
+title: Env validator
+description: Validates the existence of the .env file and its content.
+---
+
+# Environment validator
+
+The environment validator provider is used to validate the existence of the `.env` file and its content.
+It helps the developer to avoid runtime errors caused by missing environment variables.
+
+## Setup
+
+To use the environment validator provider, you need to make sure it is registered in the `configureServices()` method of the `App` class.
+Once registered, the provider will be available in the application through the DI Container.
+
+```ts
+    protected configureServices(): void | Promise<void> {
+        this.provider.register(Env);
+    }
+```
+
+## Method checkAll
+
+The `checkAll()` method is used to validate the existence of the `.env` file and its content by checking if all the environment variables are defined.
+
+You can define from where to call the `checkAll()` method. It can be called in the `postServerInitialization()` method or in any other method that you prefer.
+
+```ts
+    protected postServerInitialization(): void | Promise<void> {
+        if (this.isDevelopment()) {
+            this.provider.get(Env).checkAll();
+        }
+    }
+```
+
+If the `.env` file is missing or if any environment variable is not defined, the `checkAll()` method will throw an error with a message indicating the missing environment variables.
+
+```bash title="PORT environment variable is missing"
+[PID:26759] ERROR [env-validator-provider] Environment variable PORT is not defined.
+```
+
+## Method get
+
+The environment validator provider also has a method called `get()` that returns the value of an environment variable. It is used to get a specific environment variable value passing its name as a parameter.
+
+```typescript
+this.provider.get(Env).get("PORT");
+```
+
+## Using everywhere
+
+You can use the `Env` provider in any class by injecting it into the constructor of your usecase, service, provider, controller or any other class.
+
+```typescript
+import { Get, controller } from "@expressots/adapter-express";
+import { Env } from "@expressots/core";
+
+@controller("/")
+export class AppController {
+    constructor(private env: Env) {}
+
+    @Get("/")
+    execute(): string {
+        console.log(this.env.get("PORT"));
+        return "Hello from Expressots!";
+    }
+}
+```
+
+---
+
+## Support us ❤️
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/overview/error-handling.md b/docs/features/error-handling.mdx
similarity index 53%
rename from docs/overview/error-handling.md
rename to docs/features/error-handling.mdx
index 6a34b847..b0f8ff7a 100644
--- a/docs/overview/error-handling.md
+++ b/docs/features/error-handling.mdx
@@ -1,12 +1,14 @@
 ---
-sidebar_position: 15
+sidebar_position: 3
+title: Error handling
+description: Error handling in ExpressoTS APIs.
 ---
 
-# Error Handling
+# Error handling
 
 When it comes to error handling in Node.js TypeScript APIs, there are several best practices and approaches you can follow. ExpressoTS provides a simple and easy way to handle errors.
 
--   We use HTTP status codes appropriately: HTTP **[status codes](./status-code.md)** are used to indicate the status of a response. It is important to use them appropriately in your API to indicate the success or failure of an operation.
+-   We use HTTP status codes appropriately: HTTP **[status codes](./status-code.mdx)** are used to indicate the status of a response. It is important to use them appropriately in your API to indicate the success or failure of an operation.
 
 -   We use a consistent error format: Define a consistent error format across your API so that consumers can easily understand and handle errors.
 
@@ -21,27 +23,30 @@ When it comes to error handling in Node.js TypeScript APIs, there are several be
 ## Our approach
 
 We developed a standardized error reporting class called `Report` that provides a centralized location for throwing and handling errors, which can simplify error handling throughout the application.
-
 By defining a standard error response format, it helps to ensure consistency in error messages that are returned to clients.
 
-This approach is best used in applications with a large codebase or complex business logic, where errors may occur frequently and need to be handled consistently across different parts of the application.
+## Components
+
+Here are the components that we use to handle errors in ExpressoTS:
+
+| Object        | Description                                                             |
+| ------------- | ----------------------------------------------------------------------- |
+| Report.Error  | Method to report known errors.                                          |
+| AppError      | App Error class that defines error object format.                       |
+| StatusCode    | Http responses code and message.                                        |
+| Error Message | Error message detail that the developer wants to log.                   |
+| Error Service | To be used in the log system to indicate where the error was generated. |
 
-### Report error
+#### Report
 
 Report class is a utility class to manage and throw application-specific errors.
 
-```typescript
+```typescript title="Report class"
 class Report {
   /**
-   * The Error method is responsible for generating a standardized error object,
-   * logging the error, and then throwing it for further handling.
-   * The error thrown is of the custom type AppError, which extends the built-in Error class.
-   *
    * @param error - An instance of Error or a string that describes the error.
    * @param statusCode - The HTTP status code associated with the error (default is 500).
-   * @param service - The service name associated with the error. If not specified,
-   *                  it defaults to the name of the calling function.
-   *
+   * @param service - The service name associated with the error.
    * @throws An object of the custom type AppError, which includes details about the error.
    */
   public Error(
@@ -54,29 +59,18 @@ class Report {
 
 Once you report a known error through the `Report.Error()` method, the error will be handled by the `defaultErrorHandler()` middleware and will be returned to the client in the json parsed format.
 
-### Middleware
+#### Middleware
 
 This middleware function is used to handle errors that occur during request processing.
 
-```typescript
-/**
- * errorHandler is a custom Express error-handling middleware function.
- * It logs the error, sets the status code, and sends a JSON response containing the status code and error message.
- * @param error - An instance of IAppError containing error details.
- * @param req - The Express request object.
- * @param res - The Express response object.
- * @param next - The Express next function for passing control to the next middleware function.
- */
-function defaultErrorHandler(error: Error, req: Request, res: Response, next: NextFunction): void {
-    if (error instanceof AppError) {
-        res.status(error.statusCode).json({ statusCode: error.statusCode, error: error.message });
-    } else {
-        res.status(StatusCode.InternalServerError).json({
-            statusCode: StatusCode.InternalServerError,
-            error: "An unexpected error occurred.",
-        });
-    }
-}
+```typescript title="defaultErrorHandler middleware"
+function defaultErrorHandler(
+    error: Error,
+    req: Request,
+    res: Response,
+    next: NextFunction,
+    showStackTrace: boolean = false
+): void {}
 
 export default defaultErrorHandler;
 ```
@@ -86,9 +80,54 @@ function `defaultErrorHandler()` is a custom Express error-handling middleware f
 It logs the error, sets the status code, and sends a JSON response containing the status code and error message.
 :::
 
-## Example of use
+## App provider error handling
+
+When a project is created using the ExpressoTS CLI, the default error handling is already set up in the project structure.
+
+```typescript title="App provider error handling"
+export class App extends AppExpress {
+    private middleware: IMiddleware;
+    private provider: ProviderManager;
+
+    constructor() {
+        super();
+        this.middleware = container.get<IMiddleware>(Middleware);
+        this.provider = container.get(ProviderManager);
+    }
+
+    protected configureServices(): void | Promise<void> {
+        this.middleware.setErrorHandler();
+    }
+
+    protected postServerInitialization(): void | Promise<void> {}
+
+    protected serverShutdown(): void | Promise<void> {}
+}
+```
+
+The `setErrorHandler()` method is used to set up the error handling middleware in the application. It allows ExpressoTS to handle errors in a centralized location as well as to send
+a consistent error response to the client in a JSON format.
+
+You can also pass two optional parameters to the `setErrorHandler()` method:
+
+-   `showStackTrace`: A boolean value that indicates whether to show the stack trace in the error response. The default value is `false`.
+-   `customErrorHandler`: A custom error handler function that can be used to handle errors in a specific way. The default value is defaultErrorHandler.
+
+```typescript title="Using your own error handler"
+this.middleware.setErrorHandler({ errorHandler: myErrorHandler });
+```
+
+```typescript title="Using showStackTrace in the default error handler"
+this.middleware.setErrorHandler({ showStackTrace: true });
+```
+
+:::info
+In the `showStackTrace` example, the error response will include a formated stack trace message. We tried to make stack trace messages more readable and easy to understand.
+:::
 
-```typescript
+## Usage example
+
+```typescript title="Using Report class"
 class FooClass {
     constructor(private report: Report) {}
 
@@ -104,7 +143,7 @@ class FooClass {
 
 Use case example:
 
-```typescript
+```typescript title="Use case example"
 @provide(CreateUserUseCase)
 class CreateUserUseCase {
     constructor(private userRepository: UserRepository, private report: Report) {}
@@ -145,25 +184,61 @@ class CreateUserUseCase {
 }
 ```
 
-## Error components description
+You can also throw the this.report.Error() method directly:
 
-| Object        | Description                                                             |
-| ------------- | ----------------------------------------------------------------------- |
-| Report.Error  | Method to report known errors.                                          |
-| AppError      | App Error class that defines error object format.                       |
-| StatusCode    | Http responses code and message.                                        |
-| Error Message | Error message detail that the developer wants to log.                   |
-| Error Service | To be used in the log system to indicate where the error was generated. |
+```typescript title="Throw using this.report.Error()"
+@provide(CreateUserUseCase)
+class CreateUserUseCase {
+    constructor(private userRepository: UserRepository, private report: Report) {}
 
----
+    execute(data: ICreateUserRequestDTO): ICreateUserResponseDTO | null {
+        const { name, email } = data;
+
+        const userAlreadyExists = await this.userRepository.findByEmail(email);
+
+        if (userAlreadyExists) {
+            throw this.report.Error(
+                "User already exists",
+                StatusCode.BadRequest,
+                "create-user-usecase"
+            );
+        }
 
-## Support the project
+        const user: User | null = this.userRepository.create(new User(name, email));
+
+        let response: ICreateUserResponseDTO;
+
+        if (user !== null) {
+            response = {
+                id: user.Id,
+                name: user.name,
+                email: user.email,
+                status: "success",
+            };
+            return response;
+        }
+
+        return null;
+    }
+}
+```
+
+This error will be handled by the `defaultErrorHandler()` middleware and will be returned to the client in the json parsed format via request response as well as logged in the console.
+
+```json title="Error response"
+{
+    "statusCode": 400,
+    "error": "User already exists"
+}
+```
+
+```bash title="Console log"
+[ExpressoTS] 00/00/0000 00:00:00 PM [PID:00000] ERROR [app-controller] This is an error message
+```
+
+---
 
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
+## Support us ❤️
 
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/overview/expressots-config.md b/docs/features/expressots-config.mdx
similarity index 68%
rename from docs/overview/expressots-config.md
rename to docs/features/expressots-config.mdx
index 50af7c92..cfe605a1 100644
--- a/docs/overview/expressots-config.md
+++ b/docs/features/expressots-config.mdx
@@ -1,14 +1,17 @@
 ---
-sidebar_position: 18
+sidebar_position: 6
+title: ExpressoTS config
+description: ExpressoTS configuration file.
 ---
 
-# ExpressoTS Config File
+# Global config file
 
-The ExpressoTS configuration file is located in the root folder of the project and it's called `expressots.config.ts`. This file is used to configure the CLI and the project.
+The ExpressoTS configuration file is located in the root folder of the project and it's called `expressots.config.ts`.
+This file is used to configure the CLI and the project behavior.
 
 Here is the current configuration file with all the available options:
 
-```typescript
+```typescript title="expressots.config.ts"
 import { ExpressoConfig, Pattern } from "@expressots/core";
 
 const config: ExpressoConfig = {
@@ -29,6 +32,8 @@ const config: ExpressoConfig = {
 export default config;
 ```
 
+## Configuration options
+
 -   **sourceRoot**: the root folder that will be used by the CLI to create the resources. Default: `src`
 
 -   **scaffoldPattern**: the pattern that will be used to create the resources. Default: `Pattern.KEBAB_CASE`. Example: `user-create`
@@ -47,17 +52,7 @@ Try to use as many different forms of creating resources as possible. This will
 
 ---
 
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
+## Support us ❤️
 
-```
-
-```
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/features/in-memory-db.mdx b/docs/features/in-memory-db.mdx
new file mode 100644
index 00000000..bc925f4d
--- /dev/null
+++ b/docs/features/in-memory-db.mdx
@@ -0,0 +1,175 @@
+---
+sidebar_position: 9
+title: DB in memory
+description: A simple in memory database to store data.
+---
+
+# In memory DB
+
+<span class="span-table">In-memory-db</span> is a provider that uses a simple in memory database to store
+data. It is a class that can be registered in the ExpressoTS dependency injection system as a singleton.
+
+```ts
+this.provider.register(InMemoryDB, "Singleton");
+```
+
+The `InMemoryDB` class provides a simple and efficient way to simulate a database entirely in-memory, which can be particularly useful for testing and rapid development where a full-fledged database might be overkill.
+
+## DB inspector
+
+The `InMemoryDB` class have the ability to print tables to the console. This feature is particularly useful for debugging and testing purposes. It can also be used to quickly inspect the contents of a table.
+
+The table content will be printed to the console every time the repository is used by any endpoint that have operations that read or write to the database.
+
+Here is an image showing the output in the console of the `InMemoryDB` when we create a new user:
+
+![Application Overview](../core/img/inMemoryDB.png)
+
+:::info
+The DB inspector is enabled by default. As soon as you create a new entity and extend the BaseRepository class, the InMemoryDB will print the table to the console.
+:::
+
+## Register InMemoryDB
+
+To use the `InMemoryDB` class, you need to import it from the `@expressots/core` package and register it as a singleton in the dependency injection system. Here is an example of how to do this in a service class:
+
+```typescript
+import { InMemoryDB } from "@expressots/core";
+
+export class App extends AppExpress {
+    private middleware: IMiddleware;
+    private provider: ProviderManager;
+
+    constructor() {
+        super();
+        this.middleware = container.get<IMiddleware>(Middleware);
+        this.provider = container.get(ProviderManager);
+    }
+
+    protected configureServices(): void {
+        this.provider.register(InMemoryDB, "Singleton");
+    }
+}
+```
+
+When registering the `InMemoryDB` class, you can specify the scope as `string` or using the `BindingScopeEnum`.
+
+## Create an entity
+
+Create an entity to represent the data that will be stored in the database. The entity class should have properties that represent the fields of the data that will be stored in the database.
+
+```typescript
+@provide(UserEntity)
+export class UserEntity {
+    id: string;
+    name: string;
+    email: string;
+
+    constructor() {
+        this.id = randomUUID();
+    }
+}
+```
+
+## Repository pattern
+
+The repository pattern is a design pattern that abstracts the data access logic from the rest of the application. It provides a way to access and manipulate data in the database without exposing the details of the database to the rest of the application.
+
+Read more about the repository pattern in here: [Repositories](../guides/repositories.mdx).
+
+## Create a repository
+
+The repository is a class that extends the `BaseRepository` class and is used to manage entities of a specific type. The repository class is part of the dependency injection system and is marked by the @provide decorator.
+
+```typescript
+@provide(UserRepository)
+export class UserRepository extends BaseRepository<UserEntity> {
+    constructor() {
+        super("users");
+    }
+}
+```
+
+In the class above, we are creating a repository for the `UserEntity` class. The repository is initialized with the table name `users` in the constructor, as well as the entity class `UserEntity`.
+
+By extending the `BaseRepository` class, the `UserRepository` class inherits all the CRUD methods for managing entities in the database.
+
+## Define custom methods
+
+You can also define custom methods for the user repository.
+
+```typescript
+@provide(UserRepository)
+class UserRepository extends BaseRepository<UserEntity> {
+    constructor() {
+        super("users");
+    }
+
+    findByEmail(email: string): User | null {
+        const user = this.table.find((item) => item.email === email);
+        return user || null;
+    }
+}
+```
+
+## Usage in a use case
+
+You can inject the repository in the constructor or via property injection. Example:
+
+```typescript title="Injecting repository via property injection"
+@provide(UserCreateUseCase)
+export class UserCreateUseCase {
+    @inject(UserRepository)
+    private userRepo: UserRepository;
+
+    @inject(UserEntity)
+    private userEntity: UserEntity;
+
+    execute(payload: IUserCreateRequestDTO): IUserCreateResponseDTO {
+        this.userEntity.name = payload.name;
+        this.userEntity.email = payload.email;
+
+        this.userRepo.create(this.userEntity);
+
+        return {
+            id: this.userEntity.id,
+            name: this.userEntity.name,
+            email: this.userEntity.email,
+        };
+    }
+}
+```
+
+```typescript title="Injecting repository in the constructor"
+@provide(UserCreateUseCase)
+export class UserCreateUseCase {
+    constructor(private userEntity: UserEntity, private userRepo: UserRepository) {}
+
+    execute(payload: IUserCreateRequestDTO): IUserCreateResponseDTO {
+        this.userEntity.name = payload.name;
+        this.userEntity.email = payload.email;
+
+        this.userRepo.create(this.userEntity);
+
+        return {
+            id: this.userEntity.id,
+            name: this.userEntity.name,
+            email: this.userEntity.email,
+        };
+    }
+}
+```
+
+Once a request is made to the `UserCreateUseCase`:
+
+-   The `UserEntity` is populated with the request data.
+-   The entity is created in the database using the `UserRepository`.
+-   The response data is then returned to the client.
+-   The `InMemoryDB` will print the table to the console, showing the newly created entity.
+
+---
+
+## Support us ❤️
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/features/logging.mdx b/docs/features/logging.mdx
new file mode 100644
index 00000000..d6716f5f
--- /dev/null
+++ b/docs/features/logging.mdx
@@ -0,0 +1,78 @@
+---
+sidebar_position: 10
+title: Logger
+description: A simple way to log messages using native node modules.
+---
+
+# Logging
+
+Logger is a class that provides a set of methods to log messages using native node modules. It is a simple way to log messages in your application and it is already included in the ExpressoTS framework.
+
+Logger take two parameters:
+
+-   message: The message to be logged.
+-   module: The service name associated with the log.
+
+## Logger methods
+
+There are 4 methods available:
+
+```typescript title="Logger usage"
+log.<method>(message: string, module?: string);
+```
+
+-   **info**: Logs an informational message.
+-   **warn**: Logs a warning message.
+-   **error**: Logs an error message.
+-   **msg**: Logs a message.
+
+## Logger format
+
+Using `info()` method as an example, the logger format is:
+
+```
+[ExpressoTS] 00/00/0000 00:00:00 PM [PID:30319] INFO [app-controller] Hello from Expressots!
+```
+
+## Register logger in the container
+
+The logger is already included in the ExpressoTS framework but first you need to register it in the container. You can do this in the `configureServices` method of your application.
+
+```typescript
+export class App extends AppExpress {
+    private middleware: IMiddleware;
+    private provider: ProviderManager;
+
+    constructor() {
+        super();
+        this.middleware = container.get<IMiddleware>(Middleware);
+        this.provider = container.get(ProviderManager);
+    }
+
+    protected configureServices(): void | Promise<void> {
+        this.provider.register(Logger);
+    }
+}
+```
+
+## Usage example
+
+Once the logger is registered in the container, you can inject it into your services, controllers, use cases, etc.
+
+```typescript
+export class YourUseUseCase {
+    constructor(private log: Logger) {}
+
+    execute() {
+        this.log.info("Testing log message", "your-use-case");
+        return "Hello ExpressoTS!";
+    }
+}
+```
+
+---
+
+## Support us ❤️
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/features/middleware.mdx b/docs/features/middleware.mdx
new file mode 100644
index 00000000..49126a70
--- /dev/null
+++ b/docs/features/middleware.mdx
@@ -0,0 +1,218 @@
+---
+sidebar_position: 0
+title: Middleware
+description: Middleware are interceptors.
+---
+
+# Middleware
+
+Middlewares play a crucial role in the request-response cycle of an ExpressoTS application. They allow you to execute code, modify request and response objects, end the cycle, or pass control to the next middleware in the stack. To prevent request timeouts, it's important to call `next()` unless your middleware completes the cycle.
+
+ExpressoTS supports function and class-based middleware. Function-based middleware is the simplest form of middleware, while class-based middleware allows you to create reusable middleware with a constructor and methods.
+
+ExpressoTS integrates smoothly with Express middleware, allowing you to leverage its extensive ecosystem to enhance your application.
+
+:::note ExpressoTS fully supports [Express](https://expressjs.com/en/resources/middleware.html) middleware out-of-the-box.
+:::
+
+## Add middleware
+
+ExpressoTS application supports adding middleware globally to the application as well as per route. It offers all the middleware supported by [Expressjs](https://expressjs.com/en/resources/middleware.html) team out-of-the-box.
+
+In the `app.provider.ts` file, you can add middleware to the application using the `this.middleware` property. The `this.middleware` property is
+an instance of the `Middleware` class, which provides a list of out-of-the-box Expressjs middlewares supported by ExpressoTS.
+
+```ts title="Adding middleware globally to the application in app.provider.ts"
+@provide(App)
+export class App extends AppExpress {
+    private middleware: IMiddleware;
+
+    constructor() {
+        super();
+        this.middleware = container.get<IMiddleware>(Middleware);
+    }
+
+    protected configureServices(): void {
+        this.middleware.addBodyParser();
+        this.middleware.addCors();
+        this.middleware.addHelmet();
+    }
+}
+```
+
+In ExpressoTS, middleware options are available to be added as needed, but the actual middleware packages are not pre-installed to keep the application lightweight. When you choose to add one of the available out-of-the-box middleware options, such as CORS, the system checks if the necessary package is installed.
+
+If the middleware package isn't installed, the application will warn you with a message, but will continue running.
+
+```bash
+🖥️ Middleware [cors] not installed. Please install it using your package manager.
+```
+
+Once you install the required middleware, the warning will disappear on hot reload, and the middleware will be ready for use with its interface integrated into your application.
+
+## Out-of-the-box middleware
+
+Expressjs middlewares supported by ExpressoTS:
+
+| Middleware Name     | Description                                           |
+| ------------------- | ----------------------------------------------------- |
+| addBodyParser       | Add body parser middleware to the application.        |
+| addCompression      | Add compression middleware to the application.        |
+| addCookieParser     | Add cookie parser middleware to the application.      |
+| addCookieSession    | Add cookie session middleware to the application.     |
+| addCors             | Add cors middleware to the application.               |
+| addHelmet           | Add helmet middleware to the application.             |
+| addMorgan           | Add morgan middleware to the application.             |
+| addRateLimiter      | Add rate limit middleware to the application.         |
+| addServeFavicon     | Add serve favicon middleware to the application.      |
+| addSession          | Add session middleware to the application.            |
+| addUrlEncodedParser | Add url encoded parser middleware to the application. |
+| serverStatic        | Add static middleware to the application.             |
+| setupMulter         | Create a multer instance for file upload.             |
+| setErrorHandler     | Add error handler middleware to the application.      |
+
+:::caution
+If you add a middleware that is not installed as dependency, the application will throw a warning message and continue to run.
+:::
+
+## Using `addMiddleware` method
+
+For any other middleware, or a custom middleware, you can add it using the `this.middleware.addMiddleware()` method. Using the `addMiddleware` method, you can add any middleware from NPM Registry, custom Expressjs middleware or a ExpressoTS class-based middleware.
+
+NPM Registry middleware:
+
+```typescript title="Adding NPM Registry cors middleware"
+this.middleware.addMiddleware(cors());
+```
+
+Custom Expressjs middleware:
+
+```typescript title="Adding custom expressjs middleware"
+function myMiddleware(req: Request, res: Response, next: NextFunction) {
+    next();
+}
+
+this.middleware.addMiddleware(myMiddleware);
+```
+
+Custom ExpressoTS middleware:
+
+```typescript title="Adding custom expressots middleware"
+class CustomMiddleware extends ExpressoMiddleware {
+    use(req: Request, res: Response, next: NextFunction): void | Promise<void> {
+        next();
+    }
+}
+
+this.middleware.addMiddleware(new CustomMiddleware());
+```
+
+You can also add middleware to a specific route in the `App` class through the `this.middleware.addMiddleware()` method. You can add any middleware from NPM Registry, custom Expressjs middleware or a custom middleware.
+
+```typescript title="Adding middleware to a specific route"
+this.middleware.addMiddleware({ path: "/api", middlewares: [] });
+```
+
+:::note Each route can have multiple middlewares.
+:::
+
+## Middleware in controller
+
+If you want to apply a middleware to all routes under a specific controller, you can add it to the `@controller()` decorator. You can pass as many middlewares as you want to the `@controller()` decorator.
+
+```typescript
+@controller("/app", express.json())
+export class AppController {
+    @Post("/create")
+    createApp() {
+        return "Create App";
+    }
+
+    @Patch("/update")
+    updateApp() {
+        return "Update App";
+    }
+}
+```
+
+## Middleware in http method
+
+Or you add a middleware to a specific route in the controller class through the `http Method` decorators.
+
+```typescript
+@controller("/")
+export class AppController {
+    @Post("", express.json())
+    execute() {
+        return "Hello World";
+    }
+}
+```
+
+## Create expressoTS middleware
+
+To create a custom class-based middleware, you need to extend the `ExpressoMiddleware` class and implement the `use` method. The `use`
+method is the entry point of the middleware, and it receives the `Request`, `Response`, and `NextFunction` objects.
+
+Use the CLI to create a new middleware class:
+
+```bash
+expressots g mi middleware-name
+```
+
+```ts title="Scaffold output"
+import { ExpressoMiddleware, provide } from "@expressots/core";
+import { NextFunction, Request, Response } from "express";
+
+@provide(ExampleMiddleware)
+export class ExampleMiddleware extends ExpressoMiddleware {
+    use(req: Request, res: Response, next: NextFunction): void | Promise<void> {
+        throw new Error("Method not implemented.");
+    }
+}
+```
+
+An example of a custom class-based middleware implementation:
+
+```typescript title="Creating a custom class-base middleware"
+class CustomMiddleware extends ExpressoMiddleware {
+    private isOn: boolean;
+
+    constructor(isOn: boolean) {
+        super();
+        this.isOn = isOn;
+    }
+
+    use(req: Request, res: Response, next: NextFunction): void | Promise<void> {
+        // Do something
+        if (this.isOn) {
+            next();
+        } else {
+            res.status(403).send("Forbidden");
+        }
+    }
+}
+```
+
+Custom middleware allows you to pass parameters to the constructor and use them as options in the `use` method of your middleware. This way, you can
+create reusable middleware with different configurations.
+
+## View middleware pipeline
+
+You can view all the middlewares added to the application using the `this.middleware.viewMiddlewarePipeline()` method.
+The goal of the `viewMiddlewarePipeline` method is to provide a visual representation of the middleware pipeline in the application.
+
+:::info
+We are working on adding execution time for each middleware in the pipeline. This will allow you to identify bottlenecks in the middleware pipeline.
+:::
+
+Here is the output of the `viewMiddlewarePipeline` method:
+
+![View Middleware Pipeline](../core/img/middleware-view.png)
+
+---
+
+## Support us ❤️
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/overview/render.md b/docs/features/render.mdx
similarity index 62%
rename from docs/overview/render.md
rename to docs/features/render.mdx
index 282265d3..61594973 100644
--- a/docs/overview/render.md
+++ b/docs/features/render.mdx
@@ -1,12 +1,20 @@
 ---
-sidebar_position: 17
+sidebar_position: 5
+title: Render engine
+description: How to render views in ExpressoTS.
 ---
 
-# Render Engine
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
 
-**[ExpressoTS](https://expresso-ts.com/)** enhances the web server capabilities of Express.js by providing a streamlined experience for rendering views. ExpressoTS supports various render engines out-of-the-box, including EJS, PUG, and Handlebars (HBS). This makes it easy for developers to start rendering views without needing additional configuration, as default settings are provided for each supported engine.
+# Render engine
 
-## Supported Render Engines
+ExpressoTS enhances the web server capabilities of Express.js by providing a streamlined experience for rendering views. ExpressoTS supports
+3 render engines out-of-the-box.
+
+This makes it easy for developers to start rendering views without needing additional configuration, as default settings are provided for each supported engine.
+
+## Supported engines
 
 ExpressoTS supports the following render engines:
 
@@ -14,7 +22,11 @@ ExpressoTS supports the following render engines:
 -   PUG
 -   HBS (Handlebars)
 
-### Handlebars Configuration Options
+## Engine options
+
+<Tabs>
+    <TabItem value="handlebars" label="Handlebars">
+#### Configuration options
 
 ```typescript
 export type HandlebarsOptions = {
@@ -24,7 +36,7 @@ export type HandlebarsOptions = {
 };
 ```
 
-#### Default Handlebars configuration options
+#### Default configuration values
 
 ```typescript
 {
@@ -34,9 +46,7 @@ export type HandlebarsOptions = {
 }
 ```
 
-### Default Folder structure
-
-Default folder structure for Handlebars:
+#### Default folder structure
 
 ```tree
 src
@@ -46,9 +56,7 @@ views
 |--index.hbs
 ```
 
-All other engines follow the same structure, with the exception of the `partials` folder, which is specific to Handlebars.
-
-### Handlebars File Example
+#### .hbs file example
 
 ```html
 <html lang="en">
@@ -64,9 +72,10 @@ All other engines follow the same structure, with the exception of the `partials
 </html>
 ```
 
-## Other Engine Configuration Options
+    </TabItem>
+    <TabItem value="pug" label="Pug">
 
-### Pug Configuration Options
+#### Configuration options
 
 ```typescript
 export type PugOptions = {
@@ -75,7 +84,7 @@ export type PugOptions = {
 };
 ```
 
-#### Default Pug configuration options
+#### Default configuration values
 
 ```typescript
 {
@@ -84,7 +93,10 @@ export type PugOptions = {
 }
 ```
 
-### EJS Configuration Options
+    </TabItem>
+    <TabItem value="ejs" label="EJS">
+
+#### Configuration options
 
 ```typescript
 export type EjsOptions = {
@@ -94,7 +106,7 @@ export type EjsOptions = {
 };
 ```
 
-#### Default EJS configuration options
+#### Default configuration values
 
 ```typescript
 {
@@ -110,9 +122,17 @@ export type EjsOptions = {
 }
 ```
 
-## How to use
+    </TabItem>
+
+</Tabs>
+
+:::note
+All engines follow the same structure, with the exception of the `partials` folder, which is specific to Handlebars.
+:::
 
-Here's how you can set up ExpressoTS to use a render engine like HBS (handlebars) in your application:
+## Setup a render engine
+
+Here's how you can set up a render engine like HBS (handlebars) in your application:
 
 In the `app.provider` configuration provider, you can set the render engine:
 
@@ -144,16 +164,13 @@ export class App extends AppExpress {
 }
 ```
 
-:::note
 If you want to pass custom options to the render engine, you can do so by passing an object with the desired options to the `setEngine` method. For example, to set the views directory to a custom path, you can do the following:
 
-```typescript
-this.setEngine<HBS>(Engine.HBS, { viewsDir: <<custom-path>> });
+```typescript title="Custom render engine configuration"
+this.setEngine<HBS>(Engine.HBS, { viewsDir: <<custom-option>> });
 ```
 
-:::
-
-### How To Render Views in ExpressoTS
+## Render views
 
 To render a view in ExpressoTS, you can use the `render` method provided by the `Response` object. Here's an example of how you can render a view in ExpressoTS:
 
@@ -166,21 +183,19 @@ root(@response() res: Response) {
 
 In the example above, the `render` method is called on the `Response` object, passing the name of the view to be rendered and an object with data to be passed to the view. The view engine will render the view with the provided data and return the rendered HTML to the client.
 
-### Render Decorator
+## Render decorator
 
-The `@Render` decorator can be used on controller methods to render views using the specified view engine. Here's an example of how you can use the `@Render` decorator to render a view in ExpressoTS:
+The `@Render` decorator can be used on controller methods to render views using the specified view engine. It's a syntactic sugar that simplifies the process of rendering views in ExpressoTS.
 
-#### Rendering passing the view and default data in the decorator
+Here's an example of how you can use the `@Render` decorator to render a view in ExpressoTS:
 
-```typescript
+```typescript title="Rendering passing the view and default data in the decorator"
 @Get("/")
 @Render("index", { date: new Date(), name: "Random information" })
 root() {}
 ```
 
-#### Rendering passing only the view in the decorator
-
-```typescript
+```typescript title="Rendering passing only the view in the decorator"
 @Get("/")
 @Render("index")
 root() {
@@ -190,13 +205,7 @@ root() {
 
 ---
 
-## Support the project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
+## Support us ❤️
 
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/overview/status-code.md b/docs/features/status-code.mdx
similarity index 55%
rename from docs/overview/status-code.md
rename to docs/features/status-code.mdx
index f70e8fed..3d787372 100644
--- a/docs/overview/status-code.md
+++ b/docs/features/status-code.mdx
@@ -1,8 +1,10 @@
 ---
-sidebar_position: 14
+sidebar_position: 2
+title: Status code
+description: Status code is a way to represent the result of a request.
 ---
 
-# Status Code
+# Status code
 
 Status code is a way to represent the result of a request. These HTTP responses indicate whether a specific HTTP request has been successfully completed. Responses are grouped in five classes:
 
@@ -14,42 +16,60 @@ Status code is a way to represent the result of a request. These HTTP responses
 
 You can find more details about the status code in the **[MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status)**.
 
-:::tip
-The status codes listed below are defined by [RFC 9110](https://httpwg.org/specs/rfc9110.html#overview.of.status.codes)
+:::tip The status codes listed below are defined by [RFC 9110](https://httpwg.org/specs/rfc9110.html#overview.of.status.codes)
 :::
 
-## ExpressoTS status code
+## List of status codes
 
-In ExpressoTS, we have a list of all status codes listed in the MDN that you can use in your application. Here is an example of use:
+ExpressoTS provides a list of status codes that you can use in your application represented by the `StatusCode` enum.
 
-### In a Controller
+## Usage example
 
-```typescript
+Example of how to use the status code in a controller, use case, using `res` object, `@http` decorator etc.
+
+```typescript title="Controller example"
 import { StatusCode } from "@expressots/core";
 
 @controller("/user/create")
 class CreateUserController extends BaseController {
-    constructor(private createUserUseCase: CreateUserUseCase) {
-        super("create-user-controller");
-    }
+    constructor(private createUserUseCase: CreateUserUseCase) {}
 
-    @httpPost("/")
+    @Post("/")
     execute(
-        @requestBody() data: ICreateUserRequestDTO,
-        @response() res: any
+        @body() data: ICreateUserRequestDTO,
+        @response() res: Response
     ): ICreateUserResponseDTO {
-        return this.callUseCase(
-            this.createUserUseCase.execute(data),
-            res,
-            StatusCode.Created // Status code
-        );
+        return this.callUseCase(this.createUserUseCase.execute(data), res, StatusCode.Created);
+    }
+}
+```
+
+```typescript title="Using res object"
+import { StatusCode } from "@expressots/core";
+
+@controller("/")
+class ExampleController {
+    @Get("/")
+    execute(@response() res: Response) {
+        res.status(StatusCode.OK).send("Hello World!");
     }
 }
 ```
 
-### In a Use Case
+```typescript title="Using @http decorator"
+import { StatusCode } from "@expressots/core";
 
-```typescript
+@controller("/")
+class ExampleController {
+    @Get("/")
+    @Http(StatusCode.OK)
+    execute() {
+        return "Hello World!";
+    }
+}
+```
+
+```typescript title="Use case example"
 import { StatusCode } from "@expressots/core";
 
 @provide(CreateUserUseCase)
@@ -88,13 +108,7 @@ class CreateUserUseCase {
 
 ---
 
-## Support the project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
+## Support us ❤️
 
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/features/test.mdx b/docs/features/test.mdx
new file mode 100644
index 00000000..31b86201
--- /dev/null
+++ b/docs/features/test.mdx
@@ -0,0 +1,115 @@
+---
+sidebar_position: 4
+title: Testing
+description: How to test your ExpressoTS APIs.
+---
+
+# Testing
+
+Unit and integration testing are both crucial in application development, each serving a unique purpose:
+
+-   Unit tests: Focus on testing individual pieces of code, like a single function or method, in isolation. Dependencies are mocked to ensure controlled, reliable testing. Unit tests help catch bugs early and ensure that each part of the code works correctly, simplifying debugging later.
+
+-   Integration tests: Test the interaction between different components and external services. Unlike unit tests, they evaluate the application as a whole to ensure all parts work together as expected.
+
+:::tip
+Combining unit tests and integration tests can be beneficial because it allows developers to test both individual units of code and the application as a whole.
+This helps ensure that each piece of code is working correctly on its own and in conjunction with other parts of the application.
+:::
+
+## Our goal
+
+Our goal is to provide a simple and easy way to test your ExpressoTS APIs. We are working on a test library that wraps a modern testing framework to provide a simple and intuitive API for writing unit and integration tests.
+The test library will include:
+
+-   A test runner
+-   Adding the test library of your choice
+-   A test suite
+-   A test case
+-   A test assertion library
+-   A test coverage tool
+-   CLI command to scaffold tests
+
+:::caution Stay tuned for updates on our test library!
+:::
+
+## Testing usage example
+
+We will demonstrate how to test a simple ExpressoTS API using Jest and Supertest. You can use the test library of your choice.
+
+Below we are testing the PingUseCase endpoint return. We are using the **[Jest](https://jestjs.io/)** as the test runner and **[ts-jest](https://www.npmjs.com/package/ts-jest)** as the TypeScript preprocessor.
+
+```typescript title="ping.use-case.spec.ts"
+import { describe, expect, it } from "@jest/globals";
+
+describe("PingUseCase", () => {
+    let pingUseCase: PingUseCase;
+
+    beforeEach(() => {
+        pingUseCase = new PingUseCase();
+    });
+
+    it("should return a valid PingResponseDTO", () => {
+        const start: Date = new Date();
+        const response = pingUseCase.execute(start);
+        const end: Date = new Date(response.end);
+        const ttl = parseFloat(response.ttl.split(" ")[0]);
+
+        expect(response).toHaveProperty("start");
+        expect(response).toHaveProperty("end");
+        expect(response).toHaveProperty("ttl");
+        expect(response).toHaveProperty("message");
+        expect(response.message).toBe("Pong!");
+        expect(start <= end).toBe(true);
+        expect(ttl >= 0).toBe(true);
+    });
+});
+```
+
+## E2E testing with supertest
+
+We have available a method called `getHttpServer` in the `AppExpress` class that returns a proxy to the Express server. This method is useful for testing the application using **[Supertest](https://www.npmjs.com/package/supertest)**.
+
+```typescript title="POST /organization :: Creating a new organization use case"
+import "reflect-metadata";
+
+import { ServerEnvironment } from "@expressots/adapter-express";
+import { AppFactory, StatusCode } from "@expressots/core";
+import { container } from "../src/app.container";
+import { App } from "./../src/app.provider";
+import express from "express";
+import request from "supertest";
+
+const appExpress = express();
+
+describe("api test", () => {
+    let server: express.Application;
+
+    beforeAll(async () => {
+        const appInstance = await AppFactory.create(container, App);
+        await appInstance.listen(3000, ServerEnvironment.Development);
+
+        server = await appInstance.getHttpServer();
+    });
+
+    describe("organization.module", () => {
+        test("POST /organization", async () => {
+            const newOrg = {
+                name: "test org",
+            };
+
+            const response = await request(server).post("/organization").send(newOrg);
+
+            expect(response.status).toBe(StatusCode.Created);
+            expect(response.body).toEqual(newOrg);
+        });
+    });
+});
+```
+
+---
+
+## Support us ❤️
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](../support-us.mdx)**.
diff --git a/docs/governance.md b/docs/governance.md
deleted file mode 100644
index c72cdb71..00000000
--- a/docs/governance.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-sidebar_position: 8
----
-
-# Governance
-
-ExpressoTS is built by its community. We welcome and appreciate contributions of all kinds. There are many ways to help, from reporting issues, contributing code, and helping us improve our community.
-
-## Core Team
-
-Currently we have a small core team of constant contributors. We are looking to expand this team to include more people from the community with a wide range of skills and interests.
-
-## Decision Making
-
-Each major decision in ExpressoTS starts with a proposal. Proposals can be written by anyone in the community. The core team will review the proposal and decide whether to accept it, reject it, or ask for more information.
-
-:::caution SPOILER ALERT
-We are moving the project board and roadmap from Jira to GitHub Projects. This will allow us to have a more open and transparent process, as well as allow the community to participate more actively in the project.
-:::
-
-## Team
-
-Meet the team of regular contributors: **[Team](https://expresso-ts.com/team)**
-
-## Want to Help?
-
-**[Fix a bug or submit a proposal](https://github.com/expressots/expressots/issues/new/choose)**
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
diff --git a/docs/governance.mdx b/docs/governance.mdx
new file mode 100644
index 00000000..3dc8cdd0
--- /dev/null
+++ b/docs/governance.mdx
@@ -0,0 +1,87 @@
+---
+sidebar_position: 6
+title: GOVERNANCE
+---
+
+import Tabs from "@theme/Tabs";
+import TabItem from "@theme/TabItem";
+
+# Governance
+
+ExpressoTS is built by its community. We welcome and appreciate contributions of all kinds. There are many ways to help, from reporting issues, contributing code, and helping us improve our community.
+
+## Decision making
+
+Each major decision in ExpressoTS starts with a proposal. Proposals can be written by anyone in the community. The core team will review the proposal and decide whether to accept it, reject it, or ask for more information.
+
+## How to contribute?
+
+**"This path is arduous but it's very rewarding, you can help to shape the future of backend development!**
+
+The framework is gaining traction globally, and I'm currently managing parallel development efforts from various talented developers like yourself. Apologies if my responses are sometimes delayed!
+We’re always looking for passionate contributors, and there’s a straightforward, well-defined process to become part of our selective core development team—a unique aspect compared to many open-source projects.
+
+#### Types of contributors:
+
+<Tabs>
+    <TabItem label="Ocassional Contributor" value="ocasional">
+        Developers who suggest improvements or implement a change and contribute on a one-off basis.
+        For those who want to contribute occasionally, you can start by fixing a bug or submitting a
+        proposal. We appreciate all contributions, no matter how small!
+    </TabItem>
+    <TabItem label="Core Developer" value="core">
+        A dedicated group of developers who not only code but also act as DevRel for the platform.
+        As a core developer, you’ll join a team of skilled individuals driving the future of
+        ExpressoTS and helping to shape the backend development landscape.
+    </TabItem>
+</Tabs>
+
+#### How to become a core developer:
+
+To become a core developer, you’ll need to deliver at least three major contributions to the framework, focusing on new functionalities or significant improvements.
+
+Steps to Start Contributing:
+
+1. Explore ExpressoTS: Create a project using ExpressoTS and explore its functionalities, including the Core, Adapter, and CLI.
+   Take notes on potential improvements or features you think could be added.
+
+2. Read the Documentation: Understanding the project’s philosophy and technical details is crucial. Make sure to thoroughly read the documentation.
+
+3. Dive into the Codebase: Clone the repository and start familiarizing yourself with the code.
+
+```bash
+git clone https://github.com/expressots/expressots.git
+```
+
+4. Identify Your Interest Area: Once you're comfortable with the framework, reach out to me with the area you'd like to contribute to. We can schedule a meeting to discuss how to implement or improve that part of the framework.
+
+5. Contribute and Grow: After our discussion, I'll assign you a task. Your contributions will be reviewed, and based on the quality and impact, you may be invited to join the core development team.
+
+6. Additional Tips: Engage with the Community: Join our Discord or other community channels to interact with other contributors and core developers.
+
+7. Star the project on GitHub: expressots/expressots
+
+8. Stay Updated: Keep an eye on the project’s roadmap and open issues on GitHub to find areas where your contributions can make the most impact.
+
+:::info
+We’re excited to have you on board and look forward to your contributions to ExpressoTS!
+
+**[Fix a bug or submit a proposal](https://github.com/expressots/expressots/issues/new/choose)**
+:::
+
+## Core Team
+
+Currently we have a small core team of constant contributors. We are looking to expand this team to include more people from the community with a wide range of skills and interests.
+
+Submit your application to become a core developer when you feel ready to contribute to the project.
+
+**[Start my application](https://docs.google.com/forms/d/e/1FAIpQLSdL-IYrnndkzHF2THxgOP1lrmFiUKSVegysz5iVVrtyFUVB7g/viewform?usp=sf_link)**.
+
+Meet the team of regular and past contributors: **[Team](https://expresso-ts.com/team)**
+
+---
+
+## Support us ❤️
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](./support-us.mdx)**.
diff --git a/docs/guides/_category_.json b/docs/guides/_category_.json
new file mode 100644
index 00000000..d2a0a376
--- /dev/null
+++ b/docs/guides/_category_.json
@@ -0,0 +1,8 @@
+{
+    "label": "GUIDES",
+    "position": 4,
+    "link": {
+        "type": "generated-index",
+        "description": "Expresso TS Tutorials."
+    }
+}
diff --git a/docs/tutorials/compression.md b/docs/guides/compression.mdx
similarity index 58%
rename from docs/tutorials/compression.md
rename to docs/guides/compression.mdx
index c4ac5dfd..d0bcbd8f 100644
--- a/docs/tutorials/compression.md
+++ b/docs/guides/compression.mdx
@@ -1,36 +1,52 @@
 ---
-sidebar_position: 1
+sidebar_position: 0
+title: Compression
+description: How to use the npm compression package in ExpressoTS.
 ---
 
 # Compression
 
 The npm compression package is a middleware that can compress response bodies for requests that traverse through it. This helps reduce the size of data that's sent over the network, leading to quicker response times and lower bandwidth usage. It uses the zlib library to perform gzip or deflate compression, both of which are widely supported by modern web browsers.
 
-## How to Use Compression in ExpressoTS
+:::info
+For more information about the npm compression package, please visit the **[npm compression package](https://www.npmjs.com/package/compression)**.
+:::
 
-Install the npm compression middleware.
+## Benefits
 
-```bash
-npm i compression
-npm i -D @types/compression
-```
+-   Performance: It can significantly reduce the size of the response body, thereby decreasing the time it takes for a client to download the response and render the content.
 
-### Add Middleware Globally
+-   Efficiency: It helps in reducing bandwidth consumption which is especially useful if your server is sending large amounts of data or if you have limited bandwidth.
 
-**Non-opinionated template**: add the compression middleware in the `AppFactory` create method.
+-   Overhead: While compression reduces the size of the response body, it does add some computational overhead on the server-side as the server must compress the response body before sending it.
 
-```typescript
-import compression from "compression";
+:::caution COMPRESSION OVERHEAD
+This might not be ideal for high traffic websites where server resources are at a premium.
 
-async function bootstrap() {
-    const app = await AppFactory.create(container, [compression()]);
-    await app.listen(3001, ServerEnvironment.Development);
-}
+Not all content benefits from compression. Binary files like images and videos are already compressed and trying to compress them further can sometimes increase their size.
+:::
+
+## When to use
+
+Deciding on when to use compression depends on the use case. If your website serves a lot of textual data (HTML, CSS, JS, JSON, XML etc.), then using the npm compression package can result in significant bandwidth savings and performance benefits. However, if your website is extremely high traffic, the additional computational overhead of compression might start to become a bottleneck.
+
+In high traffic scenarios, it might be more beneficial to use a reverse proxy or a CDN (Content Delivery Network) which can serve static assets and perform caching. This can offload some of the traffic from your main servers and also serve content from locations geographically closer to users, resulting in faster response times. These services usually handle compression themselves, meaning you wouldn't need to use the npm compression package.
+
+Modern approaches could involve a combination of techniques - serving static assets from a CDN, caching responses where appropriate, utilizing HTTP/2 for multiplexing, and splitting up your application into microservices to distribute the load.
+
+Remember, these approaches aren't mutually exclusive. Often the best approach is to use a combination of these techniques based on the specific requirements of your application. Testing and monitoring your application under realistic workloads can help you make the best decision.
+
+## Install
+
+Install the npm compression middleware.
 
-bootstrap();
+```bash
+npm i compression && npm i -D @types/compression
 ```
 
-**Opinionated template**: configure the compression middleware in the `App` provider class. In the opinionated template common `expressjs` middlewares are offered out-of-the-box. Explore the options in `this.middleware` property.
+## Setup
+
+Add the compression middleware to your application using the out-of-the-box ExpressoTS middleware system.
 
 ```typescript
 @provide(App)
@@ -47,23 +63,40 @@ export class App extends AppExpress {
     protected configureServices(): void {
         this.middleware.addCompression();
     }
+}
+```
 
-    protected postServerInitialization(): void {
-        if (this.isDevelopment()) {
-            this.provider.envValidator.checkAll();
-        }
-    }
+:::info
+If middleware is not added to the application, ExpressoTS will emit a warning message.
+:::
 
-    protected serverShutdown(): void {}
-}
+```bash
+WARN  [resolver] Middleware [compression] not installed. Please install it using your package manager.
 ```
 
+## Usage example
+
+Once the middleware is added to the application, it will compress all responses that pass through it. The middleware can be configured with various options to control the behavior of compression.
+
+:::note
+Also you can add the compression middleware globally or to a specific route.
+:::
+
 Using compress with filters, filtering requests that contain payload bodies larger than 100 \* 1024 bytes:
 
 ```typescript
-async function bootstrap() {
-    const app = await AppFactory.create(container, [
-        compression({
+export class App extends AppExpress {
+    private middleware: IMiddleware;
+    private provider: ProviderManager;
+
+    constructor() {
+        super();
+        this.middleware = container.get<IMiddleware>(Middleware);
+        this.provider = container.get(ProviderManager);
+    }
+
+    protected configureServices(): void | Promise<void> {
+        this.middleware.addCompression({
             level: 6,
             threshold: 100 * 1024,
             filter: (req, res) => {
@@ -72,60 +105,72 @@ async function bootstrap() {
                 }
                 return compression.filter(req, res);
             },
-        }),
-    ]);
-    await app.listen(3001, ServerEnvironment.Development);
+        });
+    }
 }
-
-bootstrap();
-```
-
-### Add Middleware to a Route
-
-This is valid for both templates. You can add the compression middleware to a specific route.
-
-```typescript
-@Get("/", compression())
-execute(){};
 ```
 
-:::tip
-For more information about the npm compression package, please visit the **[npm compression package](https://www.npmjs.com/package/compression)**.
-:::
-
-## Compression Package
+## Add to a specific route
 
--   Performance: It can significantly reduce the size of the response body, thereby decreasing the time it takes for a client to download the response and render the content.
+Adding the compression middleware to a specific route is also possible via the ExpressoTS middleware system.
 
--   Efficiency: It helps in reducing bandwidth consumption which is especially useful if your server is sending large amounts of data or if you have limited bandwidth.
+```ts
+export class App extends AppExpress {
+    private middleware: IMiddleware;
+    private provider: ProviderManager;
 
--   Overhead: While compression reduces the size of the response body, it does add some computational overhead on the server-side as the server must compress the response body before sending it.
+    constructor() {
+        super();
+        this.middleware = container.get<IMiddleware>(Middleware);
+        this.provider = container.get(ProviderManager);
+    }
 
-:::caution COMPRESSION OVERHEAD
-This might not be ideal for high traffic websites where server resources are at a premium.
+    protected configureServices(): void | Promise<void> {
+        this.middleware.addMiddleware({
+            path: "/api",
+            middlewares: [
+                compression({
+                    level: 6,
+                    threshold: 100 * 1024,
+                    filter: (req, res) => {
+                        if (req.headers["x-no-compression"]) {
+                            return false;
+                        }
+                        return compression.filter(req, res);
+                    },
+                }),
+            ],
+        });
+    }
+}
+```
 
-Not all content benefits from compression. Binary files like images and videos are already compressed and trying to compress them further can sometimes increase their size.
-:::
+## Add in the controller
 
-## When to Use
+Adding the middleware in the controller applies the compression middleware to all routes in the controller.
 
-Deciding on when to use compression depends on the use case. If your website serves a lot of textual data (HTML, CSS, JS, JSON, XML etc.), then using the npm compression package can result in significant bandwidth savings and performance benefits. However, if your website is extremely high traffic, the additional computational overhead of compression might start to become a bottleneck.
+```typescript
+@controller("/", compression())
+export class AppController {
+    @Get("/")
+    execute(): string {
+        return "Hello from Expressots!";
+    }
+}
+```
 
-In high traffic scenarios, it might be more beneficial to use a reverse proxy or a CDN (Content Delivery Network) which can serve static assets and perform caching. This can offload some of the traffic from your main servers and also serve content from locations geographically closer to users, resulting in faster response times. These services usually handle compression themselves, meaning you wouldn't need to use the npm compression package.
+## Add in the method
 
-Modern approaches could involve a combination of techniques - serving static assets from a CDN, caching responses where appropriate, utilizing HTTP/2 for multiplexing, and splitting up your application into microservices to distribute the load.
+Adding the compression middleware in the method applies the compression middleware to the specific route.
 
-Remember, these approaches aren't mutually exclusive. Often the best approach is to use a combination of these techniques based on the specific requirements of your application. Testing and monitoring your application under realistic workloads can help you make the best decision.
+```typescript
+@Get("/", compression())
+execute(){};
+```
 
 ---
 
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
+## Support us ❤️
 
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](./support-us.mdx)**.
diff --git a/docs/tutorials/cookies.md b/docs/guides/cookies.mdx
similarity index 61%
rename from docs/tutorials/cookies.md
rename to docs/guides/cookies.mdx
index 536b43a0..9f290b50 100644
--- a/docs/tutorials/cookies.md
+++ b/docs/guides/cookies.mdx
@@ -1,37 +1,59 @@
 ---
-sidebar_position: 2
+sidebar_position: 1
+title: Cookies
+description: How to use cookies in ExpressoTS.
 ---
 
 # Cookies
 
 Cookies are small pieces of data that a website sends to a user's web browser while the user is browsing that website. Every time the user loads the website, the browser sends the cookie back to the server to notify the website of the user's previous activity.
 
-## How to Use Cookies in ExpressoTS
+## Benefits
 
-Install the npm cookie-parser middleware and type definition.
+Cookies serve several primary purposes:
 
-```bash
-npm i cookie-parser
-npm i -D @types/cookie-parser
-```
+1. Session Management:
+   Cookies are often used to handle user sessions. For example, when you log into a website, a cookie is set to remember your login state. So, as you navigate the site, you remain logged in.
 
-### Add Middleware Globally
+2. Personalization:
+   Cookies can store user preferences to personalize the user's experience on the site. For example, cookies might store information about the user's preferred language, theme, or other settings.
 
-**Non-opinionated template**: add the cookie-parser middleware in the `AppFactory` create method.
+3. Tracking:
+   Some cookies track user behavior on the site over time. These are often used by third-party analytics tools to understand user behavior and optimize the site accordingly. Advertisers also use tracking cookies to display targeted ads based on user activity.
 
-```typescript
-import cookieParser from "cookie-parser";
+4. Security:
+   Cookies can be used to support secure website functions. For example, a cookie can be used to remember that a user has authenticated to a site so that the server knows the user has already provided valid login credentials.
 
-// Add middleware in the AppFactory create method
-async function bootstrap() {
-    const app = await AppFactory.create(container, [cookieParser()]);
-    await app.listen(3000, ServerEnvironment.Development);
-}
+It's also important to note that there are different types of cookies - session cookies, which expire when the browser session ends, and persistent cookies, which remain on the user's device for a set period of time or until they are explicitly deleted.
+
+:::caution USING COOKIES FOR TRACKING
+Keep in mind that the use of cookies, especially for tracking and personalization, has raised privacy concerns, leading to regulations such as GDPR in Europe and CCPA in California that require sites to disclose their cookie usage and obtain user consent.
+:::
 
-bootstrap();
+## When to use
+
+Deciding when to use cookie-parser largely depends on your application's needs. If your web application requires state management and you've chosen to do that via cookies, cookie-parser can make your life easier and your application more secure with signed cookies.
+
+However, if your website has heavy traffic, the overhead might become a concern. If your architecture is based around stateless services (common in microservices architectures), you might want to avoid cookies and opt for other methods of maintaining state, like JWTs (JSON Web Tokens).
+
+:::info
+In case you're dealing with a high traffic website, consider alternatives like sessions stored in a database, JWTs, or tokens stored in HTTP headers. Also, using a load balancer to distribute traffic and session store modules to maintain session data across multiple servers can help to manage high traffic and stateful data.
+:::
+
+The best approach often involves combining multiple techniques, tailored to your application's specific needs. Testing and monitoring your application under realistic conditions can help guide your decision-making process.
+
+## Install
+
+Install the npm cookie-parser middleware and type definition.
+
+```bash
+npm i cookie-parser
+npm i -D @types/cookie-parser
 ```
 
-**Opinionated template**: configure the cookie-parser middleware in the `App` provider class. In the opinionated template common `expressjs` middlewares are offered out-of-the-box. Explore the options in `this.middleware` property.
+## Setup
+
+Add the cookie-parser middleware to your application using the out-of-the-box ExpressoTS middleware system.
 
 ```typescript
 @provide(App)
@@ -48,20 +70,12 @@ export class App extends AppExpress {
     protected configureServices(): void {
         this.middleware.addCookieParser();
     }
-
-    protected postServerInitialization(): void {
-        if (this.isDevelopment()) {
-            this.provider.envValidator.checkAll();
-        }
-    }
-
-    protected serverShutdown(): void {}
 }
 ```
 
-### Add Middleware to a Route
+## Usage example
 
-This is valid for both templates. You can add the cookie-parser middleware to a specific route.
+Once the middleware is added to the application, it will parse cookies from the request and make them available in the request object. The middleware can be configured with various options to control the behavior of cookie parsing.
 
 ```typescript
 @Get("get-cookie", cookieParser())
@@ -81,9 +95,11 @@ setCookie(@response() res: Response) {
 }
 ```
 
-Create a route that gets the cookie and returns the value:
+## Using cookies decorator
 
-```typescript
+Using the `@cookies()` decorator, you can get all cookies from the request and use them in your route:
+
+```typescript title="Create a route that gets the cookie and returns the value"
 @httpGet("get-cookie")
 getCookie(@cookies() cookieInfo: string, @response() res: Response) {
     return res.send(`Your token: ${cookieInfo["authToken"]}`);
@@ -94,61 +110,9 @@ getCookie(@cookies() cookieInfo: string, @response() res: Response) {
 `@cookies()` decorator it is a helper to get all cookies from the request. You can also use `@cookies('cookieName')` to get a specific cookie.
 :::
 
-## What Are Cookies Used For?
-
-Cookies serve several primary purposes:
-
-1. Session Management:
-   Cookies are often used to handle user sessions. For example, when you log into a website, a cookie is set to remember your login state. So, as you navigate the site, you remain logged in.
-
-2. Personalization:
-   Cookies can store user preferences to personalize the user's experience on the site. For example, cookies might store information about the user's preferred language, theme, or other settings.
-
-3. Tracking:
-   Some cookies track user behavior on the site over time. These are often used by third-party analytics tools to understand user behavior and optimize the site accordingly. Advertisers also use tracking cookies to display targeted ads based on user activity.
-
-4. Security:
-   Cookies can be used to support secure website functions. For example, a cookie can be used to remember that a user has authenticated to a site so that the server knows the user has already provided valid login credentials.
-
-It's also important to note that there are different types of cookies - session cookies, which expire when the browser session ends, and persistent cookies, which remain on the user's device for a set period of time or until they are explicitly deleted.
-
-:::caution USING COOKIES FOR TRACKING
-Keep in mind that the use of cookies, especially for tracking and personalization, has raised privacy concerns, leading to regulations such as GDPR in Europe and CCPA in California that require sites to disclose their cookie usage and obtain user consent.
-:::
-
-## Cookie-Parser Package
-
--   Ease of Use: cookie-parser makes it very easy to read cookie values, which are often used for tracking user sessions, personalization, and managing stateful applications. Without this library, you would have to manually parse the Cookie header and handle the nuances of cookie formatting.
-
--   Signed Cookies: The package also supports signed cookies, which are a way to verify the integrity of cookies (i.e., whether they have been tampered with). This is an important feature for securing sensitive information stored in cookies.
-
-## What to Consider When Using cookie-parser
-
--   Overhead: While it's not a heavy library, using cookie-parser does add a bit of overhead to each request, as it parses all cookies regardless of whether they are used in the route handler.
-
--   Stateful: Cookies inherently make an application stateful. When scaling an application, state can be problematic. Therefore, alternative stateless authentication methods, like tokens, can be preferable in a microservices architecture.
-
-## When to Use
-
-Deciding when to use cookie-parser largely depends on your application's needs. If your web application requires state management and you've chosen to do that via cookies, cookie-parser can make your life easier and your application more secure with signed cookies.
-
-However, if your website has heavy traffic, the overhead might become a concern. If your architecture is based around stateless services (common in microservices architectures), you might want to avoid cookies and opt for other methods of maintaining state, like JWTs (JSON Web Tokens).
-
-:::info
-In case you're dealing with a high traffic website, consider alternatives like sessions stored in a database, JWTs, or tokens stored in HTTP headers. Also, using a load balancer to distribute traffic and session store modules to maintain session data across multiple servers can help to manage high traffic and stateful data.
-:::
-
-The best approach often involves combining multiple techniques, tailored to your application's specific needs. Testing and monitoring your application under realistic conditions can help guide your decision-making process.
-
 ---
 
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
+## Support us ❤️
 
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](./support-us.mdx)**.
diff --git a/docs/overview/repositories.md b/docs/guides/repositories.mdx
similarity index 62%
rename from docs/overview/repositories.md
rename to docs/guides/repositories.mdx
index 090f5d83..267d8b46 100644
--- a/docs/overview/repositories.md
+++ b/docs/guides/repositories.mdx
@@ -1,14 +1,12 @@
 ---
-sidebar_position: 9
+sidebar_position: 2
+title: Repositories
+description: Learn how to use repositories in ExpressoTS.
 ---
 
 # Repositories
 
-The repository pattern in ExpressoTS provides an abstraction layer for data access, encapsulating CRUD (Create, Read, Update, Delete) operations within repository classes. These repositories act as intermediaries between the business logic and data mapping layers, using ORMs like **[TypeORM](https://typeorm.io/), [Prisma](https://www.prisma.io/) or [Sequelize](https://sequelize.org/)** to interact with the database.
-
-## Understanding the repository pattern
-
-A repository pattern is a design strategy that abstracts data persistence, allowing business logic to be agnostic of the underlying database technology or schema. ExpressoTS utilizes this pattern to facilitate maintainability and scalability.
+The repository pattern provides an abstraction layer for data access, encapsulating CRUD (Create, Read, Update, Delete) operations within repository classes. These repositories act as intermediaries between the business logic and data mapping layers, using ORMs like **[TypeORM](https://typeorm.io/), [Prisma](https://www.prisma.io/) or [Sequelize](https://sequelize.org/)** to interact with the database.
 
 ## Goals and benefits
 
@@ -19,11 +17,11 @@ The main goal of the repository pattern is to separate business logic from data
 -   **Abstraction**: Hides the complexities of the data layer from the rest of the application, providing a simplified and consistent interface for data operations.
 -   **Testability**: Makes testing easier by allowing the use of mock repositories or in-memory databases to simulate data persistence.
 
-## Repository pattern implementation example
+## Implementation example
 
 In the following example, we will create a simple repository pattern implementation using TypeScript. We will define a base repository interface and class, as well as a concrete repository class for a `User` entity.
 
-### Base repository interface
+## Base repository interface
 
 ```typescript
 interface IBaseRepository<T> {
@@ -35,7 +33,7 @@ interface IBaseRepository<T> {
 }
 ```
 
-### Base repository class
+## Base repository class
 
 ```typescript
 @provide(BaseRepository)
@@ -44,7 +42,7 @@ class BaseRepository<T> implements IBaseRepository<T> {
 }
 ```
 
-### Specific repository class
+## Specific repository class
 
 ```typescript
 @provide(UserRepository)
@@ -57,19 +55,15 @@ The above example demonstrates the simplicity of creating a base repository that
 
 While repositories focus on data interaction, providers in ExpressoTS typically offer functionalities such as environment validation or logging. Keeping repositories and providers distinct ensures clean separation and adheres to the single responsibility principle.
 
-:::info
 In ExpressoTS, repositories are housed within a dedicated "repositories" folder, distinguishing them from the "providers" folder. This structural choice emphasizes their distinct roles and facilitates a modular codebase.
+
+:::info
+This separation happens only in the opinionated template. For the non opinionated template, you can structure your codebase as you see fit.
 :::
 
 ---
 
-## Support the project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
+## Support us ❤️
 
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](./support-us.mdx)**.
diff --git a/docs/hello.md b/docs/hello.md
deleted file mode 100644
index 906c58ef..00000000
--- a/docs/hello.md
+++ /dev/null
@@ -1,55 +0,0 @@
----
-sidebar_position: 0
----
-
-# Welcome to ExpressoTS
-
-ExpressoTS is designed to simplify the software development process, enabling developers to concentrate on the core business logic by abstracting technical complexities. Our goal is to enhance your productivity through a framework that not only accelerates development but also offers comprehensive documentation and a superior developer experience, minimizing the necessity for boilerplate code.
-
-Our commitment is twofold: to simplify your development work and to enhance your productivity. As we embark on this journey, we invite you to join our community-driven project. Your insights, feedback, and contributions are invaluable in creating an optimal developer experience for everyone.
-
-We appreciate your support in this endeavor. Let's code efficiently together. 🐎
-
-## Navigating the Documentation
-
-This documentation is organized into distinct sections, each focusing on a specific aspect of ExpressoTS. Use the sidebar on the left to navigate through the content:
-
--   **Overview**: Provides general information about ExpressoTS, including project resources, concepts, objectives, and initial setup instructions.
--   **Code By Example**: Offers practical examples to demonstrate the application of ExpressoTS resources.
--   **CLI**: Details the command-line interface, including usage instructions.
--   **Providers**: Describes the available providers and their utilization.
--   **Tutorial**: A comprehensive, step-by-step guide to accomplishing specific tasks within ExpressoTS.
--   **Roadmap**: Outlines the future direction and planned features of ExpressoTS.
--   **Governance**: Explains the governance model of ExpressoTS and outlines how to contribute to the project.
-
-## Understanding Alert Types
-
-Throughout this documentation, various formats are used to draw attention to different types of information:
-
--   **Links**: Bold text indicates hyperlinks to other documentation pages or external resources.
--   **Code**: Code snippets, commands, and key technical terms are highlighted.
--   **Alerts**: Specific alerts are employed to emphasize crucial information, utilizing the following markers:
-
-:::note Conveys general information or reminders.
-:::
-:::tip Provides helpful suggestions or best practices.
-:::
-:::info Offers additional, non-critical information.
-:::
-:::caution Alerts to potential spoilers or sensitive content.
-:::
-:::danger Signals potential issues or risks that could impact development.
-:::
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
diff --git a/docs/intro.mdx b/docs/intro.mdx
new file mode 100644
index 00000000..e4dec6e5
--- /dev/null
+++ b/docs/intro.mdx
@@ -0,0 +1,65 @@
+---
+sidebar_position: 0
+title: INTRO
+description: Introduction to ExpressoTS.
+---
+
+# EXPRESSO<span class="span-table">TS</span>
+
+ExpressoTS ( 🐎 ) is designed to simplify the software development process, enabling developers to concentrate on the core business logic by abstracting technical complexities. Our goal is to enhance your productivity through a framework that not only accelerates development but also offers comprehensive documentation and a superior developer experience, minimizing the necessity for building custom solutions from scratch.
+
+Your insights, feedback, and contributions are invaluable in creating an optimal developer experience for everyone.
+
+## Structure
+
+This documentation is organized into distinct sections, each focusing on a specific aspect of ExpressoTS.
+
+> **CORE**: Provides guidance on the core building blocks of ExpressoTS.
+
+> **FEATURES**: Details the features and functionalities of ExpressoTS that are part of the core framework.
+
+> **CLI**: Details the command-line interface, including usage instructions.
+
+> **GUIDES**: A comprehensive, step-by-step guide to accomplishing specific tasks within ExpressoTS.
+
+> **ROADMAP**: Outlines the future direction and planned features of ExpressoTS.
+
+> **GOVERNANCE**: Explains the governance model of ExpressoTS.
+
+> **SUPPORT US ❤️**: Details how you can support the development of ExpressoTS and describe how to contribute to the project.
+
+## Alert types
+
+Throughout this documentation, various formats are used to draw attention to different types of information:
+
+**[Links](doc.expresso-ts.com)**: Bold green text indicates hyperlinks to other documentation pages or external resources.
+
+```md
+[Links](doc.expresso-ts.com)
+```
+
+**Code**: Code snippets, commands, and key technical terms are highlighted.
+
+```ts title="Code snippet"
+console.log("Hello, ExpressoTS!");
+```
+
+**Alerts**: Specific alerts are employed to emphasize crucial information, utilizing the following markers:
+
+:::note Conveys general information or reminders.
+:::
+:::tip Provides helpful suggestions or best practices.
+:::
+:::info Offers additional, non-critical information.
+:::
+:::caution Alerts to potential issues or problems that could arise.
+:::
+:::danger Warns of critical issues or problems that could arise.
+:::
+
+---
+
+## Support us ❤️
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](./support-us.mdx)**.
diff --git a/docs/overview/_category_.json b/docs/overview/_category_.json
deleted file mode 100644
index 912aa19c..00000000
--- a/docs/overview/_category_.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "label": "Overview",
-  "position": 2,
-  "link": {
-    "type": "generated-index",
-    "description": "ExpressoTS Framework Overview."
-  }
-}
diff --git a/docs/overview/app-container.md b/docs/overview/app-container.md
deleted file mode 100644
index b75f5f98..00000000
--- a/docs/overview/app-container.md
+++ /dev/null
@@ -1,107 +0,0 @@
----
-sidebar_position: 3
----
-
-# App Container
-
-ExpressoTS leverages **[InversifyJS](https://inversify.io/)** for its Inversion of Control (IoC) container capabilities, providing a robust system for dependency injection. This type-aware container facilitates object instantiation, resolution, and life cycle management, enabling the creation of complex dependencies with minimal code.
-
-The AppContainer wrapper simplifies integration, allowing for straightforward registration of controllers, use cases, and providers within the application.
-
-## Configuring the container
-
-The application container can be customized with default scopes for dependency binding and options to skip base class checks, enhancing flexibility in dependency management.
-
--   **defaultScope**: The default scope, `RequestScope`, creates a new instance of a dependency for each request, while `SingletonScope` creates a single instance shared across all requests. The `TransientScope` creates a new instance each time the dependency is requested.
--   **skipBaseClassChecks**: When set to `true`, the container will skip base class checks when working with derived classes.
--   **autoBindInjectable**: When set to `true`, the container will automatically inject classes that are not explicitly bound.
-
-Here is the interface options definition:
-
-```typescript
-interface ContainerOptions {
-    /**
-     * The default scope for bindings in the container.
-     * It can be set to Request (default), Singleton, or Transient.
-     */
-    defaultScope?: interfaces.BindingScope;
-
-    /**
-     * Allows skipping of base class checks when working with derived classes.
-     */
-    skipBaseClassChecks?: boolean;
-
-    /**
-     * Allows auto-injection of classes that are not explicitly bound to the container.
-     */
-    autoBindInjectable: false;
-}
-```
-
-Creating the container
-
-```typescript
-// Adding options to the container
-export const appContainer: AppContainer = new AppContainer({
-    defaultScope: BindingScopeEnum.Singleton,
-    skipBaseClassChecks: true,
-    autoBindInjectable: false,
-});
-
-// Creating a container module manager
-const container = appContainer.create([
-    // Add your modules here
-    AppModule,
-]);
-
-export { container };
-```
-
-## Defining the container scope
-
-As mentioned above, if the `defaultScope` option is not provided, it defaults to `RequestScope`. However, it is possible to change the default scope by passing the `defaultScope` as a an option in the container constructor. The `BindingScopeEnum` contains the following values:
-
--   `BindingScopeEnum.Singleton` - The dependency will be created once and will be shared across all requests.
--   `BindingScopeEnum.Request` - The dependency will be created once per request.
--   `BindingScopeEnum.Transient` - The dependency will be created every time it is requested.
-
-## Viewing container bindings
-
-The container can be used to view all the bindings that have been registered. This can be useful for debugging purposes or to understand the dependencies that have been registered.
-
-```typescript
-appContainer.viewContainerBindings();
-```
-
-![Container Bindings View](./img/container-bindings.png)
-
-## Registering Modules
-
-The `appContainer` facilitates module registration via its `create([])` method, which accepts an array of modules. This streamlined approach reduces setup complexity and aligns with ExpressoTS's goal of simplifying application architecture:
-
-```typescript
-// Create a new container
-const appContainer: AppContainer = new AppContainer();
-
-const container: Container = appContainer.create([
-    // Register all the modules
-    UserModule,
-    PaymentModule,
-    ProductModule,
-]);
-```
-
-The use of `appContainer` abstracts away the intricacies of InversifyJS direct usage, providing a straightforward path to integrating and managing modules within ExpressoTS applications.
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
diff --git a/docs/overview/application.md b/docs/overview/application.md
deleted file mode 100644
index 8dec2d43..00000000
--- a/docs/overview/application.md
+++ /dev/null
@@ -1,151 +0,0 @@
----
-sidebar_position: 2
----
-
-# Application
-
-At the heart of an ExpressoTS application lies the `App` class. It serves as the foundation for creating and configuring the server. Additionally, the App class allows middleware and providers to be configured in the server bootstrapping process. The App class also provides lifecycle hooks that allow developers to execute code before, after, and on server shutdown. This section provides an overview of the ExpressoTS application architecture, its components, and the workflow of an ExpressoTS application.
-
-![Application Overview](./img/app-overview.png)
-
-## Application architecture
-
-The architecture of an ExpressoTS application is built around the **[Inversify](https://inversify.io/)** IoC container, which is used to identify and inject dependencies into class constructors. This approach allows the IoC container to load all the necessary modules, including their respective routes (controllers). By using use-cases and providers as needed, routers can handle incoming requests.
-
-## Core components and their roles
-
-The ExpressoTS application architecture is predicated on several pivotal components:
-
--   **DTO IN/OUT**: Defines the structure for incoming and outgoing data, ensuring type safety and consistency across the application.
--   **Controller**: Manages request processing, routing based on URL and HTTP method, and data validation.
--   **Use Case**: Executes specific logic for handling requests, acting upon validated data from controllers to perform operations and return responses.
--   **Provider**: Supplies external functionalities like database access, email services, or authentication mechanisms.
--   **Repository**: Facilitates direct communication with the database for CRUD operations, abstracting the data layer.
-
-:::info
-Providers and Repositories are optional components. You can use them if you need to provide extra functionality to your application such as database integration, logging system, authentication, email etc.
-:::
-
-## Application workflow
-
-The workflow begins with the server initialization, including setting up the container, modules, and controllers. Upon receiving requests, the server invokes the relevant controller, which then triggers the corresponding use case. If needed, use cases interact with providers to access external resources or services.
-
-:::warning Initializing the Application without a controller
-ExpressoTS will prevent you from initializing the Application without a controller since there are no listeners to handle incoming requests. You will see the following message in the console:
-**_No controllers have been found! Please ensure that you have register at least one Controller._**
-:::
-
-## AppExpress class
-
-The AppExpress class offers a way to create and configure the server, passing **[Express.js middlewares](https://expressjs.com/en/guide/writing-middleware.html)**, register external providers, and set up the server environment. The AppExpress class provides three lifecycle hooks that allow developers to execute code before, after, and on server shutdown. The following is the AppExpress class structure:
-
-```typescript
-export class App extends AppExpress {
-    private middleware: IMiddleware;
-    private provider: ProviderManager;
-
-    constructor() {
-        super();
-        this.middleware = container.get<IMiddleware>(Middleware);
-        this.provider = container.get(ProviderManager);
-    }
-
-    protected configureServices(): void {
-        this.provider.register(Env);
-
-        this.middleware.addBodyParser();
-        this.middleware.setErrorHandler();
-    }
-
-    protected postServerInitialization(): void {
-        if (this.isDevelopment()) {
-            this.provider.get(Env).checkAll();
-        }
-    }
-
-    protected serverShutdown(): void {}
-}
-```
-
-:::info
-The `App` class offers a set of out-of-the-box middlewares and providers that can be used to configure your application. See the complete list in the **[Middleware section](./middleware.md)**
-:::
-
-## Application bootstrapping
-
-The application bootstrapping process involves creating the server, passing the container, the App class, and starting the server. The AppFactory class provides the create and listen method that allows developers to create the server and listen for incoming requests. The following is the Bootstrap function that creates the server:
-
-```typescript
-async function bootstrap() {
-    const app = await AppFactory.create(container, App);
-    await app.listen(3000, ServerEnvironment.Development);
-}
-```
-
-:::info
-The framework currently supports Express as its primary adapter, with Fastify and other possible in house server under development.
-:::
-
-### Environment management
-
-The server environment is defined through the `ServerEnvironment` enum, with support for `development` and `production` modes, defaulting to development if `NODE_ENV` is unset.
-
--   ServerEnvironment.Development;
--   ServerEnvironment.Production;
-
-## Application lifecycle hooks
-
-Another important aspect of the Application class is lifecycle hooks. These hooks allow developers to execute code before, after and on server shutdown.
-
-```typescript
-    /* Add any service that you want to be initialized before the server starts */
-    protected configureServices(): void { }
-
-    /* Add any service that you want to execute after the server starts */
-    protected postServerInitialization(): void { }
-
-    /* Add any service that you want to execute after server is shutdown */
-    protected serverShutdown(): void { }
-```
-
-### Hooks Execution Order
-
-![Application Lifecycle Hooks](./img/app-life-cycle.png)
-
-## Application Scripts
-
-Scripts for building, running, and testing the application are provided, accommodating different development stages and operational needs, from development to production.
-
-| Script           | Description                                     | Command            |
-| ---------------- | ----------------------------------------------- | ------------------ |
-| expressots build | Build the production bundle in a ./dist folder. | npm run build      |
-| expressots dev   | Runs in development watch mode.                 | npm run dev        |
-| expressots prod  | Runs in production mode based on built bundle.  | npm run prod       |
-| test             | Run your tests located in the test folder.      | npm run test       |
-| test:watch       | Run your tests in watch and interactive mode.   | npm run test:watch |
-| test:cov         | Produces test coverage report.                  | npm run test:cov   |
-| format           | Format the code using prettier.                 | npm run format     |
-| lint             | Lint code using eslint.                         | npm run lint       |
-
-## Starting the application
-
-```bash
-npm run dev
-```
-
-This will start the application with console output indicating the version, running port, and environment, providing clear feedback on the application's running state.
-
-`expressots-demo version 1.0.0 is running on port 3000 - Environment: development`
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
diff --git a/docs/overview/controller.md b/docs/overview/controller.md
deleted file mode 100644
index 385313b6..00000000
--- a/docs/overview/controller.md
+++ /dev/null
@@ -1,202 +0,0 @@
----
-sidebar_position: 6
----
-
-# Controllers
-
-Controllers act as the primary interface between the client and server in ExpressoTS applications. They handle incoming requests, validate payloads against an input DTO, and emit responses in the DTO pattern. In essence, controllers bridge the communication between clients and service layers, also known as use-cases.
-
-**Controller MVC Pattern Example**
-
-![Controller MVC Pattern](./img/controller-mvc.png)
-
-**Controller Single Responsibility Pattern Example**
-
-![Controller Single Responsibility Pattern](./img/controller-single-resp.png)
-
-In order to create a basic controller we create a class and use the `@controller()` decorator to define the route for the controller. Then we create a method and use the `http Methods` decorators to define the route and HTTP method for the method.
-
-## Controller Class
-
-### MVC Pattern
-
-Multiple routes in a single controller.
-
-```typescript
-@controller("/user")
-export class UserController {
-    @Post("/")
-    create(@response() res: Response) {
-        return res.send("User created");
-    }
-
-    @Get("/")
-    getUser(@response() res: Response) {
-        return res.send("User listed");
-    }
-}
-```
-
-### Single Responsibility Pattern
-
-One controller, one execution method, and one use case.
-
-```typescript
-@controller("/user/create")
-export class UserCreateController {
-    @Post("/")
-    execute(@response() res: Response) {
-        return res.send("User created");
-    }
-}
-```
-
-:::tip
-Both, the `@controller()` and `http methods` decorators works in combination to define the route and middlewares to be used in the endpoint.
-:::
-
-## Controller Scope
-
-The default scope of a controller is `Request`, as it is inherited from the `AppContainer` and default `Module` class scope. However, you can override the scope of a controller by using the `@scope()` decorator. This decorator accepts the same BindingScopeEnum enum values.
-
-:::info
-If you define the module scope you can not override it in a specific controller by using the `@scope` decorator.
-The `@scope` decorator can only be used in specific controllers if the module scope is not defined.
-:::
-
-Here is an example of usage:
-
-```typescript
-@scope(BindingScopeEnum.Singleton)
-@controller("/")
-class CreateUserController extends BaseController {}
-```
-
-The controller above will be scoped as `Singleton` and will be shared across all requests.
-
-## BaseController Class
-
-We also power a controller class with the `BaseController` class that offers in the constructor a parameter that the developer can indicate what service or domain he is currently building. This helps the log system throw errors with more information about the context of the error and where the error occurred.
-
-Another advantage of using the `BaseController` class is that it offers a method in two different versions async and sync, which is the `callUseCase() or callUseCaseAsync()`.
-
-These methods reinforce the idea of one use case per controller, and they are responsible for calling the use case that will implement the business logic of the controller.
-
-:::tip
-The callUseCase methods, available in both synchronous and asynchronous versions, are well-suited for returning status and JSON responses to clients, as the users just need to pass the useCase return, res:Response, and statusCode.
-:::
-
-The signature of the `callUseCase` method:
-
-```typescript
-callUseCase(useCase: any, res: any, successStatusCode: number);
-```
-
--   `useCase`: The use case that will be called. This use case is injected in the controller constructor.
--   `res`: The response object from the express request.
--   `successStatusCode`: The status code that will be sent to the client if the use case is executed successfully. Please see the **[Http Status Code](./status-code.md)** type for more information.
-
-The default response:
-
-```typescript
-return res.status(successStatusCode).json(dataReturn);
-```
-
-A more complete example of a controller class inheriting from the **BaseController** class is shown below:
-
-```typescript
-@controller("/")
-class AppController extends BaseController {
-    constructor(private appUseCase: AppUseCase) {
-        super("app-controller");
-    }
-
-    @httpGet("/")
-    execute(@response() res: any): IAppResponseDTO {
-        return this.callUseCase(this.appUseCase.execute(), res, StatusCode.OK);
-    }
-}
-```
-
-## Controller Decorators
-
-HTTP methods and parameters decorators are a set of annotations used in ExpressoTS applications to define the routing and request handling for HTTP requests. Using the decorators listed below can simplify the routing and handling of HTTP requests in ExpressoTS applications, and make the code more readable and maintainable.
-
-### HTTP Methods Decorators
-
-Here's a list of all available `@httpMethods()` decorators in ExpressoTS, along with their description and usage:
-
-| Decorator | Description                                         | Usage                    |
-| --------- | --------------------------------------------------- | ------------------------ |
-| @Get      | Binds a controller method to a GET HTTP verb.       | @Get("/path")            |
-| @Post     | Binds a controller method to a POST HTTP verb.      | @Post("/path")           |
-| @Put      | Binds a controller method to a PUT HTTP verb.       | @Put("/path")            |
-| @Patch    | Binds a controller method to a PATCH HTTP verb.     | @Patch("/path")          |
-| @Head     | Binds a controller method to a HEAD HTTP verb.      | @Head("/path")           |
-| @Delete   | Binds a controller method to a DELETE HTTP verb.    | @Delete("/path")         |
-| @Method   | Binds a controller method to a specified HTTP verb. | @Method("verb", "/path") |
-
-### Parameter Decorators
-
-Here's a list of all available parameter decorators in ExpressoTS, along with their description and usage:
-
-| Decorator                     | Description                                            | Usage                                            |
-| ----------------------------- | ------------------------------------------------------ | ------------------------------------------------ |
-| @request()                    | Injects the Express Request object.                    | execute(@request() req: Request)                 |
-| @response()                   | Injects the Express Response object.                   | execute(@response() res: Response)               |
-| @param(paramName?: string)    | Injects a parameter from the request URL path.         | execute(@param('id') id: string)                 |
-| @query(paramName?: string)    | Injects a parameter from the request URL query string. | execute(@query('searchTerm') searchTerm: string) |
-| @body()                       | Injects the request body payload.                      | execute(@body() body: MyDTO)                     |
-| @headers(headerName?: string) | Injects a header from the request headers.             | execute(@headers('authorization') auth: string)  |
-| @cookies(cookieName?: string) | Injects a cookie from the request cookies.             | execute(@cookies('session') session: string)     |
-| @next()                       | Injects the Express NextFunction object.               | execute(@next() next: NextFunction)              |
-
-## DTO Pattern
-
-Data Transfer Object (DTO) is a commonly used design pattern that standardizes data formats for communication between different application layers, including client-server or server modules. DTO serves as an interface for data exchange, ensuring clear and standardized structures for input and output data. By separating business logic from communication logic, it helps to reduce application complexity and decouple different layers.
-
-Using DTOs can improve application performance and scalability by reducing the data transfer between the client and server and providing more efficient ways to process and handle data within the application.
-
-### DTO Example
-
-For example, imagine a user registration scenario where name, email, and password are collected, and ID is auto-generated. The user object DTO for Input and Response could have possible formats, as shown below:
-
-```typescript
-// UserCreateInputDTO
-interface UserCreateInputDTO {
-  name: string;
-  email: string;
-  password: string;
-}
-
-// UserCreateResponseDTO
-interface UserCreateResponseDTO {
-  id: string;
-  name: string;
-  status: string;
-}
-
-// Payload json format
-{
-  "name": string,
-  "email": string,
-  "password": string
-}
-```
-
-Having two different DTO formats is essential in this case because while registering a user, we don't want to return the password to the client due to security concerns. Therefore, we created a different DTO for the response, adding a complementary field called status, where a message is typically sent to the client, indicating that the user was created successfully.
-
-As a result, DTOs help to segregate and filter the data being sent to the client, reducing the amount of data processed by the application.
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
diff --git a/docs/overview/dependencies.md b/docs/overview/dependencies.md
deleted file mode 100644
index 864a4ef8..00000000
--- a/docs/overview/dependencies.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-sidebar_position: 13
----
-
-# Dependencies
-
-The purpose of this section is to list all dependencies used by ExpressoTS and our vision about dependency management.
-
-## Dependency Management
-
-We know that dependencies accelerate the development process, but it also increases the projects complexity and maintenance cost. Another aspect we consider is the potential security risks that a dependency could bring the project.
-
-Our goal is to keep the number of dependencies as low as possible, using only those that are necessary and not part of our core ExpressoTS framework mechanics. With that in mind, the Roadmap includes some dependencies that we hope to replace by our own implementation. More information will come on this.
-
-For now, we will keep a vigilant watch on included dependencies, using tools like **[Dependabot](https://dependabot.com/)** to keep them up to date and also using tools like **[Snyk](https://snyk.io/)** to monitor the security risks.
-
-## Utilities (Dev Dependencies)
-
--   @commitlint/cli: Lint commit messages
--   @commitLint/config-conventional: Lint commit messages
--   @release-it/conventional-changelog: Generate changelog
--   dotenv: Loads environment variables from .env file
--   husky: Git hooks
--   prettier: Code formatter
--   eslint: Linting code
--   ts-node-dev: Typescript runner
--   tsconfig-paths: Resolve paths from tsconfig.json
-
-## Core Packages
-
--   express: Http server framework
--   inversify: IoC container
--   inversify-binding-decorators: Decorators for inversify
--   reflect-metadata: Polyfill for metadata reflection API
-
-## Test
-
--   vitest: Testing framework
--   vite: Vitest's requirement
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
diff --git a/docs/overview/entities.md b/docs/overview/entities.md
deleted file mode 100644
index 13e2dd4c..00000000
--- a/docs/overview/entities.md
+++ /dev/null
@@ -1,136 +0,0 @@
----
-sidebar_position: 10
----
-
-# Entities
-
-Entities are the core components of an ExpressoTS application. They are the objects that are used to represent the data that is going to be manipulated by the application.
-
-If an entity changes, most likely use cases and controllers will also change. This is because the use cases and controllers are responsible for manipulating the data represented by the entities.
-
-## Entity Example
-
-Here a simple example of an entity User and it's properties:
-
-```typescript
-@provide(User)
-class User {
-    private id: string;
-    public name: string;
-    public email: string;
-
-    constructor() {
-        this.id = uuidv4();
-    }
-
-    get Id(): string {
-        return this.id;
-    }
-}
-```
-
-:::tip
-Remember that you should have one entity per file.
-:::
-
-## Entities and Encapsulation
-
-This section is dedicated to promote a reflection when you think about entities. For years we have been told that entities or classes properties should be encapsulated, its methods should abstract the internal implementation and expose only the necessary information to the outside world. This is a good practice when thinking about Object Oriented Programming Paradigm, however this is not always the best approach.
-
-If you think about it, classes, or entities, whatever you call it, are just a way to represent data. They are just a way to group data together.
-With this in mind, classes or entities became much more simple to maintain and understand, as they don't contain any logic.
-
-This way of thinking is called **[Anemic Domain Model](https://martinfowler.com/bliki/AnemicDomainModel.html)** and it's a very controversial topic. It's not the purpose of this documentation to discuss this topic, but it's important to mention it, as it's a very important concept when thinking about ExpressoTS entities.
-
-**Say good bye to God classes, and say hello to simple entities, say hello to data.**
-
-## Entity injection
-
-If your entity has dependencies, you can inject them using the `@inject` decorator.
-
-```typescript
-@provide(User)
-class User {
-    constructor(@inject("logger") private logger: Logger) {}
-}
-```
-
-## Avoid this
-
-Avoid marking constructors with primitive parameters as injectable. This is because it can be difficult for the DI container to infer what values to provide for these parameters. Here is an example of what you should avoid:
-
-```typescript
-@provide(User)
-class User {
-    name: string;
-    constructor(name: string) {
-        this.name = name;
-    }
-}
-```
-
-:::caution
-In many dependency injection (DI) systems, including InversifyJS, the DI container is responsible for constructing objects and injecting dependencies. When a class constructor contains primitive parameters, it can be difficult for the DI container to infer what values to provide for these parameters. This is because primitive values (like strings, numbers, and booleans) do not carry any inherent semantic meaning that the container can understand.
-:::
-
-### Reasons to avoid primitive parameter in injectable classes
-
-Here are some of the reasons why constructors with primitive parameters can be problematic in DI:
-
--   Ambiguity: If a class has a constructor that requires primitive types, the DI container won't know what values to inject. For example, if a class requires a number in its constructor, the DI container doesn't know what this number represents and what value it should have.
-
--   Inflexibility: A primitive value in the constructor implies that the value is a fixed part of the class. However, DI is often used to manage interchangeable parts of an application (e.g., different implementations of an interface).
-
--   Non-descriptive: Primitive values are often non-descriptive and can lead to confusing code. For example, a constructor that takes two string parameters might raise questions like: What do these strings represent? Are there any specific formats or constraints on these strings?
-
-## Entity proper injection
-
-If you want to inject an entity into another class you must rethink your design. If you really need primitive parameters on your constructor use factories to create your entities or the Repository pattern.
-
-Here is an example of a factory:
-
-```typescript
-@provide(User)
-class User implements IEntity {
-    public id: string;
-    public name!: string;
-    public email!: string;
-
-    constructor() {
-        this.id = randomUUID();
-    }
-}
-
-interface IUserFactory {
-    create(name: string, email: string): User;
-}
-
-@provide(UserFactory)
-class UserFactory implements IUserFactory {
-    create(name: string, email: string): User {
-        const user = new User();
-        user.name = name;
-        user.email = email;
-        return user;
-    }
-}
-
-export { User, UserFactory };
-```
-
-Now `UserFactory` can be easily injected into other classes.
-
-As mentioned above, there are several other approaches, as long as you remain strong 😁 of not using constructors with primitives parameters in classes that you are planning to inject.
-
----
-
-## Support the project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
diff --git a/docs/overview/first-steps.md b/docs/overview/first-steps.md
deleted file mode 100644
index 475ef15e..00000000
--- a/docs/overview/first-steps.md
+++ /dev/null
@@ -1,139 +0,0 @@
----
-sidebar_position: 1
----
-
-# First steps
-
-Begin your journey with ExpressoTS, a TypeScript framework for building scalable and maintainable Node.js applications. This section guides you through the foundational concepts, setup, and architecture of ExpressoTS.
-
-## Why TypeScript?
-
-**[TypeScript](https://www.typescriptlang.org/)** is a key element in developing robust server-side applications due to its strong typing, which significantly enhances code quality, scalability, productivity, and collaboration. Strong typing not only helps in catching errors early but also improves code documentation and maintainability, making TypeScript an excellent choice for large-scale applications.
-
-## Pre-requisites
-
-Please make sure that [Node.js](https://nodejs.org) `version >=18.10.0` is installed on your operating system.
-
-## Setup
-
-Install the **[ExpressoTS CLI](../cli/overview.md)** globally using NPM to get started with your project setup:
-
-Setting up a new ExpressoTS project is quite simple with **[ExpressoTS CLI](../cli/overview.md)**. First install the CLI globally with `NPM`:
-
-```bash
-npm i -g @expressots/cli
-```
-
-Create a new project by running:
-
-```bash
-expressots new <project-name>
-```
-
-For a specific project structure and package manager, specify the template and package manager directly:
-
-```bash
-expressots new <project-name>  -p <package-manager> -t <template-name>
-```
-
-## Project templates
-
-ExpressoTS provides two project templates to cater to different development needs:
-
--   Non-opinionated: Offers flexibility in project structuring with minimal setup.
--   Opinionated: Comes pre-configured for complex projects, reinforcing a specific project structure and scaffolding pattern.
-
-### Non-opinionated project structure
-
-```tree
-project-name/
-├── src/
-│   ├── app.container.ts
-│   ├── app.controller.ts
-│   ├── app.module.ts
-│   ├── app.provider.ts
-│   ├── main.ts
-├── test/
-│   ├── app.controller.spec.ts
-```
-
-| File Name                | Description                                                        |
-| ------------------------ | ------------------------------------------------------------------ |
-| `app.container.ts`       | Dependency injection container. Organizes the application modules. |
-| `app.controller.ts`      | A basic controller with a single route.                            |
-| `app.module.ts`          | Application root module.                                           |
-| `app.provider.ts`        | Application lifecycle manager.                                     |
-| `main.ts`                | The main entry point of an ExpressoTS application.                 |
-| `app.controller.spec.ts` | Unit test for the app.controller.                                  |
-
-### Opinionated project structure
-
-```tree
-project-name/
-├── src/
-│   ├── providers/
-│   │   └── app/
-│   │       └── app.provider.ts
-│   ├── useCases/
-│   │   └── app/
-│   │       └── app.controller.ts
-│   │       └── app.module.ts
-│   │       └── app.usecase.ts
-│   ├── app.container.ts
-│   ├── env.ts
-│   ├── main.ts
-├── test/
-│   ├── app.usecase.spec.ts
-```
-
-| File Name             | Description                                                                                                           |
-| --------------------- | --------------------------------------------------------------------------------------------------------------------- |
-| `providers/`          | This folder contains the layer responsible to provide externals resources to the application, also known as adapters. |
-| `app/app.provider.ts` | Application lifecycle manager.                                                                                        |
-| `useCases/`           | The use case folder contains the use cases implementation of operations that can be performed in the application.     |
-| `app.container.ts`    | Dependency injection container. Organizes the application modules.                                                    |
-| `env.ts`              | This is an utility resource that maps .env variables.                                                                 |
-| `main.ts`             | The main entry point of an ExpressoTS application.                                                                    |
-| `app.usecase.spec.ts` | A basic unit test for the app.usecase.                                                                                |
-
-This structure provides a robust framework for developing API endpoints, showcasing the layering and organization capabilities of ExpressoTS.
-
-## Application initialization and Configuration
-
-Initialize your application with the `AppFactory.create()` method, passing in the container and an App class for lifecycle management. This step is crucial for configuring your application's dependency injection and middleware setup.
-
-```typescript
-async function bootstrap() {
-    const app = await AppFactory.create(container, App);
-    await app.listen(3000, ServerEnvironment.Development);
-}
-```
-
-## Running your application
-
-With your application set up, start your development server or build your application with the following commands:
-
--   Development Mode: `npm run dev`
--   Production Build: `npm run build`
--   Production Mode: `npm run prod`
-
-:::info
-Once the application is up and running, you can access it by navigating to `http://localhost:3000/`.
-:::
-
-## Framework flexibility
-
-ExpressoTS is a versatile framework that is not bound to any specific platform or technology. Leveraging popular Node.js libraries like InversifyJS and Express.js, it is designed to be lightweight, modular, customizable, and easy to use. Developers can expand the framework's capabilities by creating new providers that can be incorporated into their applications.
-
----
-
-## Support the project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
diff --git a/docs/overview/img/controller-mvc.png b/docs/overview/img/controller-mvc.png
deleted file mode 100644
index 6d5921c5..00000000
Binary files a/docs/overview/img/controller-mvc.png and /dev/null differ
diff --git a/docs/overview/img/controller-single-resp.png b/docs/overview/img/controller-single-resp.png
deleted file mode 100644
index efbd0c31..00000000
Binary files a/docs/overview/img/controller-single-resp.png and /dev/null differ
diff --git a/docs/overview/img/di.png b/docs/overview/img/di.png
deleted file mode 100644
index 89394932..00000000
Binary files a/docs/overview/img/di.png and /dev/null differ
diff --git a/docs/overview/img/plugin-pattern.png b/docs/overview/img/plugin-pattern.png
deleted file mode 100644
index 1d4819e5..00000000
Binary files a/docs/overview/img/plugin-pattern.png and /dev/null differ
diff --git a/docs/overview/img/use-case-project-x.png b/docs/overview/img/use-case-project-x.png
deleted file mode 100644
index 151b50f5..00000000
Binary files a/docs/overview/img/use-case-project-x.png and /dev/null differ
diff --git a/docs/overview/intro.md b/docs/overview/intro.md
deleted file mode 100644
index a3eccdbf..00000000
--- a/docs/overview/intro.md
+++ /dev/null
@@ -1,82 +0,0 @@
----
-sidebar_position: 0
----
-
-# Introduction
-
-ExpressoTS offers a refined layer over **[Express.js](https://expressjs.com/)**, enhancing server-side TypeScript application development. It blends the robustness of Express.js with advanced TypeScript features, streamlining the creation of scalable, maintainable, and readable applications.
-
-## Philosophy
-
-Designed for efficiency, ExpressoTS simplifies server-side development. It reduces boilerplate, focusing on code clarity and structure. The framework's flexibility, through a comprehensive **[Dependency Injection system](./di.md)**, supports seamless integration of custom features with predefined scopes (Transient, Scoped, Singleton), fostering modular and decoupled design.
-Whether for a straightforward API or an intricate enterprise system, ExpressoTS accelerates development, ensuring timely, within-budget delivery of high-quality applications.
-
-## Setup
-
-### Installation
-
-Install the ExpressoTS CLI Globally:
-
-```bash
-npm i -g @expressots/cli
-```
-
-### Project Initialization
-
-Create a new project using the CLI:
-
-```bash
-expressots new <project-name>
-```
-
-For a quick setup, specify the project template and package manager directly:
-
-```bash
-expressots new <project-name> -p <package-manager> -t <template-name>
-```
-
-## Project Templates
-
-ExpressoTS offers two starter project templates: `opinionated` and `non-opinionated`.
-
--   `non-opinionated`: Offers structural flexibility.
--   `opinionated`: Provides a comprehensive project structure with predefined scaffold schematics.
-
-## Development Workflow
-
-### Access your project
-
-```bash
-cd <your-project-name>
-```
-
-### Development Mode
-
-```bash
-npm run dev
-```
-
-### Production Build
-
-```bash
-npm run build
-```
-
-### Production Mode
-
-```bash
-npm run prod
-```
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a sponsor on **[Sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
diff --git a/docs/overview/middleware.md b/docs/overview/middleware.md
deleted file mode 100644
index f7ffd7b6..00000000
--- a/docs/overview/middleware.md
+++ /dev/null
@@ -1,211 +0,0 @@
----
-sidebar_position: 5
----
-
-# Middleware
-
-Middleware functions are pivotal in the request-response cycle of an ExpressoTS application, providing the capability to execute code, modify request and response objects, end the request-response cycle, or call the next middleware in the stack. It's essential to call `next()` to avoid request timeouts unless your middleware concludes the cycle.
-
-ExpressoTS seamlessly integrates with Express middleware, enabling the use of its extensive ecosystem to enhance your application.
-
-:::info
-ExpressoTS fully supports [Express](https://expressjs.com/en/resources/middleware.html) middleware.
-:::
-
-## List of middlewares available
-
-Expressjs middlewares supported by ExpressoTS:
-
-| Middleware Name  | Description                                       |
-| ---------------- | ------------------------------------------------- |
-| addBodyParser    | Add body parser middleware to the application.    |
-| addCompression   | Add compression middleware to the application.    |
-| addCors          | Add cors middleware to the application.           |
-| addHelmet        | Add helmet middleware to the application.         |
-| addCookieParser  | Add cookie parser middleware to the application.  |
-| addCookieSession | Add cookie session middleware to the application. |
-| addSession       | Add session middleware to the application.        |
-| addServerStatic  | Add static middleware to the application.         |
-| addRateLimit     | Add rate limit middleware to the application.     |
-| addMorgan        | Add morgan middleware to the application.         |
-| addPassport      | Add passport middleware to the application.       |
-| setMulter        | Add multer middleware to the application.         |
-| addServeFavicon  | Add serve favicon middleware to the application.  |
-| setErrorHandler  | Add error handler middleware to the application.  |
-
-## Adding middleware
-
-ExpressoTS application supports adding middleware globally to the application as well as per route. It offers all the [middleware supported by Express Team](https://expressjs.com/en/resources/middleware.html) out-of-the-box through the use of `this.middleware` property.
-
-```typescript
-@provide(App)
-export class App extends AppExpress {
-    private middleware: IMiddleware;
-
-    constructor() {
-        super();
-        this.middleware = container.get<IMiddleware>(Middleware);
-    }
-
-    protected configureServices(): void {
-        this.middleware.addBodyParser();
-        this.middleware.addCors();
-        this.middleware.addHelmet();
-    }
-}
-```
-
-:::caution
-If you add a middleware that is not installed as dependency, the application will throw a warning message and continue to run.
-:::
-
-## Adding global middleware
-
-Middlewares can be added globally using the `App` class through the `this.middleware` property, using the out-of-the-box middleware list provided by Express Team:
-
-```typescript
-protected configureServices(): void {
-        this.middleware.addBodyParser();
-        this.middleware.addCors();
-        this.middleware.addHelmet();
-    }
-```
-
-## Using `addMiddleware` method
-
-For any other middleware, or a custom middleware, you can add it using the `this.middleware.addMiddleware()` method. Using the `addMiddleware` method, you can add any middleware from NPM Registry, custom Expressjs middleware or a custom middleware.
-
-NPM Registry middleware:
-
-```typescript
-this.middleware.addMiddleware(cors());
-```
-
-### Creating expressjs middleware
-
-```typescript
-function myMiddleware(req: Request, res: Response, next: NextFunction) {
-    // Do something
-    next();
-}
-```
-
-```typescript
-this.middleware.addMiddleware(myMiddleware);
-```
-
-### Creating expressots middleware
-
-Custom ExpressoTS middleware:
-
-```typescript
-class CustomMiddleware extends ExpressoMiddleware {
-    use(req: Request, res: Response, next: NextFunction): void | Promise<void> {
-        // Do something
-        next();
-    }
-}
-```
-
-```typescript
-this.middleware.addMiddleware(new CustomMiddleware());
-```
-
-## Route Middleware
-
-Middlewares can be added per route in the `App` class through the `this.middleware.addMiddleware()` method. You can add any middleware from NPM Registry, custom Expressjs middleware or a custom middleware.
-
-```typescript
-this.middleware.addMiddleware({ path: "/api", middlewares: [] });
-```
-
-:::info
-Each route can have multiple middlewares.
-:::
-
-### Adding middleware to a specific route
-
-Or you add a middleware to a specific route in the `Controller` class through the `@controller()` and/Or `http Method` decorators.
-
-```typescript
-@controller("/")
-export class AppController {
-    @Post("", express.json())
-    execute() {
-        return "Hello World";
-    }
-}
-```
-
-### Adding middleware to all routes in a controller
-
-If you want to apply a middleware to all routes under a specific controller, you can add it to the `@controller()` decorator.
-
-```typescript
-@controller("/app", express.json())
-export class AppController {
-    @Post("/create")
-    createApp() {
-        return "Create App";
-    }
-
-    @Patch("/update")
-    updateApp() {
-        return "Update App";
-    }
-}
-```
-
-## Example of custom expressoTS middleware
-
-To create a custom middleware, you need to extend the `ExpressoMiddleware` class and implement the `use` method.
-
-```typescript
-class CustomMiddleware extends ExpressoMiddleware {
-    private isOn: boolean;
-
-    constructor(isOn: boolean) {
-        super();
-        this.isOn = isOn;
-    }
-
-    use(req: Request, res: Response, next: NextFunction): void | Promise<void> {
-        // Do something
-        if (this.isOn) {
-            next();
-        } else {
-            res.status(403).send("Forbidden");
-        }
-    }
-}
-```
-
-Custom middleware allows you to pass parameters to the constructor and use them as options in the `use` method of your middleware.
-
-## View all middlewares pipeline
-
-You can view all the middlewares added to the application using the `this.middleware.viewMiddlewarePipeline()` method.
-
-![View Middleware Pipeline](./img/middleware-view.png)
-
-:::tip Use ExpressoTS CLI to scaffold a custom middleware.
-:::
-
-CLI command to scaffold a custom middleware:
-
-```bash
-expressots g mi <<middleware-name>>
-```
-
----
-
-## Support the project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
diff --git a/docs/overview/module.md b/docs/overview/module.md
deleted file mode 100644
index 21676415..00000000
--- a/docs/overview/module.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-sidebar_position: 4
----
-
-# Modules
-
-Modules, or container modules in ExpressoTS, are aggregations of services—primarily Controllers and their dependencies—that are managed by the framework's container. These modules facilitate the organization, registration, and resolution of various application components within the ExpressoTS ecosystem.
-
-## Understanding modules
-
-A module exports an Inversify Module object, serving as a configuration entity for controller bindings and their dependencies. It utilizes a bind method to establish relationships between services and their dependencies. To grasp the registration of classes such as use cases, entities, providers, repositories, and more, delve into the **[Dependency Injection section](./di.md)**, which elaborates on decorators influencing the default container scope.
-
-## Simplifying bindings with `CreateModule`
-
-ExpressoTS simplifies the binding process through the `CreateModule` function. This utility auto-registers controllers, injecting their dependencies without manual binding:
-
-```typescript
-export const AppModule: ContainerModule = CreateModule([AppController]);
-```
-
-## Defining module scope
-
-Very similar to the `Container`, developers can set the scope of a module using the same `BindingScopeEnum` enum. Here are the enum values:
-
--   `BindingScopeEnum.Singleton` - The dependency will be created once and will be shared across all requests.
--   `BindingScopeEnum.Request` - The dependency will be created once per request.
--   `BindingScopeEnum.Transient` - The dependency will be created every time it is requested.
-
-When creating a module, you can pass the scope as a second argument to the `CreateModule` function. It is optional and if not provided, the default scope is acquired from the `AppContainer` which is `RequestScope`.
-
-```typescript
-export const AppModule: ContainerModule = CreateModule([AppController], BindingScopeEnum.Singleton);
-```
-
-This flexibility allows for tailored dependency management strategies, such as combining Singleton scope modules for shared services with Request scope modules for request-specific services.
-
-## Scope precedence
-
-The hierarchy of scope precedence is `AppContainer` > `Module` > `Controller`, ensuring a versatile and hierarchical approach to dependency scope management. This layered structure permits precise control over service instantiation and lifecycle across the entire application.
-
----
-
-## Support the project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
diff --git a/docs/overview/test.md b/docs/overview/test.md
deleted file mode 100644
index 814a7864..00000000
--- a/docs/overview/test.md
+++ /dev/null
@@ -1,61 +0,0 @@
----
-sidebar_position: 16
----
-
-# Test
-
-Unit testing and integration testing are both important in any application development process because they serve different purposes.
-
--   **Unit tests**: focus on testing individual units of code, such as a single function or method, in isolation from the rest of the application. They typically involve mocking dependencies and external services to ensure that the unit being tested behaves as expected in a controlled environment. Unit tests are important because they allow developers to catch bugs and errors early in the development process, when they are easier and cheaper to fix. They also help to ensure that individual units of code are functioning correctly, which can make debugging and troubleshooting easier later on.
-
--   **Integration tests**: on the other hand, test the interactions between different components or modules of the application, including how they interact with external dependencies and services. Unlike unit tests, integration tests involve testing the application as a whole, rather than individual units in isolation. Integration tests are important because they help to ensure that the application is functioning correctly as a whole, and that different components are working together as expected.
-
-:::tip
-Combining unit tests and integration tests can be beneficial because it allows developers to test both individual units of code and the application as a whole. This helps ensure that each piece of code is working correctly on its own and in conjunction with other parts of the application. Furthermore, combining tests can provide more complete test coverage and identify problems at different levels of abstraction, from individual functions to complete system interaction with external components.
-:::
-
-## Our Example use Jest as a the test runner
-
-Below we are testing the PingUseCase endpoint return. We are using the **[Jest](https://jestjs.io/)** as the test runner and **[ts-jest](https://www.npmjs.com/package/ts-jest)** as the TypeScript preprocessor.
-
-```typescript
-describe("PingUseCase", () => {
-    let pingUseCase: PingUseCase;
-
-    beforeEach(() => {
-        pingUseCase = new PingUseCase();
-    });
-
-    it("should return a valid PingResponseDTO", () => {
-        const start: Date = new Date();
-        const response = pingUseCase.execute(start);
-        const end: Date = new Date(response.end);
-        const ttl = parseFloat(response.ttl.split(" ")[0]);
-
-        expect(response).toHaveProperty("start");
-        expect(response).toHaveProperty("end");
-        expect(response).toHaveProperty("ttl");
-        expect(response).toHaveProperty("message");
-        expect(response.message).toBe("Pong!");
-        expect(start <= end).toBe(true);
-        expect(ttl >= 0).toBe(true);
-    });
-});
-```
-
-:::caution SPOILER ALERT
-We have in our Roadmap the implementation of a test library that wraps a modern testing framework to provide a simple and intuitive API for writing unit and integration tests.
-:::
-
----
-
-## Support the project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
diff --git a/docs/overview/usecase.md b/docs/overview/usecase.md
deleted file mode 100644
index e744aefe..00000000
--- a/docs/overview/usecase.md
+++ /dev/null
@@ -1,90 +0,0 @@
----
-sidebar_position: 7
----
-
-# Use Cases
-
-From a UML standpoint, use cases provide a way to model the interactions between users, other systems, and a software application. A use case describes a specific scenario or flow of events between the actors and the system, leading to a certain outcome.
-
-In the context of ExpressoTS, use cases represent the business logic of the application, allowing for a clear separation between the controller and the request execution.
-
-## We recommend
-
-Despite you can use any design pattern you want such as **[MVC](./controller.md#mvc-pattern)**, in the ExpressoTS opinionated template we reinforce the use of the **[Clean architecture](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html)** and **[SOLID principles](https://medium.com/backticks-tildes/the-s-o-l-i-d-principles-in-pictures-b34ce2f1e898)**. We believe that this approach will help you to build a more maintainable and scalable application.
-
-It is best practice to have one use case per controller, with the controller being responsible for calling the corresponding use case that will implement the business logic of the request. The request payload, also known as request DTO in ExpressoTS, contains the information required to execute the use case.
-
-A use case in ExpressoTS contains only the business logic of the application, keeping it separate from the controller logic. It is common to have response DTOs as part of the use case, defining the response format of the request. The use case typically contains a single function called "execute", responsible for executing the logic of that particular use case.
-
-:::tip
-It is worth noting that having multiple use cases implemented within a single class violates the single responsibility principle and should be avoided.
-:::
-
-## Example
-
-Here is an example of a use case diagram for a project x:
-
-![Project X Use Case Diagram](./img/use-case-project-x.png)
-
-In the use case diagram above, the actor represents the user interacting with the system. To execute the Login use case, the user must provide specific information known as the payload or, in the case of ExpressoTS, the request DTO. This information is necessary to trigger the use case and for the system to deliver the desired outcome.
-
-It is important to note that the use case should exclusively contain the business logic of the application, with no additional or unrelated functionalities. This approach helps to ensure a clear separation of concerns, promoting maintainability, and scalability of the system.
-
-Here is a simple implementation of the use case:
-
-```typescript
-@provide(LoginUserUseCase)
-class LoginUserUseCase {
-    execute(payload: ILoginUserRequestDTO): boolean {
-        const { email, password } = payload;
-
-        if (isAuthenticated(email, password)) {
-            return true;
-        }
-
-        return false;
-    }
-}
-
-export { LoginUserUseCase };
-```
-
-## Explanation
-
-The implementation of use cases in ExpressoTS follows the best practices of software design, where each use case is responsible for implementing a specific business logic. As shown in the example code snippet, a use case typically contains only one function, called execute, which is responsible for executing the business logic defined in that use case. The use case may also include a response DTO that defines the format of the response for that particular use case.
-
-Also, it is common to use constructors in use cases to inject dependencies such as providers and repositories. This allows for better code modularity and testability.
-
-### Constructor injection
-
-With ExpressoTS **[Dependency Injection](di.md)** system we can use the constructor in the use cases to inject dependencies, such as providers, repositories, entities or any other helper class necessary to deliver the usecase response. This allows for better modularity and testability of the code.
-
-Here is an example of a use case with constructor injection:
-
-```typescript
-class ExampleUseCase {
-    constructor(private yourInjection1: Injection1, private yourInjection2: Injection2) {}
-
-    execute() {
-        this.yourInjection1.foo();
-        this.yourInjection2.bar();
-    }
-}
-```
-
-:::info
-It is important to adhere to the principle of single responsibility when implementing use cases. Each use case should only handle a specific business logic, and if you find yourself implementing multiple use cases in a single class, it is time to review your implementation to ensure that each use case has a clear and concise responsibility.
-:::
-
----
-
-## Support the project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
diff --git a/docs/providers/_category_.json b/docs/providers/_category_.json
deleted file mode 100644
index 356ebca3..00000000
--- a/docs/providers/_category_.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "label": "Providers",
-  "position": 5,
-  "link": {
-    "type": "generated-index",
-    "description": "ExpressoTS Framework Providers."
-  }
-}
diff --git a/docs/providers/dto-validator.md b/docs/providers/dto-validator.md
deleted file mode 100644
index 4783c685..00000000
--- a/docs/providers/dto-validator.md
+++ /dev/null
@@ -1,107 +0,0 @@
----
-sidebar_position: 1
----
-
-# DTO Validator
-
-The DTO Validator provider is a provider that ExpressoTS offers out-of-the-box. It is used to validate the incoming data from the client. It helps the developer to avoid runtime errors caused by missing or invalid data.
-
-When you scaffold a new project, the DTO Validator provider is already included as a middleware that can be used in any endpoint. The middleware is called `validateDTO`.
-
-## Pre Requisites
-
-The DTO validator is based on the [class-validator](https://www.npmjs.com/package/class-validator) and [class-transformer](https://www.npmjs.com/package/class-transformer) packages. It uses decorators to validate the DTOs.
-
-:::tip
-If you don't have class-validator and class-transformer installed and try to use the DTO validator, you will get an warning message in the console mentioning that you need to install the packages.
-:::
-
-Another important thing to mention is that the DTO validator works only with classes, as interfaces doesn't exist in runtime. So, if you want to use the DTO validator, you need to create a class that represents your DTO rather than the current interface provided by ExpressoTS.
-
-## How To Use
-
-You can use the DTO validator in any endpoint by adding the `validateDTO` middleware in the endpoint route.
-
-Endpoint that creates a new user:
-
-```typescript
-@httpPost("/", ValidateDTO(CreateUserDTO))
-execute(@requestBody() payload: CreateUserDTO, @response() res: Response) {
-  return res.status(StatusCode.Created).json(this.createUserUseCase.execute(payload));
-}
-```
-
-Here it is the `CreateUserDTO` class:
-
-```typescript
-import { IsEmail, IsNotEmpty, MinLength } from "class-validator";
-
-class CreateUserDTO {
-  @IsNotEmpty()
-  @MinLength(10)
-  name: string;
-  @IsNotEmpty()
-  @IsEmail({}, { message: "Invalid email" })
-  email: string;
-}
-
-export { CreateUserDTO };
-```
-
-:::info
-For more information about the decorators, please check the [class-validator](https://www.npmjs.com/package/class-validator) package.
-:::
-
-## DTO Validator Error Messages
-
-If you submit a payload that doesn't match the DTO `CreateUserDTO` above, the DTO validator will return an error message with the following format:
-
-**Payload:**
-
-```json
-{
-  "name": "",
-  "email": ""
-}
-```
-
-**Response:**
-
-```json
-{
-  "errorCode": 400,
-  "errorMessage": "Bad Request",
-  "DTO": [
-    {
-      "property": "name",
-      "messages": [
-        "name must be longer than or equal to 10 characters",
-        "name should not be empty"
-      ]
-    },
-    {
-      "property": "email",
-      "messages": ["invalid email", "email should not be empty"]
-    }
-  ]
-}
-```
-
-Messages are split by property, so you can easily identify which property has an error and what is the error message. This is useful when you have a DTO with a lot of properties, as you can easily identify which property has an error. It also helps the frontend application on getting the error messages more easily.
-
-:::caution SPOILER ALERT
-The ValidateDTO is part of the functionalities that ExpressoTS offers out-of-the-box to help you to build your application faster. In the next versions of ExpressoTS for every functionality that ExpressoTS offers out-of-the-box, we will provide a way for you to customize it or use your own implementation based on your favorite package or library.
-:::
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
-- Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
-- Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
-- Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Join our **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Share the project with your friends and colleagues
diff --git a/docs/providers/envvalidator.md b/docs/providers/envvalidator.md
deleted file mode 100644
index 65af26eb..00000000
--- a/docs/providers/envvalidator.md
+++ /dev/null
@@ -1,49 +0,0 @@
----
-sidebar_position: 2
----
-
-# Environment Validator
-
-The environment validator provider is a provider that ExpressoTS offers out-of-the-box. It is used to validate the existence of the `.env` file and its content.
-It helps the developer to avoid runtime errors caused by missing environment variables.
-
-:::tip
-It is only included in the opinionated template or when you create a class that extends the `Application` class.
-:::
-
-You can find it in the `src/providers/application` folder in the opinionated template.
-
-The `application.provider` is the main provider of the application that is responsible to control the **[Application Lifecycle](../overview/application.md#application-lifecycle-hooks)**.
-
-Inside of the Application class you can find three methods that are called in the following order:
-
-- `configureServices()` : Configure services that should be initialized before the server starts.
-- `postServerInitialization()` : Configure services that should be executed after the server starts.
-- `serverShutdown()` : Perform actions or cleanup after the server is shutdown.
-
-Environment validator provider is called in the `configureServices()` method preventing the application from starting if the `.env` file is missing or if it has missing environment variables.
-
-```typescript
-protected configureServices(): void {
-    Environments.checkAll();
-}
-```
-
-The environment validator provider also has a method called `get()` that returns the value of an environment variable. It is used to get a specific environment variable value passing its name as a parameter.
-
-```typescript
-Environments.get("PORT");
-```
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
-- Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
-- Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
-- Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Join our **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Share the project with your friends and colleagues
diff --git a/docs/providers/in-memory-db.md b/docs/providers/in-memory-db.md
deleted file mode 100644
index 28b8673c..00000000
--- a/docs/providers/in-memory-db.md
+++ /dev/null
@@ -1,168 +0,0 @@
----
-sidebar_position: 3
----
-
-# In Memory DB
-
-In Memory DB is a provider that uses a simple in memory database to store data. It is a class that can be registered in the ExpressoTS dependency injection system as a singleton.
-
-```ts
-this.provider.register(InMemoryDB, "Singleton");
-```
-
-The InMemoryDB class provides a simple and efficient way to simulate a database entirely in-memory, which can be particularly useful for testing and rapid development where a full-fledged database might be overkill.
-
-## DB Inspector
-
-Another cool feature added to the InMemoryDB class is the ability to print tables to the console using console.table. This feature is particularly useful for debugging and testing purposes. It can also be used to quickly inspect the contents of a table.
-
-The table content will be printed to the console every time the repository is used by any endpoint that have operations that read or write to the database.
-
-Here is an image showing the output in the console of the InMemoryDB when we create a new user:
-
-![Application Overview](../overview/img/inMemoryDB.png)
-
-:::info
-The DB inspector is enabled by default. As soon as you create a new entity and extend the BaseRepository class, the InMemoryDB will print the table to the console.
-:::
-
-## How to Use InMemoryDB
-
-To use the InMemoryDB class, you need to import it from the `expressots` package and register it as a singleton in the dependency injection system. Here is an example of how to do this in a service class:
-
-### Register InMemoryDB
-
-```typescript
-export class App extends AppExpress {
-    private middleware: IMiddleware;
-    private provider: ProviderManager;
-
-    constructor() {
-        super();
-        this.middleware = container.get<IMiddleware>(Middleware);
-        this.provider = container.get(ProviderManager);
-    }
-
-    protected configureServices(): void {
-        this.provider.register(InMemoryDB, "Singleton");
-    }
-
-    protected postServerInitialization(): void {}
-
-    protected serverShutdown(): void {}
-}
-```
-
-When registering the InMemoryDB class, you can specify the scope as `string` or using the `BindingScopeEnum`.
-
-### Define your Entity
-
-```typescript
-@provide(UserEntity)
-export class UserEntity {
-    id: string;
-    name: string;
-    email: string;
-
-    constructor() {
-        this.id = randomUUID();
-    }
-}
-```
-
-### Create a Repository
-
-The repository is a class that extends the BaseRepository class and is used to manage entities of a specific type. The repository class is part of the dependency injection system and is marked by the @provide decorator.
-
-```typescript
-@provide(UserRepository)
-export class UserRepository extends BaseRepository<UserEntity> {
-    constructor() {
-        super("users");
-    }
-}
-```
-
-In the class above, we are creating a repository for the `UserEntity` class. The repository is initialized with the table name `users` in the constructor.
-
-You can also define custom methods for the user repository.
-
-```typescript
-@provide(UserRepository)
-class UserRepository extends BaseRepository<UserEntity> {
-    constructor() {
-        super("users");
-    }
-
-    // Custom method implemented for the UserRepository only
-    findByEmail(email: string): User | null {
-        const user = this.table.find((item) => item.email === email);
-        return user || null;
-    }
-}
-```
-
-### Use the Repository
-
-You can inject the repository in the constructor or via property injection.
-
-Property Injection:
-
-```typescript
-@provide(UserCreateUseCase)
-export class UserCreateUseCase {
-    @inject(UserRepository)
-    private userRepo: UserRepository;
-
-    @inject(UserEntity)
-    private userEntity: UserEntity;
-
-    execute(payload: IUserCreateRequestDTO): IUserCreateResponseDTO {
-        this.userEntity.name = payload.name;
-        this.userEntity.email = payload.email;
-
-        this.userRepo.create(this.userEntity);
-
-        return {
-            id: this.userEntity.id,
-            name: this.userEntity.name,
-            email: this.userEntity.email,
-        };
-    }
-}
-```
-
-Constructor Injection:
-
-```typescript
-@provide(UserCreateUseCase)
-export class UserCreateUseCase {
-    constructor(private userEntity: UserEntity, private userRepo: UserRepository) {}
-
-    execute(payload: IUserCreateRequestDTO): IUserCreateResponseDTO {
-        this.userEntity.name = payload.name;
-        this.userEntity.email = payload.email;
-
-        this.userRepo.create(this.userEntity);
-
-        return {
-            id: this.userEntity.id,
-            name: this.userEntity.name,
-            email: this.userEntity.email,
-        };
-    }
-}
-```
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
diff --git a/docs/providers/prisma.mdx b/docs/providers/prisma.mdx
deleted file mode 100644
index 707a9c62..00000000
--- a/docs/providers/prisma.mdx
+++ /dev/null
@@ -1,599 +0,0 @@
----
-sidebar_position: 4
----
-
-import Tabs from "@theme/Tabs";
-import TabItem from "@theme/TabItem";
-
-# Prisma Provider
-
-:::danger Prisma was removed from the CLI and will be served as a separated package via [add provider] command.
-:::
-
-The ExpressoTS Prisma Provider encapsulates the robust [Prisma](https://www.prisma.io/) ORM (Object-Relational Mapper) within the ExpressoTS framework, crafting a seamless interface for data operations. Prisma facilitates a sturdy, type-safe, and streamlined access to your database, ensuring that the data interactions within your applications are precise and efficient. Its robust query engine vastly simplifies database access and mitigates common bugs associated with data retrieval and manipulation.
-
-## How To Install
-
-Harnessing the capabilities of Prisma within your ExpressoTS framework is streamlined with the help of the [ExpressoTS CLI](https://github.com/expressots/expressots-cli). The CLI provides a dedicated helper to simplify the setup of Prisma, ensuring a hassle-free integration.
-
-```bash title="terminal"
-expressots add prisma
-
-- Type the prisma client version (default=latest): (latest)
-- Type the schema name (default=schema): (schema)
-- Where do you want to save your prisma schema (default=./): (.)
-- Select your database:
-  CockroachDB
-  Microsoft SQL Server
-  MongoDB
-  MySQL
-> PostgreSQL
-  SQLite
-- Do you want to install the latest recommended database driver for PostgreSQL? (Y/n)
-- Do you want to add BaseRepository Pattern in this project? this will replace the existing BaseRepository and BaseRepositoryInterface if it exists. (Y/n)
-```
-
-By following these prompts, ExpressoTS ensures a seamless installation and configuration of Prisma, tailored to your project’s needs.
-
-### Config Update
-
-Post installation, a new set of configurations pertaining to the Prisma provider are now available for you to fine-tune. These include schemaName, schemaPath, entitiesPath, and entityNamePattern. Customize these settings to align with your project’s architecture and naming conventions.
-
-```ts title="expressots.config.ts"
-import { ExpressoConfig, Pattern } from "@expressots/core";
-
-const config: ExpressoConfig = {
-    sourceRoot: "src",
-    scaffoldPattern: Pattern.KEBAB_CASE,
-    opinionated: true,
-    providers: {
-        // highlight-start
-        prisma: {
-            schemaName: "schema",
-            schemaPath: "./prisma",
-            entitiesPath: "entities",
-            entityNamePattern: "entity",
-        },
-        // highlight-end
-    },
-};
-
-export default config;
-```
-
-## Base Repository Extension
-
-During the setup process, you will be prompted to extend your existing base repository or create a new one if none exists. This includes both the interface and implementation, allowing for a standardized way to interact with your database entities.
-
-<Tabs>
-
-  <TabItem label="Interface" value="interface">
-
-```ts title="./src/repositories/base-repository.interface.ts"
-import { Prisma, PrismaClient } from "@prisma/client";
-import { CreateInput, ModelsOf, DeleteWhere, Select, PrismaAction } from "@expressots/prisma";
-
-interface IBaseRepository<ModelName extends ModelsOf<PrismaClient>> {
-    // highlight-start
-    aggregate: (args: PrismaAction<ModelName, "aggregate">) => Promise<any>;
-    count: (args: PrismaAction<ModelName, "count">) => Promise<number>;
-    // highlight-end
-    create: (
-        data:
-            | CreateInput<ModelName>["data"]
-            | {
-                  data: CreateInput<ModelName>["data"];
-                  select?: Select<ModelName, "create">["select"];
-              }
-    ) => Promise<ModelName | never>;
-    // ...
-}
-```
-
-  </TabItem>
-
-  <TabItem label="Implementation" value="implementation">
-
-```ts title="./src/repositories/base-repository.ts"
-import { PrismaClient, Prisma } from "@prisma/client";
-import {
-  CreateInput,
-  ModelsOf,
-  DeleteWhere,
-  Select,
-  PrismaAction,
-} from "@expressots/prisma";
-import { provide } from "inversify-binding-decorators";
-import { IBaseRepository } from "./base-repository.interface";
-
-@provide(BaseRepository)
-class BaseRepository<ModelName extends ModelsOf<PrismaClient>>
-  implements IBaseRepository<ModelName>
-{
-  protected prismaModel: any;
-  protected prismaClient: PrismaClient;
-  constructor(modelName: keyof PrismaClient) {
-    this.prismaClient = new PrismaClient();
-    this.prismaModel = this.prismaClient[modelName];
-  }
-
-  // highlight-start
-  async aggregate(args: PrismaAction<ModelName, "aggregate">): Promise<any> {
-    return await this.prismaModel.aggregate(args);
-  }
-  // highlight-end
-
-  // highlight-start
-  async count(args: PrismaAction<ModelName, "count">): Promise<number> {
-    return await this.prismaModel.count(args);
-  }
-  // highlight-end
-```
-
-  </TabItem>
-
-</Tabs>
-
-## Utilizing ExpressoTS Prisma Decorators
-
-We designed decorators to make it easier to use Prisma with ExpressoTS. You can use the decorators with Entities, enums and types to generate the Prisma schema automatically.
-
-### Decorators
-
-| Decorator       | Description                                    | Options                                                               |
-| --------------- | ---------------------------------------------- | --------------------------------------------------------------------- |
-| @prismaModel    | Decorate a class as a Prisma model             | map                                                                   |
-| @prismaField    | Decorate a property with specific db attribute | attr, isId, isOptional, type, isUnique, prismaDefault, mapField, name |
-| @prismaRelation | Decorate a property as a Prisma relation       | relation, name, model, refs, fields, onDelete, onUpdate, isRequired   |
-| @prismaIndex    | Decorate a property as a Prisma index          | name, fields, map, type                                               |
-
-### PrismaModel Decorator
-
-The @prismaModel() decorator is instrumental in designating a class as a Prisma model, which in turn triggers the automatic generation of the corresponding Prisma schema.
-
-Options:
-
--   `map`: The map option is available to map the class name to a different name in the Prisma schema, granting you the flexibility to adhere to naming conventions or requirements. For an in-depth understanding of the map option, refer to the Prisma documentation.
-
-Let’s illustrate this with an example drawn from the Opinionated template. Initially, the entity is structured as follows:
-
-<div style={{ display: 'flex', justifyContent: 'center', alignItems: 'center' }}>
-
-<div style={{ display: 'flex', justifyContent: 'center', alignItems: 'center' }}>
-
-```mermaid
-classDiagram
-class User {
-    +id: string
-    +name: string
-    +email: string
-    +constructor()
-}
-```
-
-</div>
-
-<div style={{ flex: 1 }}>
-
-```ts title="./src/entities/user.entity.ts"
-import { provide } from "inversify-binding-decorators";
-import { randomUUID } from "node:crypto";
-import { IEntity } from "./base.entity";
-
-// highlight-start
-@provide(User)
-export class User implements IEntity {
-    id: string;
-    name!: string;
-    email!: string;
-
-    constructor() {
-        this.id = randomUUID();
-    }
-}
-// highlight-end
-```
-
-</div>
-
-</div>
-
-The sole addition needed to begin is the `@prismaModel()` decorator to the class:
-
-<Tabs>
-
-<TabItem label="Entity" value="entity">
-
-```ts title="./src/entities/user.entity.ts"
-import { provide } from "inversify-binding-decorators";
-import { randomUUID } from "node:crypto";
-import { IEntity } from "./base.entity";
-// highlight-start
-import { prismaModel } from "@expressots/prisma";
-// highlight-end
-
-@provide(User)
-// highlight-start
-@prismaModel({ map: "user" })
-// highlight-end
-export class User implements IEntity {
-    id: string;
-    name!: string;
-    email!: string;
-
-    constructor() {
-        this.id = randomUUID();
-    }
-}
-```
-
-</TabItem>
-
-<TabItem label="Terminal" value="terminal">
-
-```bash title="Terminal"
-npm run prisma
-```
-
-</TabItem>
-
-<TabItem label="Prisma Schema" value="prisma-schema">
-
-```typescript title="./prisma/schema.prisma"
-model User {
-
-  @@map("users")
-}
-```
-
-</TabItem>
-</Tabs>
-
----
-
-Upon executing this, you might encounter an error message as shown below. This is anticipated behavior as Prisma mandates at least one unique criterion per model and we have not provided any through the decorators.
-
-```ansii
-error: Error validating model "User": Each model must have at least one unique criteria that has only required fields. Either mark a single field with `@id`, `@unique` or add a multi field criterion with `@@id([])` or `@@unique([])` to the model.
-  -->  schema.prisma:13
-   |
-12 |
-13 | model User {
-14 |
-15 |   @@map("users")
-16 | }
-   |
-```
-
-:::note
-In order to generate the Prisma model `@prismaModel()` decorator must be used. All entities must be decorated with `@prismaModel()`.
-:::
-
-### PrismaField Decorator
-
-The `@prismaField()` decorator is used to decorate a property with specific prisma attributes available in the [Prisma documentation](https://www.prisma.io/docs/reference/api-reference/prisma-schema-reference#model-fields).
-
-Options:
-
--   `attr`: You can use the `attr` option to add specific attributes to the field per database. For more information about the `attr` option, please check the [Prisma documentation](https://www.prisma.io/docs/reference/api-reference/prisma-schema-reference#model-fields).
-
-<Tabs>
-
-<TabItem label="Entity" value="entity">
-
-```ts title="./src/entities/user.entity.ts"
-import { provide } from "inversify-binding-decorators";
-import { randomUUID } from "node:crypto";
-import { IEntity } from "./base.entity";
-import { prismaModel, prismaField, db } from "@expressots/prisma";
-
-@provide(User)
-@prismaModel({ map: "users" })
-export class User implements IEntity {
-    @prismaField({ attr: db.Postgres.Uuid, isUnique: true, isId: true })
-    id: string;
-
-    @prismaField({ attr: db.Postgres.Char(36) })
-    name!: string;
-
-    @prismaField({ attr: db.Postgres.Char(36) })
-    email!: string;
-
-    constructor() {
-        this.id = randomUUID();
-    }
-}
-```
-
-</TabItem>
-
-<TabItem label="Terminal" value="terminal">
-
-```bash title="Terminal"
-npm run prisma
-```
-
-</TabItem>
-
-<TabItem label="Prisma Schema" value="prisma-schema">
-
-```typescript title="./prisma/schema.prisma"
-model User {
-  // highlight-start
-  id    String @id @unique @db.Uuid
-  name  String @db.Char(36)
-  email String @db.Char(36)
-  // highlight-end
-
-  @@map("user")
-}
-```
-
-</TabItem>
-</Tabs>
-
-:::note
-`db` is a namespace that contains all the available attributes per database.
-:::
-
-### PrismaRelation Decorator
-
-The `@prismaRelation()` decorator is a powerful feature that streamlines the creation of relationships between Prisma models. It simplifies the process by allowing the definition of relations from the perspective of the model where the relationship is most logically initiated. This means that instead of defining a foreign key in a child model, you can declare the relationship in the parent model, which can be more intuitive, especially when dealing with one-to-many (1-M) relationships.
-
-Options for `@prismaRelation()` include:
-
--   `model`: Specifies the related Prisma model.
--   `relation`: Defines the type of relationship, such as one-to-many, one-to-one, etc.
--   `refs`: An array that denotes the field(s) that the relationship is referencing.
--   `fields`: Specifies the field(s) on the model that are used for the relation.
--   `onDelete` and `onUpdate`: Define the referential actions on delete and update operations.
--   `isRequired`: Determines if the related field is required.
-
-Now, let's apply this to a specific example for better understanding.
-
-#### Example: User-Post Relationship
-
-<div style={{ display: 'flex', justifyContent: 'center', gap: '2rem' }}>
-
-<div style={{ display: "flex", width: "50%" }}>
-
-```mermaid
-classDiagram
-  class User {
-    +String id
-    +String name
-    +String email
-    +Array~Post~ posts
-  }
-  class Post {
-    +String id
-  }
-
-  User "1" --> "*" Post : has many
-```
-
-</div>
-
-<div>
-
-Consider a blogging platform where a user can author multiple posts. We want to define a one-to-many relationship from the `User` to `Post` models. From an application development perspective, it's more natural to express that a user "has many" posts than to say a post "belongs to" a user. With the `@prismaRelation()` decorator, we can directly declare this relationship on the `User` model.
-
-</div>
-
-</div>
-
-Here's how we can use the `@prismaRelation()` decorator in context:
-
-<Tabs>
-
-<TabItem label="User Entity" value="user-entity">
-
-```ts title="./src/entities/user.entity.ts"
-import { provide } from "inversify-binding-decorators";
-import { randomUUID } from "node:crypto";
-import { IEntity } from "./base.entity";
-import {
-    prismaModel,
-    prismaField,
-    // highlight-start
-    prismaRelation,
-    Relation,
-    // highlight-end
-    db,
-} from "@expressots/prisma";
-import { Post } from "./post.entity";
-
-@provide(User)
-@prismaModel({ map: "user" })
-export class User implements IEntity {
-    @prismaField({ attr: db.Postgres.Uuid, isUnique: true, isId: true })
-    id: string;
-
-    @prismaField({ attr: db.Postgres.Char(36) })
-    name!: string;
-
-    @prismaField({ attr: db.Postgres.Char(36) })
-    email!: string;
-
-    // highlight-start
-    // Define the one-to-many relationship to Post.
-    @prismaField({ type: Post })
-    @prismaRelation({
-        model: "Post",
-        relation: Relation.OneToMany,
-        refs: ["id"],
-    })
-    posts: Post[]; // This is where the User-Post relationship is expressed.
-    // highlight-end
-
-    constructor() {
-        this.id = randomUUID();
-    }
-}
-```
-
-</TabItem>
-
-<TabItem label="Post Entity" value="post-entity">
-
-```ts title="./src/entities/post.entity.ts"
-import { provide } from "inversify-binding-decorators";
-import { prismaModel, prismaField } from "@expressots/prisma";
-import { randomUUID } from "node:crypto";
-
-@prismaModel({ map: "posts" })
-@provide(Post)
-export class Post {
-    @prismaField({ isId: true })
-    id: string;
-
-    // highlight-next-line
-    // No need to explicitly define the foreign key field here; it's handled by the provider. 🥳
-
-    constructor() {
-        this.id = randomUUID();
-    }
-}
-```
-
-</TabItem>
-
-<TabItem label="Terminal" value="terminal">
-
-```bash title="Terminal"
-npm run prisma
-```
-
-</TabItem>
-
-<TabItem label="Prisma Schema" value="prisma-schema">
-
-```typescript title="./prisma/schema.prisma"
-model User {
-  id    String @id @unique @db.Uuid
-  name  String @db.Char(36)
-  email String @db.Char(36)
-  // highlight-next-line
-  posts Post[]
-
-  @@map("user")
-}
-
-model Post {
-  id     String  @id @unique @db.Uuid
-  // highlight-start
-  user   User?   @relation(fields: [userId], references: [id])
-  userId String? @unique
-  // highlight-end
-
-  @@map("posts")
-}
-```
-
-</TabItem>
-</Tabs>
-
-In this example, the `User` model uses the `@prismaRelation()` decorator to declare its connection to multiple `Post` instances. Prisma will automatically handle the creation of the corresponding foreign key on the `Post` model, making the relationship both explicit and implicitly managed, thus reducing the potential for error and confusion.
-
-:::note
-The `@prismaRelation()` decorator's declarative syntax aligns closely with how developers conceptualize relationships in the application, providing a bridge between the object model and the underlying database schema.
-:::
-
-### PrismaIndex Decorator
-
-The `@prismaIndex()` decorator is essential for optimizing database queries by defining indexes on specific fields of a Prisma model. Indexes are special lookup tables that the database search engine can use to speed up data retrieval. Properly indexing a database can drastically improve the performance of an application.
-
-When you apply the `@prismaIndex()` decorator to a model, you provide Prisma with the information needed to create an index in the underlying database. The decorator takes an object with several options:
-
--   `name`: Specifies a name for the index, allowing for easier reference and management.
--   `fields`: Defines an array of fields to be included in the index. These are the model properties you expect to query frequently.
--   `type`: Dictates the type of index to be used, influencing how the database organizes and retrieves the data.
-
-#### Index Types
-
-The `IndexType` enum offers a selection of index types suitable for different kinds of data and query patterns:
-
--   `Brin`: Block Range Indexes are suitable for large tables in which certain columns have a linear correlation with their physical location on disk.
--   `Btree`: Balanced Tree indexes are the most common and are excellent for general use. They support equality and range queries efficiently.
--   `Gist`: Generalized Search Tree indexes support complex types like geometric data and can handle multidimensional data.
--   `Gin`: Generalized Inverted Indexes are optimized for indexing composite values where each indexed item can contain multiple component values.
--   `Hash`: Hash indexes provide fast retrieval for equality searches but do not support range queries.
--   `Spgist`: Space-partitioned Generalized Search Tree indexes are good for data that does not fit well into a B-tree structure, such as telephone numbers or IP addresses.
-
-Each index type comes with its own performance characteristics and is optimized for specific kinds of queries and data patterns. Choosing the right index type is crucial for the performance of read operations and, consequently, the overall application performance.
-
-#### Example Usage
-
-Below is an example of how to use the `@prismaIndex()` decorator to define a hash index on the `email` field of a `User` model, which would speed up queries that search for users by their email addresses:
-
-<Tabs>
-
-<TabItem label="Entity" value="entity">
-
-```ts title="./src/entities/user.entity.ts"
-import {
-    prismaModel,
-    prismaField,
-    prismaRelation,
-    // highlight-next-line
-    prismaIndex,
-    Relation,
-    // highlight-next-line
-    IndexType,
-    db,
-} from "@expressots/prisma";
-
-@provide(User)
-@prismaModel({ map: "user" })
-// highlight-next-line
-@prismaIndex({ name: "emailIndex", fields: ["email"], type: IndexType.Hash })
-export class User implements IEntity {
-    // ...
-
-    // highlight-next-line
-    @prismaField({ attr: db.Postgres.Char(36), isUnique: true })
-    email!: string;
-}
-```
-
-</TabItem>
-
-<TabItem label="Terminal" value="terminal">
-
-```bash title="Terminal"
-npm run prisma
-```
-
-</TabItem>
-
-<TabItem label="Prisma Schema" value="prisma-schema">
-
-```prisma title="./prisma/schema.prisma"
-model User {
-  email String @db.Char(36)
-
-  @@unique([id, email])
-  @@index([email], name: "emailIndex", type: Hash)
-  @@map("user")
-}
-```
-
-</TabItem>
-</Tabs>
-
-:::note
-Indexes are crucial for optimizing your database, but they should be used judiciously as they can affect write performance and consume additional storage.
-:::
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
--   Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
--   Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
--   Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Join our **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Share the project with your friends and colleagues
diff --git a/docs/roadmap.md b/docs/roadmap.md
deleted file mode 100644
index c45222d6..00000000
--- a/docs/roadmap.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-sidebar_position: 7
----
-
-# Roadmap
-
-Coming soon...
-
----
-
-## Support the Project
-
-ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support. If you'd like to help, please consider:
-
-- Become a **[sponsor on GitHub](https://github.com/sponsors/expressots)**
-- Follow the **[organization](https://github.com/expressots)** on GitHub and Star ⭐ the project
-- Subscribe to the Twitch channel: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Join our **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribute submitting **[issues and pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Share the project with your friends and colleagues
diff --git a/docs/roadmap.mdx b/docs/roadmap.mdx
new file mode 100644
index 00000000..46517874
--- /dev/null
+++ b/docs/roadmap.mdx
@@ -0,0 +1,65 @@
+---
+sidebar_position: 5
+title: ROADMAP
+---
+
+# Roadmap
+
+The roadmap is a high-level overview of the upcoming features and improvements we plan to make to ExpressoTS. It is a living document and will be updated as we complete work and plan for future releases.
+
+There are also many features and improvements that are not listed here because they are either too small to mention or we have not yet decided when they will be exposed to the public.
+
+## Working packages
+
+Working packages are a way to group related tasks together. They are a way to organize the work that needs to be done and to help us prioritize what to work on next.
+
+![Roadmap Components](./core/img/roadmap-component.png)
+
+> -   **Enhanced:** ExpressoTS streamlined workflow and improved the developer experience.
+
+> -   **Support:** ExpressoTS supports the feature and provides the necessary tools to use it.
+
+> -   **Non existent:** The feature is not yet available in ExpressoTS but maybe is in development or planned.
+
+## Timeline
+
+The timeline is a rough estimate of when we expect to complete the work. It is not a guarantee, and the actual timeline may vary.
+
+-   Q1: January - March
+-   Q2: April - June
+-   Q3: July - September
+-   Q4: October - December
+
+---
+
+**2024/Q3**
+
+| Feature              | Description                                                                                                    |
+| -------------------- | -------------------------------------------------------------------------------------------------------------- |
+| Documentation update | Update the documentation to reflect the latest changes in ExpressoTS and streamlight the developer experience. |
+| Improved CLI         | Enhance the CLI performance and supply scaffold resource tools.                                                |
+| Core improvements    | Improve the core of ExpressoTS to provide better performance and stability.                                    |
+| Provider store       | Implement a provider store to allow better ExpressoTS providers management.                                    |
+| Study of AI          | Study the implementation of AI in ExpressoTS.                                                                  |
+| Continue marketing   | Continue marketing efforts to increase the ExpressoTS community.                                               |
+| UBC Presentation     | Present ExpressoTS at the University of British Columbia.                                                      |
+
+---
+
+**2024/Q4**
+
+| Feature                    | Description                                                      |
+| -------------------------- | ---------------------------------------------------------------- |
+| QA Framework               | Implement a QA framework to facilitate the testing process.      |
+| Real time                  | Implement real-time features in ExpressoTS.                      |
+| API Doc                    | Implement an API documentation tool and Open API standards       |
+| QA Training and Onboarding | Discuss and build QA Team to implement the QA Framework.         |
+| New Contributors           | Onboard new contributors to the ExpressoTS project.              |
+| Continue marketing         | Continue marketing efforts to increase the ExpressoTS community. |
+
+---
+
+## Support us ❤️
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+If you'd like to help, please read our **[support guide](./support-us.mdx)**.
diff --git a/docs/support-us.mdx b/docs/support-us.mdx
new file mode 100644
index 00000000..d8086d24
--- /dev/null
+++ b/docs/support-us.mdx
@@ -0,0 +1,31 @@
+---
+sidebar_position: 7
+title: SUPPORT US ❤️
+---
+
+# Support us
+
+ExpressoTS is an MIT-licensed open source project. It's an independent project with ongoing development made possible thanks to your support.
+
+Your support, in any form, is greatly appreciated. Together, we can make Expresso<span class="span-table">TS</span> the go-to framework for developers around the world.
+
+## How you can support us
+
+There are several ways you can support the growth and development of ExpressoTS:
+
+-   **[Become a Sponsor on GitHub](https://github.com/sponsors/expressots)**: Financial support helps us allocate more time and resources to the project, accelerating its growth and enabling us to bring new features and improvements faster.
+
+-   **[Follow and Star the Project on GitHub](https://github.com/expressots/expressots)**  
+    Show your support by following our organization on GitHub and starring ⭐ the project. This helps increase our visibility and attract more contributors.
+
+-   **[Join our Community on LinkedIn](https://www.linkedin.com/company/expresso-ts/?viewAsMember=true)**: Join the community on LinkedIn to stay up-to-date with the latest news, updates, and events related to ExpressoTS.
+
+-   **[Join Our Discord Community](https://discord.com/invite/PyPJfGK)**: Connect with other ExpressoTS users and contributors on Discord]. Share your experiences, ask questions, and get involved in discussions about the framework.
+
+-   **<span class="span-table">Spread the Word</span>**: Share ExpressoTS with your friends and colleagues. The more people use and contribute to the project, the better it becomes!
+
+## Thank you! ❤️
+
+Thank you for being a part of our journey!
+
+If you have any questions or suggestions, feel free to reach out to us on **[Discord](https://discord.com/invite/PyPJfGK)**. We'd love to hear from you!
diff --git a/docs/tutorials/_category_.json b/docs/tutorials/_category_.json
deleted file mode 100644
index de8ac4f4..00000000
--- a/docs/tutorials/_category_.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "label": "Tutorials",
-  "position": 6,
-  "link": {
-    "type": "generated-index",
-    "description": "Expresso TS Tutorials."
-  }
-}
diff --git a/docusaurus.config.ts b/docusaurus.config.ts
index c50098f3..799afa82 100644
--- a/docusaurus.config.ts
+++ b/docusaurus.config.ts
@@ -1,51 +1,10 @@
 import * as Preset from "@docusaurus/preset-classic";
 import type { Config } from "@docusaurus/types";
-import { themes } from "prism-react-renderer";
-import axios from "axios";
-
-const coreVersion = async (): Promise<string> => {
-    try {
-        const response = await axios.get(
-            "https://api.github.com/repos/expressots/expressots/releases"
-        );
-        const latestRelease = response.data[0];
-        return latestRelease.tag_name;
-    } catch (error) {
-        console.error("Error fetching current version from GitHub:", error);
-        return "2.0.0"; // Fallback version
-    }
-};
-
-const adapterVersion = async (): Promise<string> => {
-    try {
-        const response = await axios.get(
-            "https://api.github.com/repos/expressots/adapter-express/releases"
-        );
-
-        const latestRelease = response.data[0];
-        return latestRelease.tag_name;
-    } catch (error) {
-        console.error("Error fetching current version from GitHub:", error);
-        return "2.0.0"; // Fallback version
-    }
-};
-
-const cliVersion = async (): Promise<string> => {
-    try {
-        const response = await axios.get(
-            "https://api.github.com/repos/expressots/expressots-cli/releases"
-        );
-
-        const latestRelease = response.data[0];
-        return latestRelease.tag_name;
-    } catch (error) {
-        console.error("Error fetching current version from GitHub:", error);
-        return "2.0.0"; // Fallback version
-    }
-};
+import expressotsDarkTheme from "./src/css/prism.dark-theme";
+import expressotsLightTheme from "./src/css/prism.light-theme";
 
 const config: Config = {
-    title: "Expresso TS",
+    title: "ExpressoTS",
     tagline: "A lightweight, fast and easy to use TypeScript framework",
     favicon: "img/favicon.ico",
 
@@ -57,20 +16,12 @@ const config: Config = {
     deploymentBranch: "gh-pages",
     trailingSlash: false,
 
-    onBrokenLinks: "throw", // 'throw' | 'warn' | 'ignore'
+    onBrokenLinks: "warn", // 'throw' | 'warn' | 'ignore'
     onBrokenMarkdownLinks: "warn",
 
     i18n: {
         defaultLocale: "en",
-        locales: ["en", "pt"],
-        localeConfigs: {
-            en: {
-                label: "English",
-            },
-            pt: {
-                label: "Português",
-            },
-        },
+        locales: ["en"],
     },
 
     presets: [
@@ -99,8 +50,8 @@ const config: Config = {
             },
         ],
         colorMode: {
-            defaultMode: "light",
-            disableSwitch: false,
+            defaultMode: "dark",
+            disableSwitch: true,
             respectPrefersColorScheme: false,
         },
         algolia: {
@@ -111,19 +62,13 @@ const config: Config = {
             appId: "3UANWN5EUQ",
         },
         navbar: {
-            title: "Expresso TS",
-            hideOnScroll: true,
+            title: "ExpressoTS",
+            hideOnScroll: false,
             logo: {
-                alt: "Expresso TS",
+                alt: "ExpressoTS",
                 src: "img/logo.png",
             },
             items: [
-                {
-                    type: "doc",
-                    docId: "hello",
-                    position: "right",
-                    label: "Documentation",
-                },
                 {
                     type: "doc",
                     docId: "governance",
@@ -132,14 +77,19 @@ const config: Config = {
                 },
                 {
                     href: "https://github.com/expressots/expressots",
-                    label: "GitHub",
                     position: "right",
                     "aria-label": "GitHub repository",
+                    className: "header-github-link",
                 },
                 {
-                    type: "localeDropdown",
-                    label: "Language",
+                    href: "https://www.linkedin.com/company/expresso-ts/?viewAsMember=true",
                     position: "right",
+                    "aria-label": "LinkedIn profile",
+                    className: "header-linkedin-link",
+                },
+                {
+                    type: "search",
+                    position: "left",
                 },
             ],
         },
@@ -157,7 +107,7 @@ const config: Config = {
                     items: [
                         {
                             label: "Tutorial",
-                            to: "docs/category/tutorials",
+                            to: "docs/category/guides",
                         },
                     ],
                 },
@@ -165,8 +115,16 @@ const config: Config = {
                     title: "Community",
                     items: [
                         {
-                            label: "Twitch TV",
-                            href: "https://www.twitch.tv/richardzampieri",
+                            label: "LinkedIn",
+                            href: "https://www.linkedin.com/company/expresso-ts/?viewAsMember=true",
+                        },
+                        {
+                            label: "X (Twitter)",
+                            href: "https://twitter.com/expressots",
+                        },
+                        {
+                            label: "Discord",
+                            href: "https://discord.gg/PyPJfGK",
                         },
                     ],
                 },
@@ -191,8 +149,8 @@ const config: Config = {
             copyright: `Copyright © ${new Date().getFullYear()} Official ExpressoTS, Released under the MIT License.`,
         },
         prism: {
-            theme: themes.github,
-            darkTheme: themes.vsDark,
+            theme: expressotsLightTheme,
+            darkTheme: expressotsDarkTheme,
         },
     } satisfies Preset.ThemeConfig,
     themes: ["@docusaurus/theme-mermaid"],
@@ -201,17 +159,4 @@ const config: Config = {
     },
 };
 
-export default async function asyncConfig(): Promise<Config> {
-    const core = await coreVersion();
-    const adapter = await adapterVersion();
-    const cli = await cliVersion();
-
-    config.themeConfig.announcementBar = {
-        id: "supportus",
-        content: `@core v${core} / @adapter-express v${adapter} / @cli v${cli}`,
-        backgroundColor: "#111",
-        textColor: "#19CE59",
-        isCloseable: false,
-    };
-    return config;
-}
+export default config;
diff --git a/i18n/en/code.json b/i18n/en/code.json
index 9ccc26c5..962c79f4 100644
--- a/i18n/en/code.json
+++ b/i18n/en/code.json
@@ -1,308 +1,308 @@
 {
-  "tagline": {
-    "message": "A lightweight, fast and easy to use TypeScript framework"
-    },
-  "homepageTitle": {
-    "message": "Expresso TS",
-    "description": "Title for the homepage"
-  },
-  "homepageDocumentation": {
-    "message": "Documentation"
-  },
-  "homepageSourceCode": {
-    "message": "Source code"
-  },
-  "featuresEasyToUse": {
-    "message": "Easy to Use"
-  },
-  "featuresEasyToUseDesc": {
-    "message": "Built on a modular architecture and designed with simplicity in mind, it empowers developers to quickly create powerful applications."
-  },
-  "featuresFocusOnWhatMatters": {
-    "message": "Focus on What Matters"
-  },
-  "featuresFocusOnWhatMattersDesc": {
-    "message": "You can stop worrying about repetitive boilerplate tasks and focus on what really matters - coding your business logic and delivering a high-quality product."
-  },
-  "featuresExtensible": {
-    "message": "Extensible"
-  },
-  "featuresExtensibleDesc": {
-    "message": "Ability to easily create adapters/providers that seamlessly integrate with the rest of the application.",
-    "description": "Description for the Extensible feature"
-  },
-  "Ability to easily create adapters/providers that seamlessly integrate with the rest of the application.": {
-    "message": "Ability to easily create adapters/providers that seamlessly integrate with the rest of the application."
-  },
-  "theme.ErrorPageContent.title": {
-    "message": "This page crashed.",
-    "description": "The title of the fallback page when the page crashed"
-  },
-  "theme.NotFound.title": {
-    "message": "Page Not Found",
-    "description": "The title of the 404 page"
-  },
-  "theme.NotFound.p1": {
-    "message": "We could not find what you were looking for.",
-    "description": "The first paragraph of the 404 page"
-  },
-  "theme.NotFound.p2": {
-    "message": "Please contact the owner of the site that linked you to the original URL and let them know their link is broken.",
-    "description": "The 2nd paragraph of the 404 page"
-  },
-  "theme.admonition.note": {
-    "message": "note",
-    "description": "The default label used for the Note admonition (:::note)"
-  },
-  "theme.admonition.tip": {
-    "message": "tip",
-    "description": "The default label used for the Tip admonition (:::tip)"
-  },
-  "theme.admonition.danger": {
-    "message": "danger",
-    "description": "The default label used for the Danger admonition (:::danger)"
-  },
-  "theme.admonition.info": {
-    "message": "info",
-    "description": "The default label used for the Info admonition (:::info)"
-  },
-  "theme.admonition.caution": {
-    "message": "caution",
-    "description": "The default label used for the Caution admonition (:::caution)"
-  },
-  "theme.BackToTopButton.buttonAriaLabel": {
-    "message": "Scroll back to top",
-    "description": "The ARIA label for the back to top button"
-  },
-  "theme.blog.archive.title": {
-    "message": "Archive",
-    "description": "The page & hero title of the blog archive page"
-  },
-  "theme.blog.archive.description": {
-    "message": "Archive",
-    "description": "The page & hero description of the blog archive page"
-  },
-  "theme.blog.paginator.navAriaLabel": {
-    "message": "Blog list page navigation",
-    "description": "The ARIA label for the blog pagination"
-  },
-  "theme.blog.paginator.newerEntries": {
-    "message": "Newer Entries",
-    "description": "The label used to navigate to the newer blog posts page (previous page)"
-  },
-  "theme.blog.paginator.olderEntries": {
-    "message": "Older Entries",
-    "description": "The label used to navigate to the older blog posts page (next page)"
-  },
-  "theme.blog.post.paginator.navAriaLabel": {
-    "message": "Blog post page navigation",
-    "description": "The ARIA label for the blog posts pagination"
-  },
-  "theme.blog.post.paginator.newerPost": {
-    "message": "Newer Post",
-    "description": "The blog post button label to navigate to the newer/previous post"
-  },
-  "theme.blog.post.paginator.olderPost": {
-    "message": "Older Post",
-    "description": "The blog post button label to navigate to the older/next post"
-  },
-  "theme.blog.post.plurals": {
-    "message": "One post|{count} posts",
-    "description": "Pluralized label for \"{count} posts\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
-  },
-  "theme.blog.tagTitle": {
-    "message": "{nPosts} tagged with \"{tagName}\"",
-    "description": "The title of the page for a blog tag"
-  },
-  "theme.tags.tagsPageLink": {
-    "message": "View All Tags",
-    "description": "The label of the link targeting the tag list page"
-  },
-  "theme.colorToggle.ariaLabel": {
-    "message": "Switch between dark and light mode (currently {mode})",
-    "description": "The ARIA label for the navbar color mode toggle"
-  },
-  "theme.colorToggle.ariaLabel.mode.dark": {
-    "message": "dark mode",
-    "description": "The name for the dark color mode"
-  },
-  "theme.colorToggle.ariaLabel.mode.light": {
-    "message": "light mode",
-    "description": "The name for the light color mode"
-  },
-  "theme.docs.breadcrumbs.navAriaLabel": {
-    "message": "Breadcrumbs",
-    "description": "The ARIA label for the breadcrumbs"
-  },
-  "theme.docs.DocCard.categoryDescription": {
-    "message": "{count} items",
-    "description": "The default description for a category card in the generated index about how many items this category includes"
-  },
-  "theme.docs.paginator.navAriaLabel": {
-    "message": "Docs pages navigation",
-    "description": "The ARIA label for the docs pagination"
-  },
-  "theme.docs.paginator.previous": {
-    "message": "Previous",
-    "description": "The label used to navigate to the previous doc"
-  },
-  "theme.docs.paginator.next": {
-    "message": "Next",
-    "description": "The label used to navigate to the next doc"
-  },
-  "theme.docs.tagDocListPageTitle.nDocsTagged": {
-    "message": "One doc tagged|{count} docs tagged",
-    "description": "Pluralized label for \"{count} docs tagged\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
-  },
-  "theme.docs.tagDocListPageTitle": {
-    "message": "{nDocsTagged} with \"{tagName}\"",
-    "description": "The title of the page for a docs tag"
-  },
-  "theme.docs.versionBadge.label": {
-    "message": "Version: {versionLabel}"
-  },
-  "theme.docs.versions.unreleasedVersionLabel": {
-    "message": "This is unreleased documentation for {siteTitle} {versionLabel} version.",
-    "description": "The label used to tell the user that he's browsing an unreleased doc version"
-  },
-  "theme.docs.versions.unmaintainedVersionLabel": {
-    "message": "This is documentation for {siteTitle} {versionLabel}, which is no longer actively maintained.",
-    "description": "The label used to tell the user that he's browsing an unmaintained doc version"
-  },
-  "theme.docs.versions.latestVersionSuggestionLabel": {
-    "message": "For up-to-date documentation, see the {latestVersionLink} ({versionLabel}).",
-    "description": "The label used to tell the user to check the latest version"
-  },
-  "theme.docs.versions.latestVersionLinkLabel": {
-    "message": "latest version",
-    "description": "The label used for the latest version suggestion link label"
-  },
-  "theme.common.editThisPage": {
-    "message": "Edit this page",
-    "description": "The link label to edit the current page"
-  },
-  "theme.common.headingLinkTitle": {
-    "message": "Direct link to {heading}",
-    "description": "Title for link to heading"
-  },
-  "theme.lastUpdated.atDate": {
-    "message": " on {date}",
-    "description": "The words used to describe on which date a page has been last updated"
-  },
-  "theme.lastUpdated.byUser": {
-    "message": " by {user}",
-    "description": "The words used to describe by who the page has been last updated"
-  },
-  "theme.lastUpdated.lastUpdatedAtBy": {
-    "message": "Last updated{atDate}{byUser}",
-    "description": "The sentence used to display when a page has been last updated, and by who"
-  },
-  "theme.navbar.mobileVersionsDropdown.label": {
-    "message": "Versions",
-    "description": "The label for the navbar versions dropdown on mobile view"
-  },
-  "theme.tags.tagsListLabel": {
-    "message": "Tags:",
-    "description": "The label alongside a tag list"
-  },
-  "theme.AnnouncementBar.closeButtonAriaLabel": {
-    "message": "Close",
-    "description": "The ARIA label for close button of announcement bar"
-  },
-  "theme.blog.sidebar.navAriaLabel": {
-    "message": "Blog recent posts navigation",
-    "description": "The ARIA label for recent posts in the blog sidebar"
-  },
-  "theme.CodeBlock.copied": {
-    "message": "Copied",
-    "description": "The copied button label on code blocks"
-  },
-  "theme.CodeBlock.copyButtonAriaLabel": {
-    "message": "Copy code to clipboard",
-    "description": "The ARIA label for copy code blocks button"
-  },
-  "theme.CodeBlock.copy": {
-    "message": "Copy",
-    "description": "The copy button label on code blocks"
-  },
-  "theme.CodeBlock.wordWrapToggle": {
-    "message": "Toggle word wrap",
-    "description": "The title attribute for toggle word wrapping button of code block lines"
-  },
-  "theme.DocSidebarItem.toggleCollapsedCategoryAriaLabel": {
-    "message": "Toggle the collapsible sidebar category '{label}'",
-    "description": "The ARIA label to toggle the collapsible sidebar category"
-  },
-  "theme.NavBar.navAriaLabel": {
-    "message": "Main",
-    "description": "The ARIA label for the main navigation"
-  },
-  "theme.navbar.mobileLanguageDropdown.label": {
-    "message": "Languages",
-    "description": "The label for the mobile language switcher dropdown"
-  },
-  "theme.TOCCollapsible.toggleButtonLabel": {
-    "message": "On this page",
-    "description": "The label used by the button on the collapsible TOC component"
-  },
-  "theme.blog.post.readMore": {
-    "message": "Read More",
-    "description": "The label used in blog post item excerpts to link to full blog posts"
-  },
-  "theme.blog.post.readMoreLabel": {
-    "message": "Read more about {title}",
-    "description": "The ARIA label for the link to full blog posts from excerpts"
-  },
-  "theme.blog.post.readingTime.plurals": {
-    "message": "One min read|{readingTime} min read",
-    "description": "Pluralized label for \"{readingTime} min read\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
-  },
-  "theme.docs.breadcrumbs.home": {
-    "message": "Home page",
-    "description": "The ARIA label for the home page in the breadcrumbs"
-  },
-  "theme.docs.sidebar.collapseButtonTitle": {
-    "message": "Collapse sidebar",
-    "description": "The title attribute for collapse button of doc sidebar"
-  },
-  "theme.docs.sidebar.collapseButtonAriaLabel": {
-    "message": "Collapse sidebar",
-    "description": "The title attribute for collapse button of doc sidebar"
-  },
-  "theme.docs.sidebar.navAriaLabel": {
-    "message": "Docs sidebar",
-    "description": "The ARIA label for the sidebar navigation"
-  },
-  "theme.docs.sidebar.closeSidebarButtonAriaLabel": {
-    "message": "Close navigation bar",
-    "description": "The ARIA label for close button of mobile sidebar"
-  },
-  "theme.navbar.mobileSidebarSecondaryMenu.backButtonLabel": {
-    "message": "← Back to main menu",
-    "description": "The label of the back button to return to main menu, inside the mobile navbar sidebar secondary menu (notably used to display the docs sidebar)"
-  },
-  "theme.docs.sidebar.toggleSidebarButtonAriaLabel": {
-    "message": "Toggle navigation bar",
-    "description": "The ARIA label for hamburger menu button of mobile navigation"
-  },
-  "theme.docs.sidebar.expandButtonTitle": {
-    "message": "Expand sidebar",
-    "description": "The ARIA label and title attribute for expand button of doc sidebar"
-  },
-  "theme.docs.sidebar.expandButtonAriaLabel": {
-    "message": "Expand sidebar",
-    "description": "The ARIA label and title attribute for expand button of doc sidebar"
-  },
-  "theme.ErrorPageContent.tryAgain": {
-    "message": "Try again",
-    "description": "The label of the button to try again rendering when the React error boundary captures an error"
-  },
-  "theme.common.skipToMainContent": {
-    "message": "Skip to main content",
-    "description": "The skip to content label used for accessibility, allowing to rapidly navigate to main content with keyboard tab/enter navigation"
-  },
-  "theme.tags.tagsPageTitle": {
-    "message": "Tags",
-    "description": "The title of the tag list page"
-  }
+    "tagline": {
+        "message": "A lightweight, fast and easy to use TypeScript framework"
+    },
+    "homepageTitle": {
+        "message": "ExpressoTS",
+        "description": "Title for the homepage"
+    },
+    "homepageDocumentation": {
+        "message": "Documentation"
+    },
+    "homepageSourceCode": {
+        "message": "Source code"
+    },
+    "featuresEasyToUse": {
+        "message": "Easy to Use"
+    },
+    "featuresEasyToUseDesc": {
+        "message": "Built on a modular architecture and designed with simplicity in mind, it empowers developers to quickly create powerful applications."
+    },
+    "featuresFocusOnWhatMatters": {
+        "message": "Focus on What Matters"
+    },
+    "featuresFocusOnWhatMattersDesc": {
+        "message": "You can stop worrying about repetitive boilerplate tasks and focus on what really matters - coding your business logic and delivering a high-quality product."
+    },
+    "featuresExtensible": {
+        "message": "Extensible"
+    },
+    "featuresExtensibleDesc": {
+        "message": "Ability to easily create adapters/providers that seamlessly integrate with the rest of the application.",
+        "description": "Description for the Extensible feature"
+    },
+    "Ability to easily create adapters/providers that seamlessly integrate with the rest of the application.": {
+        "message": "Ability to easily create adapters/providers that seamlessly integrate with the rest of the application."
+    },
+    "theme.ErrorPageContent.title": {
+        "message": "This page crashed.",
+        "description": "The title of the fallback page when the page crashed"
+    },
+    "theme.NotFound.title": {
+        "message": "Page Not Found",
+        "description": "The title of the 404 page"
+    },
+    "theme.NotFound.p1": {
+        "message": "We could not find what you were looking for.",
+        "description": "The first paragraph of the 404 page"
+    },
+    "theme.NotFound.p2": {
+        "message": "Please contact the owner of the site that linked you to the original URL and let them know their link is broken.",
+        "description": "The 2nd paragraph of the 404 page"
+    },
+    "theme.admonition.note": {
+        "message": "note",
+        "description": "The default label used for the Note admonition (:::note)"
+    },
+    "theme.admonition.tip": {
+        "message": "tip",
+        "description": "The default label used for the Tip admonition (:::tip)"
+    },
+    "theme.admonition.danger": {
+        "message": "danger",
+        "description": "The default label used for the Danger admonition (:::danger)"
+    },
+    "theme.admonition.info": {
+        "message": "info",
+        "description": "The default label used for the Info admonition (:::info)"
+    },
+    "theme.admonition.caution": {
+        "message": "caution",
+        "description": "The default label used for the Caution admonition (:::caution)"
+    },
+    "theme.BackToTopButton.buttonAriaLabel": {
+        "message": "Scroll back to top",
+        "description": "The ARIA label for the back to top button"
+    },
+    "theme.blog.archive.title": {
+        "message": "Archive",
+        "description": "The page & hero title of the blog archive page"
+    },
+    "theme.blog.archive.description": {
+        "message": "Archive",
+        "description": "The page & hero description of the blog archive page"
+    },
+    "theme.blog.paginator.navAriaLabel": {
+        "message": "Blog list page navigation",
+        "description": "The ARIA label for the blog pagination"
+    },
+    "theme.blog.paginator.newerEntries": {
+        "message": "Newer Entries",
+        "description": "The label used to navigate to the newer blog posts page (previous page)"
+    },
+    "theme.blog.paginator.olderEntries": {
+        "message": "Older Entries",
+        "description": "The label used to navigate to the older blog posts page (next page)"
+    },
+    "theme.blog.post.paginator.navAriaLabel": {
+        "message": "Blog post page navigation",
+        "description": "The ARIA label for the blog posts pagination"
+    },
+    "theme.blog.post.paginator.newerPost": {
+        "message": "Newer Post",
+        "description": "The blog post button label to navigate to the newer/previous post"
+    },
+    "theme.blog.post.paginator.olderPost": {
+        "message": "Older Post",
+        "description": "The blog post button label to navigate to the older/next post"
+    },
+    "theme.blog.post.plurals": {
+        "message": "One post|{count} posts",
+        "description": "Pluralized label for \"{count} posts\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
+    },
+    "theme.blog.tagTitle": {
+        "message": "{nPosts} tagged with \"{tagName}\"",
+        "description": "The title of the page for a blog tag"
+    },
+    "theme.tags.tagsPageLink": {
+        "message": "View All Tags",
+        "description": "The label of the link targeting the tag list page"
+    },
+    "theme.colorToggle.ariaLabel": {
+        "message": "Switch between dark and light mode (currently {mode})",
+        "description": "The ARIA label for the navbar color mode toggle"
+    },
+    "theme.colorToggle.ariaLabel.mode.dark": {
+        "message": "dark mode",
+        "description": "The name for the dark color mode"
+    },
+    "theme.colorToggle.ariaLabel.mode.light": {
+        "message": "light mode",
+        "description": "The name for the light color mode"
+    },
+    "theme.docs.breadcrumbs.navAriaLabel": {
+        "message": "Breadcrumbs",
+        "description": "The ARIA label for the breadcrumbs"
+    },
+    "theme.docs.DocCard.categoryDescription": {
+        "message": "{count} items",
+        "description": "The default description for a category card in the generated index about how many items this category includes"
+    },
+    "theme.docs.paginator.navAriaLabel": {
+        "message": "Docs pages navigation",
+        "description": "The ARIA label for the docs pagination"
+    },
+    "theme.docs.paginator.previous": {
+        "message": "Previous",
+        "description": "The label used to navigate to the previous doc"
+    },
+    "theme.docs.paginator.next": {
+        "message": "Next",
+        "description": "The label used to navigate to the next doc"
+    },
+    "theme.docs.tagDocListPageTitle.nDocsTagged": {
+        "message": "One doc tagged|{count} docs tagged",
+        "description": "Pluralized label for \"{count} docs tagged\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
+    },
+    "theme.docs.tagDocListPageTitle": {
+        "message": "{nDocsTagged} with \"{tagName}\"",
+        "description": "The title of the page for a docs tag"
+    },
+    "theme.docs.versionBadge.label": {
+        "message": "Version: {versionLabel}"
+    },
+    "theme.docs.versions.unreleasedVersionLabel": {
+        "message": "This is unreleased documentation for {siteTitle} {versionLabel} version.",
+        "description": "The label used to tell the user that he's browsing an unreleased doc version"
+    },
+    "theme.docs.versions.unmaintainedVersionLabel": {
+        "message": "This is documentation for {siteTitle} {versionLabel}, which is no longer actively maintained.",
+        "description": "The label used to tell the user that he's browsing an unmaintained doc version"
+    },
+    "theme.docs.versions.latestVersionSuggestionLabel": {
+        "message": "For up-to-date documentation, see the {latestVersionLink} ({versionLabel}).",
+        "description": "The label used to tell the user to check the latest version"
+    },
+    "theme.docs.versions.latestVersionLinkLabel": {
+        "message": "latest version",
+        "description": "The label used for the latest version suggestion link label"
+    },
+    "theme.common.editThisPage": {
+        "message": "Edit this page",
+        "description": "The link label to edit the current page"
+    },
+    "theme.common.headingLinkTitle": {
+        "message": "Direct link to {heading}",
+        "description": "Title for link to heading"
+    },
+    "theme.lastUpdated.atDate": {
+        "message": " on {date}",
+        "description": "The words used to describe on which date a page has been last updated"
+    },
+    "theme.lastUpdated.byUser": {
+        "message": " by {user}",
+        "description": "The words used to describe by who the page has been last updated"
+    },
+    "theme.lastUpdated.lastUpdatedAtBy": {
+        "message": "Last updated{atDate}{byUser}",
+        "description": "The sentence used to display when a page has been last updated, and by who"
+    },
+    "theme.navbar.mobileVersionsDropdown.label": {
+        "message": "Versions",
+        "description": "The label for the navbar versions dropdown on mobile view"
+    },
+    "theme.tags.tagsListLabel": {
+        "message": "Tags:",
+        "description": "The label alongside a tag list"
+    },
+    "theme.AnnouncementBar.closeButtonAriaLabel": {
+        "message": "Close",
+        "description": "The ARIA label for close button of announcement bar"
+    },
+    "theme.blog.sidebar.navAriaLabel": {
+        "message": "Blog recent posts navigation",
+        "description": "The ARIA label for recent posts in the blog sidebar"
+    },
+    "theme.CodeBlock.copied": {
+        "message": "Copied",
+        "description": "The copied button label on code blocks"
+    },
+    "theme.CodeBlock.copyButtonAriaLabel": {
+        "message": "Copy code to clipboard",
+        "description": "The ARIA label for copy code blocks button"
+    },
+    "theme.CodeBlock.copy": {
+        "message": "Copy",
+        "description": "The copy button label on code blocks"
+    },
+    "theme.CodeBlock.wordWrapToggle": {
+        "message": "Toggle word wrap",
+        "description": "The title attribute for toggle word wrapping button of code block lines"
+    },
+    "theme.DocSidebarItem.toggleCollapsedCategoryAriaLabel": {
+        "message": "Toggle the collapsible sidebar category '{label}'",
+        "description": "The ARIA label to toggle the collapsible sidebar category"
+    },
+    "theme.NavBar.navAriaLabel": {
+        "message": "Main",
+        "description": "The ARIA label for the main navigation"
+    },
+    "theme.navbar.mobileLanguageDropdown.label": {
+        "message": "Languages",
+        "description": "The label for the mobile language switcher dropdown"
+    },
+    "theme.TOCCollapsible.toggleButtonLabel": {
+        "message": "On this page",
+        "description": "The label used by the button on the collapsible TOC component"
+    },
+    "theme.blog.post.readMore": {
+        "message": "Read More",
+        "description": "The label used in blog post item excerpts to link to full blog posts"
+    },
+    "theme.blog.post.readMoreLabel": {
+        "message": "Read more about {title}",
+        "description": "The ARIA label for the link to full blog posts from excerpts"
+    },
+    "theme.blog.post.readingTime.plurals": {
+        "message": "One min read|{readingTime} min read",
+        "description": "Pluralized label for \"{readingTime} min read\". Use as much plural forms (separated by \"|\") as your language support (see https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
+    },
+    "theme.docs.breadcrumbs.home": {
+        "message": "Home page",
+        "description": "The ARIA label for the home page in the breadcrumbs"
+    },
+    "theme.docs.sidebar.collapseButtonTitle": {
+        "message": "Collapse sidebar",
+        "description": "The title attribute for collapse button of doc sidebar"
+    },
+    "theme.docs.sidebar.collapseButtonAriaLabel": {
+        "message": "Collapse sidebar",
+        "description": "The title attribute for collapse button of doc sidebar"
+    },
+    "theme.docs.sidebar.navAriaLabel": {
+        "message": "Docs sidebar",
+        "description": "The ARIA label for the sidebar navigation"
+    },
+    "theme.docs.sidebar.closeSidebarButtonAriaLabel": {
+        "message": "Close navigation bar",
+        "description": "The ARIA label for close button of mobile sidebar"
+    },
+    "theme.navbar.mobileSidebarSecondaryMenu.backButtonLabel": {
+        "message": "← Back to main menu",
+        "description": "The label of the back button to return to main menu, inside the mobile navbar sidebar secondary menu (notably used to display the docs sidebar)"
+    },
+    "theme.docs.sidebar.toggleSidebarButtonAriaLabel": {
+        "message": "Toggle navigation bar",
+        "description": "The ARIA label for hamburger menu button of mobile navigation"
+    },
+    "theme.docs.sidebar.expandButtonTitle": {
+        "message": "Expand sidebar",
+        "description": "The ARIA label and title attribute for expand button of doc sidebar"
+    },
+    "theme.docs.sidebar.expandButtonAriaLabel": {
+        "message": "Expand sidebar",
+        "description": "The ARIA label and title attribute for expand button of doc sidebar"
+    },
+    "theme.ErrorPageContent.tryAgain": {
+        "message": "Try again",
+        "description": "The label of the button to try again rendering when the React error boundary captures an error"
+    },
+    "theme.common.skipToMainContent": {
+        "message": "Skip to main content",
+        "description": "The skip to content label used for accessibility, allowing to rapidly navigate to main content with keyboard tab/enter navigation"
+    },
+    "theme.tags.tagsPageTitle": {
+        "message": "Tags",
+        "description": "The title of the tag list page"
+    }
 }
diff --git a/i18n/en/docusaurus-theme-classic/navbar.json b/i18n/en/docusaurus-theme-classic/navbar.json
index e9148a65..85c5a9fe 100644
--- a/i18n/en/docusaurus-theme-classic/navbar.json
+++ b/i18n/en/docusaurus-theme-classic/navbar.json
@@ -1,34 +1,34 @@
 {
-  "title": {
-    "message": "Expresso TS",
-    "description": "The title in the navbar"
-  },
-  "logo.alt": {
-    "message": "Expresso TS",
-    "description": "The alt text of navbar logo"
-  },
-  "item.label.Documentation": {
-    "message": "Documentation",
-    "description": "Navbar item with label Documentation"
-  },
-  "item.label.Governance": {
-    "message": "Governance",
-    "description": "Navbar item with label Governance"
-  },
-  "item.label.GitHub": {
-    "message": "GitHub",
-    "description": "Navbar item with label GitHub"
-  },
-  "item.label.Language": {
-    "message": "Language",
-    "description": "Navbar item with label Language"
-  },
-  "item.label.English": {
-    "message": "English",
-    "description": "Navbar item with label English"
-  },
-  "item.label.Português": {
-    "message": "Português",
-    "description": "Navbar item with label Português"
-  }
+    "title": {
+        "message": "ExpressoTS",
+        "description": "The title in the navbar"
+    },
+    "logo.alt": {
+        "message": "ExpressoTS",
+        "description": "The alt text of navbar logo"
+    },
+    "item.label.Documentation": {
+        "message": "Documentation",
+        "description": "Navbar item with label Documentation"
+    },
+    "item.label.Governance": {
+        "message": "Governance",
+        "description": "Navbar item with label Governance"
+    },
+    "item.label.GitHub": {
+        "message": "GitHub",
+        "description": "Navbar item with label GitHub"
+    },
+    "item.label.Language": {
+        "message": "Language",
+        "description": "Navbar item with label Language"
+    },
+    "item.label.English": {
+        "message": "English",
+        "description": "Navbar item with label English"
+    },
+    "item.label.Português": {
+        "message": "Português",
+        "description": "Navbar item with label Português"
+    }
 }
diff --git a/i18n/pt/code.json b/i18n/pt/code.json
deleted file mode 100644
index 7915fa06..00000000
--- a/i18n/pt/code.json
+++ /dev/null
@@ -1,311 +0,0 @@
-{
-  "tagline": {
-  "message": "Um framework TypeScript leve, rápido e fácil de usar."
-  },
-  "homepageTitle": {
-  "message": "Expresso TS",
-  "description": "Título para a página inicial"
-  },
-  "homepageDocumentation": {
-  "message": "Documentação"
-  },
-  "homepageSourceCode": {
-  "message": "Código Fonte"
-  },
-  "featuresEasyToUse": {
-  "message": "Fácil de Usar"
-  },
-  "featuresEasyToUseDesc": {
-  "message": "Construído sobre uma arquitetura modular e projetado com simplicidade em mente, capacita os desenvolvedores a criar rapidamente aplicações poderosas."
-  },
-  "featuresFocusOnWhatMatters": {
-  "message": "Concentre-se no que importa"
-  },
-  "featuresFocusOnWhatMattersDesc": {
-  "message": "Você pode parar de se preocupar com tarefas repetitivas e focar no que realmente importa - codificar sua lógica de negócios e entregar um produto de alta qualidade."
-  },
-  "featuresExtensible": {
-  "message": "Extensível"
-  },
-  "featuresExtensibleDesc": {
-  "message": "Capacidade de criar facilmente adaptadores/provedores que se integram perfeitamente ao resto da aplicação.",
-  "description": "Descrição para o recurso Extensível"
-  },
-  "Ability to easily create adapters/providers that seamlessly integrate with the rest of the application.": {
-  "message": "Capacidade de criar facilmente adaptadores/provedores que se integram perfeitamente ao resto da aplicação."
-  },
-  "theme.AnnouncementBar.Content": {
-  "message": "Expresso TS agora está em beta! Por favor, ajude-nos a testar e nos dê feedback.",
-  "description": "O conteúdo da barra de anúncios"
-  },
-  "theme.ErrorPageContent.title": {
-  "message": "Esta página travou.",
-  "description": "O título da página de fallback quando a página travou"
-  },
-  "theme.NotFound.title": {
-  "message": "Página não encontrada",
-  "description": "O título da página 404"
-  },
-  "theme.NotFound.p1": {
-  "message": "Não foi possível encontrar o que você estava procurando.",
-  "description": "O primeiro parágrafo da página 404"
-  },
-  "theme.NotFound.p2": {
-  "message": "Por favor, entre em contato com o proprietário do site que o direcionou para a URL original e informe que o link está quebrado.",
-  "description": "O segundo parágrafo da página 404"
-  },
-  "theme.admonition.note": {
-  "message": "nota",
-  "description": "O rótulo padrão usado para a Advertência de Nota (:::note)"
-  },
-  "theme.admonition.tip": {
-  "message": "dica",
-  "description": "O rótulo padrão usado para a Advertência de Dica (:::tip)"
-  },
-  "theme.admonition.danger": {
-  "message": "perigo",
-  "description": "O rótulo padrão usado para a Advertência de Perigo (:::danger)"
-  },
-  "theme.admonition.info": {
-  "message": "informação",
-  "description": "O rótulo padrão usado para a Advertência de Informação (:::info)"
-  },
-  "theme.admonition.caution": {
-  "message": "cuidado",
-  "description": "O rótulo padrão usado para a Advertência de Cuidado (:::caution)"
-  },
-  "theme.BackToTopButton.buttonAriaLabel": {
-    "message": "Voltar ao topo",
-    "description": "O ARIA label para o botão voltar ao topo"
-  },
-  "theme.blog.archive.title": {
-    "message": "Arquivo",
-    "description": "O título da página e do cabeçalho da página de arquivo do blog"
-  },
-  "theme.blog.archive.description": {
-    "message": "Arquivo",
-    "description": "A descrição da página e do cabeçalho da página de arquivo do blog"
-  },
-  "theme.blog.paginator.navAriaLabel": {
-    "message": "Navegação da lista de blogs",
-    "description": "O ARIA label para a paginação do blog"
-  },
-  "theme.blog.paginator.newerEntries": {
-    "message": "Entradas mais recentes",
-    "description": "O rótulo usado para navegar para a página de postagens de blog mais recentes (página anterior)"
-  },
-  "theme.blog.paginator.olderEntries": {
-    "message": "Entradas mais antigas",
-    "description": "O rótulo usado para navegar para a página de postagens de blog mais antigas (próxima página)"
-  },
-  "theme.blog.post.paginator.navAriaLabel": {
-    "message": "Navegação da página de postagem do blog",
-    "description": "O ARIA label para a paginação das postagens do blog"
-  },
-  "theme.blog.post.paginator.newerPost": {
-    "message": "Postagem mais recente",
-    "description": "O rótulo do botão da postagem do blog para navegar para a postagem mais recente/anterior"
-  },
-  "theme.blog.post.paginator.olderPost": {
-    "message": "Postagem mais antiga",
-    "description": "O rótulo do botão da postagem do blog para navegar para a postagem mais antiga/próxima"
-  },
-  "theme.blog.post.plurals": {
-    "message": "Uma postagem|{count} postagens",
-    "description": "Rótulo pluralizado para \"{count} postagens\". Use tantas formas plurais (separadas por \"|\") quanto seu idioma suportar (consulte https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
-  },
-  "theme.blog.tagTitle": {
-    "message": "{nPosts} marcados com \"{tagName}\"",
-    "description": "O título da página para uma tag de blog"
-  },
-  "theme.tags.tagsPageLink": {
-    "message": "Ver todas as tags",
-    "description": "O rótulo do link direcionado para a página da lista de tags"
-  },
-  "theme.colorToggle.ariaLabel": {
-    "message": "Alternar entre o modo escuro e o modo claro (atualmente {mode})",
-    "description": "O ARIA label para o alternador de modo de cor da barra de navegação"
-  },
-  "theme.colorToggle.ariaLabel.mode.dark": {
-    "message": "modo escuro",
-    "description": "O nome para o modo de cor escura"
-  },
-  "theme.colorToggle.ariaLabel.mode.light": {
-    "message": "modo claro",
-    "description": "O nome para o modo de cor clara"
-  },
-  "theme.docs.breadcrumbs.navAriaLabel": {
-    "message": "Caminho de navegação",
-    "description": "O ARIA label para o caminho de navegação (breadcrumbs)"
-  },
-  "theme.docs.DocCard.categoryDescription": {
-    "message": "{count} itens",
-    "description": "A descrição padrão para um cartão de categoria no índice gerado sobre quantos itens essa categoria inclui"
-  },
-  "theme.docs.paginator.navAriaLabel": {
-    "message": "Navegação das páginas de documentação",
-    "description": "O ARIA label para a paginação dos documentos"
-  },
-  "theme.docs.paginator.previous": {
-    "message": "Anterior",
-    "description": "O rótulo usado para navegar até o documento anterior"
-  },
-  "theme.docs.paginator.next": {
-    "message": "Próximo",
-    "description": "O rótulo usado para navegar até o próximo documento"
-  },
-  "theme.docs.tagDocListPageTitle.nDocsTagged": {
-    "message": "Um documento marcado|{count} documentos marcados",
-    "description": "Rótulo pluralizado para \"{count} documentos marcados\". Use tantas formas plurais (separadas por \"|\") quanto seu idioma suportar (consulte https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
-  },
-  "theme.docs.tagDocListPageTitle": {
-    "message": "{nDocsTagged} com \"{tagName}\"",
-    "description": "O título da página para uma tag de documentação"
-  },
-  "theme.docs.versionBadge.label": {
-    "message": "Versão: {versionLabel}"
-  },
-  "theme.docs.versions.unreleasedVersionLabel": {
-    "message": "Esta é a documentação não lançada para {siteTitle} versão {versionLabel}.",
-    "description": "O rótulo usado para informar ao usuário que ele está navegando em uma versão não lançada da documentação"
-  },
-  "theme.docs.versions.unmaintainedVersionLabel": {
-    "message": "Esta é a documentação para {siteTitle} {versionLabel}, que não é mais mantida ativamente.",
-    "description": "O rótulo usado para informar ao usuário que ele está navegando em uma versão não mantida da documentação"
-  },
-  "theme.docs.versions.latestVersionSuggestionLabel": {
-    "message": "Para documentação atualizada, consulte a {latestVersionLink} ({versionLabel}).",
-    "description": "O rótulo usado para informar ao usuário para verificar a versão mais recente"
-  },
-  "theme.docs.versions.latestVersionLinkLabel": {
-    "message": "última versão",
-    "description": "O rótulo usado para o link de sugestão da última versão"
-  },
-  "theme.common.editThisPage": {
-    "message": "Editar esta página",
-    "description": "O rótulo do link para editar a página atual"
-  },
-  "theme.common.headingLinkTitle": {
-    "message": "Link direto para {heading}",
-    "description": "Título para o link de cabeçalho"
-  },
-  "theme.lastUpdated.atDate": {
-    "message": " em {date}",
-    "description": "As palavras usadas para descrever em qual data uma página foi atualizada pela última vez"
-  },
-  "theme.lastUpdated.byUser": {
-    "message": " por {user}",
-    "description": "As palavras usadas para descrever por quem a página foi atualizada pela última vez"
-  },
-  "theme.lastUpdated.lastUpdatedAtBy": {
-    "message": "Última atualização{atDate}{byUser}",
-    "description": "A frase usada para exibir quando uma página foi atualizada pela última vez e por quem"
-  },
-  "theme.navbar.mobileVersionsDropdown.label": {
-    "message": "Versões",
-    "description": "O rótulo para o menu suspenso de versões na visualização móvel da barra de navegação"
-  },
-  "theme.tags.tagsListLabel": {
-    "message": "Tags:",
-    "description": "O rótulo ao lado de uma lista de tags"
-  },
-  "theme.AnnouncementBar.closeButtonAriaLabel": {
-    "message": "Fechar",
-    "description": "O ARIA label para o botão de fechar da barra de anúncio"
-  },
-  "theme.blog.sidebar.navAriaLabel": {
-    "message": "Navegação de postagens recentes do blog",
-    "description": "O ARIA label para postagens recentes na barra lateral do blog"
-  },
-  "theme.CodeBlock.copied": {
-    "message": "Copiado",
-    "description": "O rótulo do botão copiado nos blocos de código"
-  },
-  "theme.CodeBlock.copyButtonAriaLabel": {
-    "message": "Copiar código para a área de transferência",
-    "description": "O ARIA label para o botão de copiar blocos de código"
-  },
-  "theme.CodeBlock.copy": {
-    "message": "Copiar",
-    "description": "O rótulo do botão copiar nos blocos de código"
-  },
-  "theme.CodeBlock.wordWrapToggle": {
-    "message": "Alternar quebra de linha",
-    "description": "O atributo de título para o botão de alternar quebra de linha dos blocos de código"
-  },
-  "theme.DocSidebarItem.toggleCollapsedCategoryAriaLabel": {
-    "message": "Alternar a categoria colapsável da barra lateral '{label}'",
-    "description": "O ARIA label para alternar a categoria colapsável da barra lateral"
-  },
-  "theme.NavBar.navAriaLabel": {
-    "message": "Principal",
-    "description": "O ARIA label para a navegação principal"
-  },
-  "theme.navbar.mobileLanguageDropdown.label": {
-    "message": "Idiomas",
-    "description": "O rótulo para o menu suspenso de seleção de idioma no celular"
-  },
-  "theme.TOCCollapsible.toggleButtonLabel": {
-    "message": "Nesta página",
-    "description": "O rótulo usado pelo botão no componente TOC colapsável"
-  },
-  "theme.blog.post.readMore": {
-    "message": "Leia mais",
-    "description": "O rótulo usado nos trechos de postagens do blog para vincular às postagens completas do blog"
-  },
-  "theme.blog.post.readMoreLabel": {
-    "message": "Leia mais sobre {title}",
-    "description": "O ARIA label para o link para postagens completas do blog a partir de trechos"
-  },
-  "theme.blog.post.readingTime.plurals": {
-    "message": "Leitura de um minuto|{readingTime} min de leitura",
-    "description": "Rótulo pluralizado para \"{readingTime} min de leitura\". Use tantas formas plurais (separadas por \"|\") quanto seu idioma suportar (consulte https://www.unicode.org/cldr/cldr-aux/charts/34/supplemental/language_plural_rules.html)"
-  },
-  "theme.docs.breadcrumbs.home": {
-    "message": "Página inicial",
-    "description": "O ARIA label para a página inicial nos breadcrumbs"
-  },
-  "theme.docs.sidebar.collapseButtonTitle": {
-    "message": "Recolher barra lateral",
-    "description": "O atributo de título para o botão de recolher da barra lateral de documentos"
-  },
-  "theme.docs.sidebar.collapseButtonAriaLabel": {
-    "message": "Recolher barra lateral",
-    "description": "O atributo de título para o botão de recolher da barra lateral de documentos"
-  },
-  "theme.docs.sidebar.navAriaLabel": {
-    "message": "Barra lateral de documentos",
-    "description": "O ARIA label para a navegação da barra lateral"
-  },
-  "theme.docs.sidebar.closeSidebarButtonAriaLabel": {
-    "message": "Fechar barra de navegação",
-    "description": "O ARIA label para o botão de fechar da barra lateral móvel"
-  },
-  "theme.navbar.mobileSidebarSecondaryMenu.backButtonLabel": {
-    "message": "← Voltar ao menu principal",
-    "description": "O rótulo do botão de voltar para retornar ao menu principal, dentro do menu secundário da barra lateral da barra de navegação móvel (usado principalmente para exibir a barra lateral de documentos)"
-  },"theme.docs.sidebar.toggleSidebarButtonAriaLabel": {
-    "message": "Alternar barra de navegação",
-    "description": "O ARIA label para o botão do menu hambúrguer da navegação móvel"
-  },
-  "theme.docs.sidebar.expandButtonTitle": {
-    "message": "Expandir barra lateral",
-    "description": "O ARIA label e atributo de título para o botão de expandir da barra lateral de documentos"
-  },
-  "theme.docs.sidebar.expandButtonAriaLabel": {
-    "message": "Expandir barra lateral",
-    "description": "O ARIA label e atributo de título para o botão de expandir da barra lateral de documentos"
-  },
-  "theme.ErrorPageContent.tryAgain": {
-    "message": "Tente novamente",
-    "description": "O rótulo do botão para tentar novamente a renderização quando a fronteira de erro do React captura um erro"
-  },
-  "theme.common.skipToMainContent": {
-    "message": "Pular para o conteúdo principal",
-    "description": "O rótulo de pular para o conteúdo usado para acessibilidade, permitindo navegar rapidamente para o conteúdo principal com a navegação por teclado tab/enter"
-  },
-  "theme.tags.tagsPageTitle": {
-    "message": "Tags",
-    "description": "O título da página de lista de tags"
-  }
-}
diff --git a/i18n/pt/docusaurus-plugin-content-blog/options.json b/i18n/pt/docusaurus-plugin-content-blog/options.json
deleted file mode 100644
index 7bdf0f19..00000000
--- a/i18n/pt/docusaurus-plugin-content-blog/options.json
+++ /dev/null
@@ -1,14 +0,0 @@
-{
-  "title": {
-    "message": "Blog",
-    "description": "O título para o blog usado em SEO"
-  },
-  "description": {
-    "message": "Blog",
-    "description": "A descrição para o blog usado em SEO"
-  },
-  "sidebar.title": {
-    "message": "Posts recentes",
-    "description": "O rótulo para a barra lateral esquerda"
-  }
-}
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current.json b/i18n/pt/docusaurus-plugin-content-docs/current.json
deleted file mode 100644
index 8728da63..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current.json
+++ /dev/null
@@ -1,42 +0,0 @@
-{
-  "config.title": {
-    "message": "Expresso TS",
-    "description": "O título do site"
-  },
-  "config.tagline": {
-    "message": "Um framework TypeScript leve, rápido e fácil de usar",
-    "description": "O slogan do site"
-  },
-  "version.label": {
-    "message": "Próximo",
-    "description": "O rótulo para a versão atual"
-  },
-  "sidebar.tutorialSidebar.Intro": {
-    "message": "Introdução",
-    "description": "O rótulo para a categoria Visão geral na barra lateral tutorialSidebar"
-  },
-  "sidebar.tutorialSidebar.category.Overview": {
-    "message": "Visão geral",
-    "description": "O rótulo para a categoria Visão geral na barra lateral tutorialSidebar"
-  },
-  "sidebar.tutorialSidebar.category.Overview.link.generated-index.description": {
-    "message": "Visão geral do Expresso TS Framework.",
-    "description": "A descrição da página generated-index para a categoria Visão geral na barra lateral tutorialSidebar"
-  },
-  "sidebar.tutorialSidebar.category.CLI": {
-    "message": "CLI",
-    "description": "O rótulo para a categoria CLI na barra lateral tutorialSidebar"
-  },
-  "sidebar.tutorialSidebar.category.CLI.link.generated-index.description": {
-    "message": "Ferramenta CLI do Expresso TS.",
-    "description": "A descrição da página generated-index para a categoria CLI na barra lateral tutorialSidebar"
-  },
-  "sidebar.tutorialSidebar.category.Tutorials": {
-    "message": "Tutoriais",
-    "description": "O rótulo para a categoria Tutoriais na barra lateral tutorialSidebar"
-  },
-  "sidebar.tutorialSidebar.category.Tutorials.link.generated-index.description": {
-    "message": "Tutoriais do Expresso TS.",
-    "description": "A descrição da página generated-index para a categoria Tutoriais na barra lateral tutorialSidebar"
-  }
-}
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/cli/_category_.json b/i18n/pt/docusaurus-plugin-content-docs/current/cli/_category_.json
deleted file mode 100644
index ac3132a1..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/cli/_category_.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "label": "CLI",
-  "position": 4,
-  "link": {
-    "type": "generated-index",
-    "description": "Expresso TS CLI Tool."
-  }
-}
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/cli/generate.md b/i18n/pt/docusaurus-plugin-content-docs/current/cli/generate.md
deleted file mode 100644
index cc2a6d97..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/cli/generate.md
+++ /dev/null
@@ -1,84 +0,0 @@
----
-sidebar_position: 2
----
-
-# Gerar recursos
-
-Para oferecer uma melhor experiência ao desenvolvedor, o CLI do ExpressoTS fornece um conjunto de comandos que ajudam a criar os recursos da aplicação, como casos de uso, controladores, DTOs, provedores e serviços. Isso permite que os desenvolvedores se concentrem na lógica de negócios, gerando automaticamente o código boilerplate.
-
-## Comandos
-
-O comando para gerar recursos podem ser expressados de duas formas:
-
-```bash
-expressots generate <recurso> <estrutura> [opções]
-```
-
-Ou em sua forma curta:
-
-```bash
-expressots g <recurso> <estrutura> [opções]
-```
-
-### Estrutura de comando
-
-Nós fornecemos duas estruturas diferentes para estruturar os recursos:
-
--   **[abreviada]**: `expressots generate service user-create`
-    Isso criará esta estrutura de pastas: `/user/create` e o arquivo: `user-create.[recurso].ts`
-
--   **[pasta/subpasta/recurso]**: `expressots generate service user/create`
-    Isso criará esta estrutura de pastas: `/user/create` e o arquivo: `create.[recurso].ts`
-
-    Se você adicionar `/` no final da estrutura, o CLI criará o recurso dentro da pasta. Exemplo: `expressots generate service user/create/`
-    Estrutura: `user/create/` e o arquivo: `create.[recurso].ts`
-
-### Pasta raiz do recurso
-
--   A pasta raiz de todos os recursos é a `src`. Isso pode ser alterado no arquivo `expressots.config.ts`.
--   No modo opinativo, a pasta raiz é o `src` e os recursos montados com `service, usecase, dto, controller` são criados dentro do `useCases`.
--   As entidades são criadas dentro do `entities`, e provedores dentro do `providers`.
-
-## Tipos de recursos
-
-Recursos disponíveis atualmente:
-
-| Forma longa | Abreviação | Comando                    | Resultado esperado                                                                     |
-| ----------- | ---------- | -------------------------- | -------------------------------------------------------------------------------------- |
-| useCase     | u          | expressots g u user/find   | Caso de uso para ser criado na pasta `useCases` com esta estrutura de pasta: user/find |
-| controller  | c          | expressots g c user/find   | Controlador para ser criado na pasta `useCases` dentro de user/find                    |
-| dto         | d          | expressots g d user/find   | DTO a ser criado na pasta `useCases` dentro de user/find                               |
-| provider    | p          | expressots g p email/email | Provedor a ser criado na pasta `providers` dentro de user/find                         |
-| service     | s          | expressots g s user/find   | Serviço cria caso de uso, controladora e dto e os adiciona na pasta user/find          |
-| entity      | e          | expressots g e user        | Entidade a ser criada na pasta `entities` com esta estrutura de pasta: user            |
-| middleware  | mi         | expressots g m auth        | Middleware a ser criado na pasta `middlewares` com esta estrutura de pasta: auth       |
-| module      | mo         | expressots g mo user       | Módulo a ser criado na pasta onde `controllers` e `usecases` estão localizados         |
-
-Todos os recursos podem ser criados usando a estrutura `pasta/subpasta/recurso.`
-
-## Gerando recursos com Operação Abreviada
-
-Para serviços, você pode aproveitar para criar o caso de uso, controlador e DTO de uma vez usando a estrutura `entidade_acao ` ou `entidade-acao `. Exemplo:
-
-```bash
-expressots g s user-create
-```
-
-:::info
-O arquivo de configuração `expressots.config.ts`, localizado na pasta raiz do projeto, determina onde todos os recursos serão criados. Também é possível configurar o padrão de nomenclatura dos recursos e se o CLI deve seguir uma estrutura de pasta com opinião.
-:::
-
-Leia mais sobre a [configuração do projeto](/i18n/pt/docusaurus-plugin-content-docs/current/overview/expressots-config.md).
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/cli/overview.md b/i18n/pt/docusaurus-plugin-content-docs/current/cli/overview.md
deleted file mode 100644
index a784c0c0..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/cli/overview.md
+++ /dev/null
@@ -1,227 +0,0 @@
----
-sidebar_position: 1
----
-
-# Visão geral
-
-O CLI do ExpressoTS é uma ferramenta de interface de linha de comando que ajuda você a `criar` projetos ExpressoTS e `scaffold` recursos do ExpressoTS.
-
-:::info
-Usamos o gerenciador de pacotes `npm` neste tutorial para simplicidade. No entanto, você também pode usar `yarn` ou `pnpm`.
-:::
-
-## Instalação
-
-Primeiro instalamos o CLI globalmente usando o comando abaixo:
-
-```bash
-npm install -g @expressots/cli
-```
-
-## Comandos disponíveis
-
-| Name        | Alias  | Description                                        |
-| ----------- | ------ | -------------------------------------------------- |
-| new project | new    | Cria um novo projeto                               |
-| info        | i      | Informações do projeto                             |
-| resources   | r      | Exibe comandos e recursos do CLI                   |
-| help        | h      | Mostra ajuda do comando                            |
-| service     | g s    | Gera um serviço [controller, usecase, dto, module] |
-| controller  | g c    | Gera um controlador                                |
-| usecase     | g u    | Gera um caso de uso                                |
-| dto         | g d    | Gera um DTO                                        |
-| entity      | g e    | Gera uma entidade                                  |
-| provider    | g p    | Gera um provedor interno                           |
-| provider    | add    | Adiciona provedor externo ao projeto               |
-| provider    | create | Cria provedor externo                              |
-| module      | g mo   | Gera um módulo                                     |
-| middleware  | g mi   | Gera um middleware                                 |
-
-## Exemplos de uso
-
-O CLI tem a seguinte sintaxe:
-
-```bash
-expressots <command> [options]
-```
-
-### Ajuda
-
-Para verificar os comandos e opções disponíveis:
-
-```bash
-expressots help
-```
-
-### Informação
-
-Informações dos provedores sobre seu Sistema Operacional, Projeto e versão CLI:
-
-```bash
-expressots info
-```
-
-### Lista de recursos
-
-Lista todos os recursos disponíveis para scaffolding:
-
-```bash
-expressots resources (Alias: r)
-```
-
-### Criando um projeto ExpressoTS
-
-Há duas opções para criar um novo projeto, interativamente ou silenciosamente (passando as opções como argumentos).
-Aqui está a sintaxe completa do comando:
-
-```bash
-expressots new <nome-do-projeto> -p <gerenciador-de-pacote> -t <template> -d <diretório>
-```
-
-### Criando projeto interativamente
-
-```bash
-expressots new <nome-do-projeto>
-```
-
-### Criando projeto silenciosamente
-
-```bash
-expressots new <nome-do-projeto> -p <gerenciador-de-pacote> -t <template> -d <diretório>
-```
-
--   **gerenciador-de-pacote**: `npm`, `yarn` or `pnpm`
--   **template**: `opinionated` or `non-opinionated`
--   **directory**: `./meu-projeto`
-
-A flag `-d` é opcional e serve para especificar o diretório onde o projeto será criado. Se não for especificado, o projeto será criado no diretório atual.
-
-### Adicionando provedor externo
-
-Adiciona um provedor externo ao projeto:
-
-```bash
-expressots add <nome-do-provedor>
-```
-
-### Criando provedor externo
-
-Crie um provedor externo. Para mais informações sobre provedores, consulte a seção [Provedores](/i18n/pt/docusaurus-plugin-content-docs/current/overview/providers.md#criando-e-registrando-um-provedor-externo).
-
-```bash
-expressots create <nome-do-provedor>
-```
-
-### Gerando um serviço
-
-A CLI fornece comandos para criar serviços, controladores, casos de uso e DTOs, Modulos e Middlewares. Aqui está a sintaxe completa:
-
-```bash
-expressots generate <recurso> <estrutura> [opções]
-```
-
-Os recursos são criados no diretório `src` por padrão. Eles também podem ser gerados de duas maneiras diferentes: `passando o caminho` ou usando a `operação abreviada`.
-
-:::caution
-As operações de geração de recursos produzem resultados diferentes com base no template de projeto utilizado. O template `opinionado` oferece uma estrutura de projeto mais organizada, enquanto o template `não-opinionado` proporciona uma estrutura de projeto mais flexível.
-:::
-
-### Gerando serviço no NÃO-OPINIONADO
-
-#### Passando o caminho
-
-```bash
-expressots g c usuario/cadastrar
-```
-
-O comando acima cria a seguinte estrutura de pastas: `/usuario/cadastrar` e o arquivo: `cadastrar.[recurso].ts`
-
-```bash
-src
-└── usuario
-    └── cadastrar.controller.ts
-```
-
-#### Operação abreviada
-
-```bash
-expressots g s usuario-cadastrar
-```
-
-O comando acima cria a seguinte estrutura de pastas: `/usuario/cadastrar` e os arquivos: `cadastrar.[recurso].ts`
-
-```bash
-src
-└── usuario
-    └── cadastrar
-        ├── cadastrar.controller.ts
-        ├── cadastrar.usecase.ts
-        └── cadastrar.dto.ts
-```
-
-### Gerando serviço no OPINIONADO
-
-No template `opinionado`, os recursos são criados seguindo uma estrutura predefinida.
-
--   [@providers](/i18n/pt/docusaurus-plugin-content-docs/current/overview/providers.md)
--   [@entities](/i18n/pt/docusaurus-plugin-content-docs/current/overview/entities.md)
--   [@useCases](/i18n/pt/docusaurus-plugin-content-docs/current/overview/usecase.md)
--   [@repositories](/i18n/pt/docusaurus-plugin-content-docs/current/overview/repositories.md)
-
-#### Passando o caminho
-
-```bash
-expressots g c usuario/cadastrar
-```
-
-O comando acima cria a seguinte estrutura de pastas: `/usuario/cadastrar` e o arquivo: `cadastrar.[recurso].ts`
-
-```bash
-src
-└── useCases
-    └── usuario
-        └── cadastrar.controller.ts
-```
-
-:::info
-DTOs, casos de uso, controladores e módulos são criados no diretório `useCases`.
-:::
-
-#### Operação abreviada
-
-```bash
-expressots g s usuario-cadastrar
-```
-
-O comando acima cria a seguinte estrutura de pastas: `/usuario/cadastrar` e os arquivos: `cadastrar.[recurso].ts`
-
-```bash
-src
-└── useCases
-    └── usuario
-        └── cadastrar
-            ├── cadastrar.controller.ts
-            ├── cadastrar.usecase.ts
-            └── cadastrar.dto.ts
-```
-
-:::info
-Usar a operação abreviada no template opinionado oferece benefícios significativos. Ela cria um projeto bem estruturado, que é mais fácil de navegar e entender. Quando você gera o projeto com a operação abreviada, a CLI coloca automaticamente os recursos nos diretórios corretos, adiciona os controladores aos seus respectivos módulos e integra o módulo ao container.
-:::
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
-
-```
-
-```
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/app-container.md b/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/app-container.md
deleted file mode 100644
index 228275df..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/app-container.md
+++ /dev/null
@@ -1,67 +0,0 @@
----
-sidebar_position: 1
----
-# Contêiner da Aplicação
-
-O contêiner da aplicação é um contêiner de injeção de dependências. Veja Contêiner da Aplicação para mais informações.
-
-```typescript
-const appContainer = new AppContainer();
-
-export const container: Container = appContainer.create([
-    // Adicione seus módulos aqui
-    AppModule,
-]);
-```
-
-## Criando AppContainer
-
-A classe `AppContainer` aceita um parâmetro opcional:
-
--   `defaultScope` é o escopo de vinculação padrão. Use `BindingScopeEnum` para definir o escopo padrão (Request, Singleton, Transient).
--   `skipBaseClassChecks` é um valor booleano que indica se o contêiner deve pular as verificações de classe base. Isso é útil quando você está usando classes abstratas como identificadores de vinculação ou está estendendo classes de bibliotecas de terceiros. Defina este valor como `true` para pular as verificações de classe base.
--   `autoBindInjectable` é um valor booleano que indica se o contêiner deve vincular automaticamente classes injetáveis. Defina este valor como `true` para vincular automaticamente classes injetáveis.
-
-:::info
-O escopo padrão é BindingScopeEnum.Request e skipBaseClassChecks é false.
-:::
-
-```typescript
-const appContainer = new AppContainer({
-    defaultScope: BindingScopeEnum.Request,
-    skipBaseClassChecks: true,
-    autoBindInjectable: false,
-});
-```
-O `AppContainer` retorna uma instância de `AppContainer` que te dá acesso aos seguintes métodos:
-
--   `create()` cria o contêiner da aplicação.
--   Container é a instância do contêiner de injeção de dependências.
--   `getBindingDictionary()` retorna o mapa do dicionário de vinculação de classes injetadas no sistema de injeção de dependências.
--   `getContainerOptions()` retorna as opções do contêiner.
-
-### Método Create
-
-O método `create` recebe um parâmetro obrigatório (array de módulos);
-
-```typescript
-export const container: Container = appContainer.create([
-    // Adicione seus módulos aqui
-    AppModule,
-    UserModule,
-    ProductModule,
-]);
-```
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
-- Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
-- Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
-- Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Compartilhe o projeto com seus amigos e colegas
\ No newline at end of file
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/bootstrap.md b/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/bootstrap.md
deleted file mode 100644
index 394e26a5..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/bootstrap.md
+++ /dev/null
@@ -1,98 +0,0 @@
----
-sidebar_position: 0
----
-
-# Método Bootstrap
-
-O método `bootstrap` é o ponto de entrada da sua aplicação. É responsável por carregar a configuração da aplicação, registrar middlewares e iniciar a aplicação.
-
--   O método `AppFactory.create()` é responsável por criar a instância da aplicação. Ele recebe dois parâmetros:
--   `container` é o contêiner de injeção de dependências. Veja Contêiner da Aplicação para mais informações.
--   `middlewares` ou `App`
--   Retorna um instância de `IApplicationExpress` que te dá acesso a dois métodos:
--   `app.listen()` inicia a aplicação.
--   `app.setEngine()` define o motor de renderização de visualização da aplicação.`
-
-:::info
-**`middlewares`** é um array de middlewares que serão registrados na aplicação. (Template não opinativo)
-
-**`App`** é a classe da aplicação responsável por toda a configuração da aplicação. (Template opinativo)
-:::
-
-## Bootstrap com array de middlewares
-
-Use este método se você está usando o template não opinativo. Você tem a liberdade de criar sua própria classe de aplicação e registrar seus middlewares da sua própria maneira.
-
-```typescript
-async function bootstrap() {
-    const app = await AppFactory.create(container, [cors(), helmet()]);
-    await app.listen(3000, ServerEnvironment.Development);
-}
-
-bootstrap();
-```
-
-:::tip
-**`AppFactory.create(container, [])`** retorna uma instância de `ApplicationExpress` que te dá acesso direto à instância do `ExpressApp`.
-:::
-
-## Bootstrap com a classe de aplicação
-
-Use este método se você está usando o template opinativo. Sua classe de aplicação será responsável por toda a configuração da aplicação.
-
-```typescript
-async function bootstrap() {
-    const app = await AppFactory.create(container, App);
-    await app.listen(3000, ServerEnvironment.Development);
-}
-
-bootstrap();
-```
-
-:::tip
-**`AppFactory.create(container, App)`** retorna uma instância de `IApplicationExpress` que te dá acesso aos métodos `listen()` e `setEngine()`.
-:::
-
-## Método Listen
-
-O método `listen` é responsável por iniciar a aplicação. Ele recebe dois parâmetros obrigatórios e um parâmetro opcional:
-
--   `port` é o número da porta onde a aplicação estará ouvindo. (Obrigatório)
--   `environment` é o ambiente onde a aplicação estará rodando. Pode ser development ou production. Use o enum chamado `ServerEnvironment`. (Obrigatório)
--   `consoleMessage` é o objeto de mensagem que será exibido no console quando a aplicação iniciar. (Opcional)
-
-```typescript
-await app.listen(3000, ServerEnvironment.Development, {
-    appName: "Expressots",
-    appVersion: "1.0.0",
-});
-```
-
-:::tip
-O enum ServerEnvironment define automaticamente a variável de ambiente NODE_ENV. Pode ser `development` ou `production`.
-:::
-
-## Método Set Engine
-
-O método `setEngine` é responsável por definir o motor de renderização de visualização da aplicação. Por enquanto, o ExpressoTS suporta apenas Handlebars.
-
-```typescript
-app.setEngine<IHandlebars>({
-    extName: "hbs",
-    viewPath: path.join(__dirname, "..", "views"),
-    engine: engine({ defaultLayout: "layout", extname: "hbs" }),
-});
-```
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/controller.md b/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/controller.md
deleted file mode 100644
index 1091de9a..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/controller.md
+++ /dev/null
@@ -1,112 +0,0 @@
----
-sidebar_position: 3
----
-
-# Controladores
-
-Os controladores são responsáveis por manipular solicitações recebidas e retornar respostas ao cliente.
-
--   Para informações sobre `BaseController`, veja [BaseController](../overview/controller.md#classe-basecontroller).
--   Para informações sobre decoradores HTTP e de parâmetros, veja [Decoradores HTTP e de Parâmetros](../overview/decorators.md).
--   Os controladores utilizam DTOs para validar o corpo da solicitação, parâmetros de consulta e parâmetros de rota. Veja [DTOs](../overview/controller#padrão-dto) para mais informações.
-
-```typescript
-@controller("/")
-export class UserGetController extends BaseController {
-    constructor() {
-        super();
-    }
-
-    @Get("/")
-    execute() {
-        return "Getting a user...";
-    }
-}
-```
-
-Para criar um controlador, você precisa criar uma classe e decorá-la com o decorador `@controller`. O decorador `@controller` recebe dois parâmetros:
-
--   `path` é o caminho do controlador. (Obrigatório)
--   `middlewares` é um array de middlewares. (Opcional)
-
-```typescript
-@controller("/", express.json(), express.urlencoded({ extended: true }))
-```
-
-:::info
-Definir middlewares no controlador será aplicado a todas as rotas do controlador.
-:::
-
-## Exemplo de um Controlador com Múltiplas Rotas
-
-```typescript
-@controller("/user")
-export class UserController extends BaseController {
-    constructor() {
-        super();
-    }
-
-    @Get("/")
-    get() {
-        return "Getting a user...";
-    }
-
-    @Post("/create")
-    create() {
-        return "Creating a user...";
-    }
-}
-```
-
-## Exemplo de Rota com Múltiplos Middlewares
-
-```typescript
-@Get("app", express.json(), express.urlencoded({ extended: true }))
-```
-
-:::info
-Definir middlewares na rota será aplicado apenas à rota específica.
-:::
-
-:::info
-O caminho da rota do controlador será concatenado com o caminho da rota individual.
-
-```typescript
-@controller("/user")
-  @Post("/create")
-```
-
-A rota final é /user/create.
-:::
-
-## Injetando Dependências no Construtor do Controlador
-
-Você pode injetar dependências no construtor do controlador da seguinte forma:
-
-```typescript
-@controller("/")
-class AppController extends BaseController {
-    constructor(private yourProvider: YourProvider) {
-        super();
-    }
-
-    @Get("/")
-    get() {
-        this.yourProvider.doSomething();
-        return "Hello ExpressoTS!";
-    }
-}
-```
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/entities.md b/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/entities.md
deleted file mode 100644
index 540c6d9c..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/entities.md
+++ /dev/null
@@ -1,45 +0,0 @@
----
-sidebar_position: 5
----
-
-# Entidades
-
-
-Entidades são o núcleo da sua aplicação. Elas são a representação dos seus objetos de negócio. Para mais informações sobre entidades, veja [Entidades](../overview/entities.md).
-
-```typescript
-@provide(User)
-export class User {
-  id: string;
-  name: string;
-  email: string;
-
-  constructor() {
-    this.id = randomUUID();
-  }
-}
-```
-
-:::caution
-Não passe tipos primitivos como parâmetros para o construtor das suas entidades. O Contêiner de Injeção de Dependências não será capaz de resolvê-los.
-
-```typescript
-constructor(name: string) {
-    this.name = name;
-}
-```
-
-:::
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
-- Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
-- Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
-- Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Compartilhe o projeto com seus amigos e colegas
\ No newline at end of file
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/modules.md b/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/modules.md
deleted file mode 100644
index 2751dc54..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/modules.md
+++ /dev/null
@@ -1,47 +0,0 @@
----
-sidebar_position: 2
----
-
-# Módulos
-
-Os módulos são responsáveis por registrar controladores. Veja Módulos para mais informações.
-
-## Criando um Módulo
-
-O decorador `CreateModule` recebe dois parâmetros:
-
-- `controllers` é um array de controladores. (Obrigatório)
-- `scope` é o escopo de vinculação. Use `BindingScopeEnum` para definir o escopo (Request, Singleton, Transient). (Opcional)
-
-:::info
-O escopo padrão é `BindingScopeEnum.Request` herdado do `AppContainer`.
-:::
-
-```typescript
-export const UserModule = CreateModule([], BindingScopeEnum.Request);
-```
-
-Exemplo de um módulo com controladores:
-
-```typescript
-export const UserModule = CreateModule([
-  UserCreateController,
-  UserDeleteController,
-  UserUpdateController,
-  UserFindController,
-  UserFindallController,
-]);
-```
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
-- Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
-- Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
-- Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Compartilhe o projeto com seus amigos e colegas
\ No newline at end of file
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/usecase.md b/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/usecase.md
deleted file mode 100644
index 2d1197ad..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/usecase.md
+++ /dev/null
@@ -1,43 +0,0 @@
----
-sidebar_position: 4
----
-
-# Casos de Uso
-
-Casos de uso são a implementação da lógica de negócios da sua aplicação. Para mais informações sobre casos de uso, veja [Casos de Uso](../overview/usecase.md).
-
-```typescript
-@provide(YourUseCase)
-export class YourUseUseCase {
-  execute() {
-    return "Hello ExpressoTS!";
-  }
-}
-```
-
-## Injetando Dependências no Construtor de Casos de Uso
-
-```typescript
-@provide(YourUseCase)
-export class YourUseUseCase {
-  constructor(private yourProvider: YourProvider) {}
-
-  execute() {
-    this.yourProvider.doSomething();
-    return "Hello ExpressoTS!";
-  }
-}
-```
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
-- Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
-- Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
-- Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Compartilhe o projeto com seus amigos e colegas
\ No newline at end of file
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/utils.md b/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/utils.md
deleted file mode 100644
index df0a2908..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/codebyexample/utils.md
+++ /dev/null
@@ -1,128 +0,0 @@
----
-sidebar_position: 6
----
-
-# Utilitários ExpressoTS
-
-## Códigos de Status
-
-É um enum que contém todos os códigos de status HTTP.
-
-```typescript
-StatusCode.OK;
-```
-
-## Relatando Erros
-
-Para mais informações sobre Tratamento de Erros, veja [Tratamento de Erros](../overview/error-handling.md).
-
-Aqui estão os parâmetros do método `error`:
-
-- error: Uma instância de Error ou uma string que descreve o erro.
-- statusCode: O código de status HTTP associado ao erro (padrão é 500).
-- service: O nome do serviço associado ao erro.
-- @throws: Um objeto do tipo personalizado AppError, que inclui detalhes sobre o erro.
-
-```typescript
-@provide(YourUseCase)
-export class YourUseUseCase {
-  constructor(private report: Report) {}
-
-  execute() {
-    this.report.error("Something went wrong!");
-    return "Hello ExpressoTS!";
-  }
-}
-```
-
-## Registro
-
-Logger é uma classe que fornece um conjunto de métodos para registrar mensagens usando módulos nativos do node para melhor desempenho.
-
-Logger recebe dois parâmetros:
-
-- message: A mensagem a ser registrada.
-- module: O nome do serviço associado ao log.
-
-```typescript
-export class YourUseUseCase {
-  constructor(private log: Logger) {}
-
-  execute() {
-    this.log.info("Testing log message", "YourUseUseCase");
-    return "Hello ExpressoTS!";
-  }
-}
-```
-
-Existem 4 métodos disponíveis:
-
-- **info**: Registra uma mensagem informativa.
-- **warn**: Registra uma mensagem de aviso.
-- **error**: Registra uma mensagem de erro.
-- **msg**: Registra uma mensagem de log.
-
-## Definindo o Prefixo Global de Rotas
-
-Você pode definir um prefixo global para todas as rotas na sua aplicação. Isso é útil quando você quer versionar suas APIs.
-
-### Template Não Opinativo
-
-Você pode definir o prefixo global no método `bootstrap` da sua aplicação.
-
-```typescript
-async function bootstrap() {
-  const app = await AppFactory.create(container, []);
-
-  app.setGlobalRoutePrefix("/api");
-
-  await app.listen(3000, ServerEnvironment.Development);
-}
-```
-
-### Template Opinativo
-
-Você pode definir o prefixo global no método `configureServices` da sua aplicação.
-
-
-```typescript
-@provide(App)
-class App extends AppExpress {
-  private middleware: IMiddleware;
-  private provider: IProvider;
-
-  constructor() {
-    super();
-    this.middleware = container.get<IMiddleware>(Middleware);
-    this.provider = container.get<IProvider>(Provider);
-  }
-
-  protected configureServices(): void {
-    this.setGlobalRoutePrefix("/v1");
-
-    this.middleware.addBodyParser();
-    this.middleware.setErrorHandler();
-  }
-
-  protected postServerInitialization(): void {
-    if (this.isDevelopment()) {
-      this.provider.envValidator.checkAll();
-    }
-  }
-
-  protected serverShutdown(): void {}
-}
-```
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
-- Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
-- Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
-- Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Compartilhe o projeto com seus amigos e colegas
\ No newline at end of file
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/governance.md b/i18n/pt/docusaurus-plugin-content-docs/current/governance.md
deleted file mode 100644
index 6e1d18b7..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/governance.md
+++ /dev/null
@@ -1,40 +0,0 @@
----
-sidebar_position: 7
----
-
-# Governança
-
-ExpressoTS é construído pela sua comunidade. Nós acolhemos e apreciamos contribuições de todos os tipos. Há muitas maneiras de ajudar, desde a reportagem de problemas, a contribuição de código e o auxílio para melhorar nossa comunidade.
-
-## Time Principal
-
-Atualmente, temos uma pequena equipe principal de contribuidores constantes. Estamos procurando expandir esta equipe para incluir mais pessoas da comunidade com uma ampla gama de habilidades e interesses.
-
-## Tomada de Decisão
-
-Cada decisão importante no ExpressoTS começa com uma proposta. As propostas podem ser escritas por qualquer pessoa da comunidade. A equipe principal revisará a proposta e decidirá se a aceitará, rejeitará ou solicitará mais informações.
-
-:::caution ALERTA DE SPOILER
-Estamos migrando o quadro do projeto e o roteiro de Jira para GitHub Projects. Isso nos permitirá ter um processo mais aberto e transparente, bem como permitir que a comunidade participe de maneira mais ativa no projeto.
-:::
-
-## Time
-
-Conheça a equipe de colaboradores regulares: **[Team](https://expresso-ts.com/team)**
-
-## Quer ajudar?
-
-**[Corriga um bug or submeta uma idéia](https://github.com/expressots/expressots/issues/new/choose)**
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
-- Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
-- Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
-- Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Compartilhe o projeto com seus amigos e colegas
\ No newline at end of file
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/hello.md b/i18n/pt/docusaurus-plugin-content-docs/current/hello.md
deleted file mode 100644
index c227a908..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/hello.md
+++ /dev/null
@@ -1,55 +0,0 @@
----
-sidebar_position: 0
----
-
-# Bem-vindo ao ExpressoTS!
-
-ExpressoTS é projetado para simplificar o processo de desenvolvimento de software, permitindo que os desenvolvedores se concentrem na lógica de negócios principal, abstraindo complexidades técnicas. Nosso objetivo é aumentar sua produtividade por meio de uma estrutura que não apenas acelera o desenvolvimento, mas também oferece documentação abrangente e uma experiência de desenvolvedor superior, minimizando a necessidade de código genérico e repetitivo.
-
-Nosso compromisso é duplo: simplificar seu trabalho de desenvolvimento e aumentar sua produtividade. À medida que embarcamos nesta jornada, convidamos você a se juntar ao nosso projeto impulsionado pela comunidade. Suas percepções, feedback e contribuições são inestimáveis na criação de uma experiência de desenvolvedor ótima para todos.
-
-Agradecemos seu apoio neste empreendimento. Vamos codificar de forma eficiente juntos. 🐎
-
----
-
-## Navegando na documentação
-
-Esta documentação está organizada em seções distintas, cada uma focando em um aspecto específico do ExpressoTS. Utilize a barra lateral à esquerda para navegar pelo conteúdo:
-
--   **Visão geral**: Fornece informações gerais sobre o ExpressoTS, incluindo recursos do projeto, conceitos, objetivos e instruções de configuração inicial.
--   **Code By Example**: Oferece exemplos práticos para demonstrar a aplicação dos recursos do ExpressoTS.
--   **CLI**: detalha a interface da linha de comando, incluindo instruções de uso.
--   **Providers**: Descreve os providers disponíveis e sua utilização.
--   **Tutorial**: um guia passo a passo abrangente para realizar tarefas específicas no ExpressoTS.
--   **Roadmap**: descreve a direção futura e os recursos planejados do ExpressoTS.
--   **Governança**: explica o modelo de governança do ExpressoTS e descreve como contribuir para o projeto.
-
-## Compreendendo os tipos de alerta
-
-Ao longo desta documentação, vários formatos são utilizados para chamar a atenção para diferentes tipos de informação:
-
--   **Links**: O texto em negrito indica hiperlinks para outras páginas de documentação ou recursos externos.
--   **Código**: trechos de código, comandos e termos técnicos importantes são destacados.
--   **Alertas**: Alertas específicos são empregados para enfatizar informações cruciais, utilizando os seguintes marcadores:
-
-:::note Transmite informações gerais ou lembretes.
-:::
-:::tip Fornece sugestões úteis ou práticas recomendadas.
-:::
-:::info Oferece informações adicionais e não críticas.
-:::
-:::caution Alertas para potenciais spoilers ou conteúdo sensível.
-:::
-:::danger Sinaliza possíveis problemas ou riscos que podem impactar o desenvolvimento.
-:::
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/_category_.json b/i18n/pt/docusaurus-plugin-content-docs/current/overview/_category_.json
deleted file mode 100644
index ba1f2fbf..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/_category_.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "label": "Overview",
-  "position": 2,
-  "link": {
-    "type": "generated-index",
-    "description": "Expresso TS Framework Overview."
-  }
-}
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/app-container.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/app-container.md
deleted file mode 100644
index 7b4d707f..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/app-container.md
+++ /dev/null
@@ -1,107 +0,0 @@
----
-sidebar_position: 3
----
-
-# App Container
-
-O ExpressoTS utiliza o **[InversifyJS](https://inversify.io/)** para suas capacidades de contêiner de Inversão de Controle (IoC), fornecendo um sistema robusto para injeção de dependências. Este contêiner consciente de tipos facilita a instanciação de objetos, resolução e gestão de ciclo de vida, possibilitando a criação de dependências complexas com código mínimo.
-
-O encapsulador AppContainer simplifica a integração, permitindo um registro direto de controladores, casos de uso e provedores dentro da aplicação.
-
-## Configurando o contêiner
-
-O contêiner da aplicação pode ser personalizado com escopos padrões para a vinculação de dependências e opções para pular verificações de classes base, aumentando a flexibilidade na gestão de dependências.
-
--   **defaultScope**: O escopo padrão, `RequestScope`, cria uma nova instância de uma dependência para cada solicitação, enquanto `SingletonScope` cria uma única instância compartilhada por todas as solicitações. O `TransientScope` cria uma nova instância cada vez que a dependência é solicitada.
--   **skipBaseClassChecks**: Quando definido como `true`, o contêiner irá pular as verificações de classes base ao trabalhar com classes derivadas.
--   **autoBindInjectable**: Quando definido como `true`, o contêiner irá injetar automaticamente classes que não estão explicitamente vinculadas.
-
-Aqui está a definição das opções de interface:
-
-```typescript
-interface ContainerOptions {
-    /**
-     * O escopo padrão para as ligações no contêiner.
-     * Pode ser definido como Request (padrão), Singleton ou Transient.
-     */
-    defaultScope?: interfaces.BindingScope;
-
-    /**
-     * Permite ignorar as verificações da classe base ao trabalhar com classes derivadas.
-     */
-    skipBaseClassChecks?: boolean;
-
-    /**
-     * Permite a injeção automática de classes que não estão explicitamente vinculadas ao contêiner.
-     */
-    autoBindInjectable: false;
-}
-```
-
-Criando o container:
-
-```typescript
-// Adicionando opções ao contêiner
-export const appContainer: AppContainer = new AppContainer({
-    defaultScope: BindingScopeEnum.Singleton,
-    skipBaseClassChecks: true,
-    autoBindInjectable: false,
-});
-
-// Criando um gerenciador de módulos de contêiner
-const container = appContainer.create([
-    // Adicione seus módulos aqui
-    AppModule,
-]);
-
-export { container };
-```
-
-## Definindo o escopo do container
-
-Como mencionado acima, se o `defaultScope` não for fornecido, o padrão é definido como `RequestScope`. No entanto, é possível alterar o escopo padrão passando o `defaultScope` como uma opção no construtor do contêiner. O `BindingScopeEnum` contém os seguintes valores:
-
--   `BindingScopeEnum.Singleton` - A dependência será criada uma vez e será compartilhada entre todas as solicitações.
--   `BindingScopeEnum.Request` - A dependência será criada uma vez por solicitação.
--   `BindingScopeEnum.Transient` - A dependência será criada toda vez que for solicitada.
-
-## Visualizando as vinculações do contêiner
-
-O contêiner pode ser usado para visualizar todas as vinculações que foram registradas. Isso pode ser útil para fins de depuração ou para entender as dependências que foram registradas.
-
-```typescript
-appContainer.viewContainerBindings();
-```
-
-![Container Bindings View](./img/container-bindings.png)
-
-## Registrando modulos
-
-O `appContainer` facilita o registro de módulos por meio de seu método `create([])`, que aceita um array de módulos. Esta abordagem simplificada reduz a complexidade da configuração e alinha-se com o objetivo do ExpressoTS de simplificar a arquitetura da aplicação:
-
-```typescript
-// Cria novo container
-const appContainer: AppContainer = new AppContainer();
-
-const container: Container = appContainer.create([
-    // Registrar todos os módulos
-    UserModule,
-    PaymentModule,
-    ProductModule,
-]);
-```
-
-O uso do `appContainer` abstrai as complexidades do uso direto do InversifyJS, proporcionando um caminho direto para integrar e gerenciar módulos dentro das aplicações ExpressoTS.
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/application.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/application.md
deleted file mode 100644
index 796fd07a..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/application.md
+++ /dev/null
@@ -1,151 +0,0 @@
----
-sidebar_position: 2
----
-
-# Aplicação
-
-No coração de uma aplicação ExpressoTS está a classe App. Ela serve como a fundação para criar e configurar o servidor. Adicionalmente, a classe App permite que middlewares e provedores sejam configurados no processo de inicialização do servidor. A classe App também oferece hooks (ganchos) de ciclo de vida que permitem aos desenvolvedores executar código antes, depois e durante o desligamento do servidor. Esta seção fornece uma visão geral da arquitetura da aplicação ExpressoTS, seus componentes e o fluxo de trabalho de uma aplicação ExpressoTS.
-
-![Visão Geral da Aplicação](./img/app-overview.png)
-
-## Arquitetura da aplicação
-
-A arquitetura de uma aplicação ExpressoTS é construída em torno do **[Inversify](https://inversify.io/)**, um contêiner IoC (Inversão de Controle), que é usado para identificar e injetar dependências nos construtores das classes. Essa abordagem permite que o contêiner IoC carregue todos os módulos necessários, incluindo suas respectivas rotas (controllers). Utilizando casos de uso e provedores (providers) conforme necessário, as rotas podem lidar com as solicitações recebidas.
-
-## Componentes principais e suas funções
-
-A arquitetura de uma aplicação ExpressoTS é baseada em vários componentes fundamentais:
-
--   **DTO IN/OUT**: Define a estrutura para dados de entrada e saída, garantindo segurança de tipo e consistência em toda a aplicação.
--   **Controller**: Gerencia o processamento de solicitações, roteamento baseado na URL e no método HTTP, e validação de dados.
--   **Use Case**: Executa lógica específica para o tratamento de solicitações, atuando sobre dados validados pelos controladores para realizar operações e retornar respostas.
--   **Provider**: Fornece funcionalidades externas como acesso a banco de dados, serviços de email ou mecanismos de autenticação.
--   **Repository**: Facilita a comunicação direta com o banco de dados para operações CRUD, abstraindo a camada de dados.
-
-:::info
-Provedores e Repositórios são componentes opcionais. Você pode usá-los se precisar fornecer funcionalidades extras para sua aplicação, como integração com banco de dados, sistema de log, autenticação, email, etc.
-:::
-
-## Fluxo de trabalho da aplicação
-
-O fluxo de trabalho começa com a inicialização do servidor, incluindo a configuração do contêiner, módulos e controladores. Ao receber solicitações, o servidor invoca o controlador relevante, que então aciona o caso de uso correspondente. Se necessário, os casos de uso interagem com provedores para acessar recursos ou serviços externos.
-
-:::warning Inicializando a Aplicação sem um controlador
-O ExpressoTS impedirá que você inicialize a Aplicação sem um controlador, já que não há ouvintes para lidar com as solicitações recebidas. Você verá a seguinte mensagem no console:
-**_No controllers have been found! Please ensure that you have register at least one Controller._**
-:::
-
-## Classe AppExpress
-
-A classe AppExpress oferece uma maneira de criar e configurar o servidor, passando **[middlewares do Express.js](https://expressjs.com/en/guide/writing-middleware.html)**, registrando provedores externos e configurando o ambiente do servidor. A classe AppExpress fornece três hooks de ciclo de vida que permitem aos desenvolvedores executar código antes, depois e durante o desligamento do servidor. A seguir, está a estrutura da classe AppExpress:
-
-```typescript
-export class App extends AppExpress {
-    private middleware: IMiddleware;
-    private provider: ProviderManager;
-
-    constructor() {
-        super();
-        this.middleware = container.get<IMiddleware>(Middleware);
-        this.provider = container.get(ProviderManager);
-    }
-
-    protected configureServices(): void {
-        this.provider.register(Env);
-
-        this.middleware.addBodyParser();
-        this.middleware.setErrorHandler();
-    }
-
-    protected postServerInitialization(): void {
-        if (this.isDevelopment()) {
-            this.provider.get(Env).checkAll();
-        }
-    }
-
-    protected serverShutdown(): void {}
-}
-```
-
-:::info
-A classe `App` oferece um conjunto de middlewares e provedores prontos para uso que podem ser utilizados para configurar sua aplicação. Veja a lista completa na **[seção de Middlewares](./middleware.md)**
-:::
-
-## Inicialização da aplicação
-
-O processo de inicialização da aplicação envolve a criação do servidor, passando o contêiner, a classe App e iniciando o servidor. A classe AppFactory fornece o método create e listen que permite aos desenvolvedores criar o servidor e ouvir solicitações de entrada. A seguir, está a função Bootstrap que cria o servidor:
-
-```typescript
-async function bootstrap() {
-    const app = await AppFactory.create(container, App);
-    await app.listen(3000, ServerEnvironment.Development);
-}
-```
-
-:::info
-O framework atualmente suporta o Express como seu adaptador principal, com Fastify e outros possíveis servidores internos em desenvolvimento.
-:::
-
-### Gerenciamento de ambiente
-
-O ambiente do servidor é definido através do enum `ServerEnvironment`, com suporte para os modos `development` (desenvolvimento) e `production` (produção), padrão para desenvolvimento se `NODE_ENV` não estiver configurado.
-
--   ServerEnvironment.Development;
--   ServerEnvironment.Production;
-
-## Hooks de ciclo de vida da aplicação
-
-Um outro aspecto importante da classe Application são os hooks de ciclo de vida. Esses hooks permitem que os desenvolvedores executem código antes, depois e durante o desligamento do servidor.
-
-```typescript
-    /* Add any service that you want to be initialized before the server starts */
-    protected configureServices(): void { }
-
-    /* Add any service that you want to execute after the server starts */
-    protected postServerInitialization(): void { }
-
-    /* Add any service that you want to execute after server is shutdown */
-    protected serverShutdown(): void { }
-```
-
-### Ordem de execução dos hooks
-
-![Hooks de ciclo de vida da aplicação](./img/app-life-cycle.png)
-
-## Scripts da aplicação
-
-Scripts para construir, executar e testar a aplicação são fornecidos, acomodando diferentes estágios de desenvolvimento e necessidades operacionais, desde o desenvolvimento até a produção.
-
-| Script           | Descrição                                             | Comando            |
-| ---------------- | ----------------------------------------------------- | ------------------ |
-| expressots build | Constrói o pacote de produção na pasta ./dist.        | npm run build      |
-| expressots dev   | Executa em modo de desenvolvimento com observação.    | npm run dev        |
-| expressots prod  | Executa em modo de produção com base no pacote built. | npm run prod       |
-| test             | Executa os testes localizados na pasta test.          | npm run test       |
-| test:watch       | Executa os testes em modo de observação e interativo. | npm run test:watch |
-| test:cov         | Gera relatorio de cobertura de testes.                | npm run test:cov   |
-| format           | Formatar código usando prettier.                      | npm run format     |
-| lint             | Lint código usando eslint.                            | npm run lint       |
-
-## Executando a aplicação
-
-```bash
-npm run dev
-```
-
-Isso iniciará a aplicação com saída no console indicando a versão, porta em execução e ambiente, fornecendo um feedback claro sobre o estado de execução da aplicação.
-
-`expressots-demo version 1.0.0 is running on port 3000 - Environment: development`
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/controller.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/controller.md
deleted file mode 100644
index 91ee86c8..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/controller.md
+++ /dev/null
@@ -1,202 +0,0 @@
----
-sidebar_position: 6
----
-
-# Controladores
-
-Os Controladores atuam como a principal interface entre o cliente e o servidor em aplicações Node.js. Eles lidam com as requisições recebidas, validam os dados conforme o DTO de entrada, e retornam as respostas no formato DTO. Em essência, os controllers atuam como a ponte entre os clientes e as camadas de serviço, também conhecidas como casos de uso.
-
-**Exemplo de Controler Padrão MVC**
-
-![Controler Padrão MVC](./img/controller-mvc.png)
-
-**Exemplo de Controler Padrão de Responsabilidade Única**
-
-![Controler Padrão de Responsabilidade Única](./img/controller-single-resp.png)
-
-Para criar um controlador básico, criamos uma classe e usamos o decorador `@controller()` para definir a rota do controlador. Em seguida, criamos um método e usamos os decoradores `http Methods` para definir a rota e o método HTTP para o método.
-
-## Classe Controler
-
-### Padrão MVC
-
-Múltiplas rotas em um único controlador.
-
-```typescript
-@controller("/user")
-export class UserController {
-    @Post("/")
-    create(@response() res: Response) {
-        return res.send("User created");
-    }
-
-    @Get("/")
-    getUser(@response() res: Response) {
-        return res.send("User listed");
-    }
-}
-```
-
-### Padrão de Responsabilidade Única
-
-Um controlador, um método de execução e um caso de uso.
-
-```typescript
-@controller("/user/create")
-export class UserCreateController {
-    @Post("/")
-    execute(@response() res: Response) {
-        return res.send("User created");
-    }
-}
-```
-
-:::tip
-Tanto os decoradores `@controller()` quanto `http methods` funcionam em combinação para definir a rota e os middlewares a serem usados no endpoint.
-:::
-
-## Escopo do controller
-
-O escopo padrão de um controlador é `Request`, pois é herdado do `AppContainer` e do escopo de classe padrão `Module`. No entanto, você pode substituir o escopo de um controlador usando o decorador `@scope()`. Este decorador aceita os mesmos valores de enumeração BindingScopeEnum.
-
-:::info
-Se você definir o escopo do módulo, não poderá substituí-lo em um controlador específico usando o decorador `@scope`.
-O decorador `@scope` só pode ser usado em controladores específicos se o escopo do módulo não estiver definido.
-:::
-
-Aqui está um exemplo de uso:
-
-```typescript
-@scope(BindingScopeEnum.Singleton)
-@controller("/")
-class CreateUserController extends BaseController {}
-```
-
-O controlador acima terá o escopo de `Singleton` e será compartilhado entre todas as solicitações.
-
-## Classe BaseController
-
-A classe `BaseController` é utilizada como base para as classes de controller, oferecendo no construtor um parâmetro que o desenvolvedor pode indicar qual serviço ou domínio ele está atualmente construindo. Isso ajuda o sistema de log a lançar erros com mais informações sobre o contexto do erro e onde o erro ocorreu.
-
-Outra vantagem de usar a classe `BaseController` é que ela oferece um método em duas versões diferentes, assíncrona e síncrona, que é o `callUseCase()` ou `callUseCaseAsync()`.
-
-Esses métodos reforçam a ideia de um caso de uso por controller e são responsáveis por chamar o caso de uso que irá implementar a lógica de negócio do controller.
-
-:::tip
-Os métodos callUseCase, disponíveis nas versões síncrona e assíncrona, são adequados para retornar status e respostas JSON aos clientes, pois os usuários precisam apenas passar o retorno do useCase, res: Response e o código de status.
-:::
-
-Esta é a assinatura do método `callUseCase`:
-
-```typescript
-callUseCase(useCase: any, res: any, successStatusCode: number);
-```
-
--   `useCase`: O caso de uso a ser chamado. O caso de uso é injetado no construtor do controler.
--   `res`: O objeto resposta do tipe express Response.
--   `successStatusCode`: O código de status indica o resultado da solicitação HTTP e é enviado ao cliente quando o caso de uso é executado com êxito. Para mais informações sobre Status code visite **[Http Status Code](./status-code.md)**.
-
-Resposta padrão:
-
-```typescript
-return res.status(successStatusCode).json(dataReturn);
-```
-
-Um exemplo mais completo de uma classe de controlador que herda da classe BaseController é mostrado abaixo:
-
-```typescript
-@controller("/")
-class AppController extends BaseController {
-    constructor(private appUseCase: AppUseCase) {
-        super("app-controller");
-    }
-
-    @httpGet("/")
-    execute(@response() res: any): IAppResponseDTO {
-        return this.callUseCase(this.appUseCase.execute(), res, StatusCode.OK);
-    }
-}
-```
-
-## Decoradores do controlador
-
-Os decoradores de métodos HTTP e parâmetros são um conjunto de anotações usadas em aplicações ExpressoTS para definir o roteamento e o tratamento de solicitações HTTP. O uso desses decoradores pode simplificar o roteamento e o tratamento de solicitações HTTP em aplicações Node.js e tornar o código mais legível e fácil de manter.
-
-### Decoradores de métodos HTTP
-
-Aqui está uma lista de todos os decoradores `@httpMethods()` disponíveis no ExpressoTS, juntamente com sua descrição e uso:
-
-| Decorador   | Descrição                                                      | Uso                      |
-| ----------- | -------------------------------------------------------------- | ------------------------ |
-| @Get        | Vincula um método de controlador a um verbo HTTP GET.          | @Get("/path")            |
-| @Post       | Vincula um método de controlador a um verbo HTTP POST.         | @Post("/path")           |
-| @Put        | Vincula um método de controlador a um verbo HTTP PUT.          | @Put("/path")            |
-| @Patch      | Vincula um método de controlador a um verbo HTTP PATCH.        | @Patch("/path")          |
-| @Head       | Vincula um método de controlador a um verbo HTTP HEAD.         | @Head("/path")           |
-| @Delete     | Vincula um método de controlador a um verbo HTTP DELETE.       | @Delete("/path")         |
-| @Method     | Vincula um método de controlador a um verbo HTTP especificado. | @Method("verb", "/path") |
-
-### Decoradores de parâmetros
-
-Aqui está uma lista de todos os decoradores de parâmetros disponíveis no ExpressoTS, juntamente com sua descrição e uso:
-
-| Decorator                            | Descrição                                                        | Uso                                                    |
-| ------------------------------------ | ---------------------------------------------------------------- | ------------------------------------------------------ |
-| @request()                           | Injeta objeto Express Request.                                   | execute(@request() req: Request)                       |
-| @response()                          | Injeta objeto Express Response.                                  | execute(@response() res: Response)                     |
-| @requestParam(paramName?: string)    | Injeta um parâmetro da URL da solicitação.                       | execute(@requestParam('id') id: string)                |
-| @queryParam(paramName?: string)      | Injeta um parâmetro da string de consulta da URL da solicitação. | execute(@queryParam('searchTerm') searchTerm: string)  |
-| @requestBody()                       | Injeta a carga útil do corpo da solicitação.                     | execute(@requestBody() body: MyDTO)                    |
-| @requestHeaders(headerName?: string) | Injeta um cabeçalho dos cabeçalhos da solicitação.               | execute(@requestHeaders('authorization') auth: string) |
-| @cookies(cookieName?: string)        | Injeta um cookie dos cookies da solicitação.                     | execute(@cookies('session') session: string)           |
-| @next()                              | Injeta o objeto NextFunction do Express.                         | execute(@next() next: NextFunction)                    |
-
-## Padrão DTO
-
-O Data Transfer Object (DTO) é um padrão de design comumente usado em aplicações Node.js que padroniza os formatos de dados para a comunicação entre diferentes camadas da aplicação, incluindo cliente-servidor ou módulos de servidor. O DTO serve como uma interface para a troca de dados, garantindo estruturas claras e padronizadas para os dados de entrada e saída. Ao separar a lógica de negócios da lógica de comunicação, ajuda a reduzir a complexidade da aplicação e desacoplar diferentes camadas.
-
-O uso de DTOs pode melhorar o desempenho e a escalabilidade da aplicação, reduzindo a transferência de dados entre o cliente e o servidor e fornecendo maneiras mais eficientes de processar e manipular dados dentro da aplicação.
-
-### Exemplo de DTO
-
-Por exemplo, imagine um cenário de registro de usuário em que são coletados nome, e-mail e senha, e o ID é gerado automaticamente. O objeto DTO de usuário para entrada e resposta pode ter possíveis formatos, como mostrado abaixo:
-
-```typescript
-// UserCreateInputDTO
-interface UserCreateInputDTO {
-  name: string;
-  email: string;
-  password: string;
-}
-
-// UserCreateResponseDTO
-interface UserCreateResponseDTO {
-  id: string;
-  name: string;
-  status: string;
-}
-
-// Payload json formato
-{
-  "name": string,
-  "email": string,
-  "password": string
-}
-```
-
-Ter dois formatos diferentes de DTO é essencial nesse caso, porque ao registrar um usuário, não queremos retornar a senha para o cliente por motivos de segurança. Portanto, criamos um DTO diferente para a resposta, adicionando um campo complementar chamado status, onde é enviada uma mensagem ao cliente, indicando que o usuário foi criado com sucesso.
-
-Como resultado, os DTOs ajudam a segregar e filtrar os dados enviados ao cliente, reduzindo a quantidade de dados processados pela aplicação.
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/decorators.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/decorators.md
deleted file mode 100644
index 0b4525b5..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/decorators.md
+++ /dev/null
@@ -1,71 +0,0 @@
----
-sidebar_position: 11
----
-
-# Decoradores
-
-Aqui está uma lista completa de todos os decoradores que estão disponíveis no ExpressoTS, bem como uma breve descrição do que eles fazem.
-
-## Decoradores de classes
-
-Decoradores disponíveis para suas classes.
-
-| Decoradores       | Descrição                                                                       |
-| ----------------- | ------------------------------------------------------------------------------- |
-| @provide          | Vincula a classe ao container de injeção de dependência.                        |
-| @provideSingleton | Vincula a classe ao contêiner de injeção de dependência como Singleton.         |
-| @provideTransient | Vincula a classe ao contêiner de injeção de dependência como Transient.         |
-| @injectable       | Marca a classe como disponível para ser injetada.                               |
-| @inject           | Marca a classe como disponível para ser injetada no construtor de outra classe. |
-
-## Decoradores do controlador
-
-Decoradores disponíveis para seus controladores.
-
-| Decoradores | Descrição                                  | Exemplo de Uso                                               |
-| ----------- | ------------------------------------------ | ------------------------------------------------------------ |
-| @controller | Marca a classe como controlador injetável. | @controller("/path", middleware[])                           |
-| @scope      | Vincula um controlador a um escopo.        | @scope(BindingScopeEnum.Singleton, ou Request, ou Transient) |
-
-### Decoradores de métodos HTTP
-
-Decoradores disponíveis para seus métodos de controlador.
-
-| Decorador | Descrição                                                      | Uso                      |
-| --------- | -------------------------------------------------------------- | ------------------------ |
-| @Get      | Vincula um método de controlador a um verbo HTTP GET.          | @Get("/path")            |
-| @Post     | Vincula um método de controlador a um verbo HTTP POST.         | @Post("/path")           |
-| @Put      | Vincula um método de controlador a um verbo HTTP PUT.          | @Put("/path")            |
-| @Patch    | Vincula um método de controlador a um verbo HTTP PATCH.        | @Patch("/path")          |
-| @Head     | Vincula um método de controlador a um verbo HTTP HEAD.         | @Head("/path")           |
-| @Delete   | Vincula um método de controlador a um verbo HTTP DELETE.       | @Delete("/path")         |
-| @Method   | Vincula um método de controlador a um verbo HTTP especificado. | @Method("verb", "/path") |
-| @Http     | Define o código de status HTTP para a resposta.                | @Http(200)               |
-
-### Decoradores de parâmetros
-
-Aqui está uma lista de todos os decoradores de parâmetros disponíveis no ExpressoTS, juntamente com sua descrição e uso:
-
-| Decorador                     | Descrição                                                        | Uso                                              |
-| ----------------------------- | ---------------------------------------------------------------- | ------------------------------------------------ |
-| @request()                    | Injeta objeto Express Request.                                   | execute(@request() req: Request)                 |
-| @response()                   | Injeta objeto Express Response.                                  | execute(@response() res: Response)               |
-| @param(paramName?: string)    | Injeta um parâmetro da URL da solicitação.                       | execute(@param('id') id: string)                 |
-| @query(paramName?: string)    | Injeta um parâmetro da string de consulta da URL da solicitação. | execute(@query('searchTerm') searchTerm: string) |
-| @body()                       | Injeta a carga útil do corpo da solicitação.                     | execute(@body() body: MyDTO)                     |
-| @headers(headerName?: string) | Injeta um cabeçalho dos cabeçalhos da solicitação.               | execute(@headers('authorization') auth: string)  |
-| @cookies(cookieName?: string) | Injeta um cookie dos cookies da solicitação.                     | execute(@cookies('session') session: string)     |
-| @next()                       | Injeta o objeto NextFunction do Express.                         | execute(@next() next: NextFunction)              |
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/dependencies.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/dependencies.md
deleted file mode 100644
index 70110d7b..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/dependencies.md
+++ /dev/null
@@ -1,52 +0,0 @@
----
-sidebar_position: 13
----
-
-# Dependências
-
-O propósito desta seção é listar todas as dependências usadas pelo ExpressoTS e nossa visão sobre o gerenciamento de dependências.
-
-## Gestão de dependências
-
-Sabemos que ter dependências acelera o processo de desenvolvimento, mas também aumenta a complexidade do projeto e o custo de manutenção. Além disso, outro aspecto que consideramos é o risco de segurança que uma dependência pode trazer para o projeto.
-
-Nosso objetivo é manter o número de dependências o mais baixo possível, tentando usar apenas as que são realmente necessárias e que não fazem parte dos mecanismos principais do framework ExpressoTS. Com isso em mente, temos em nosso Roadmap algumas dependências que gostaríamos de substituir por nossa própria implementação. Mais notícias em breve.
-
-Enquanto isso, vamos continuar monitorando de perto as dependências, utilizando ferramentas como o **[Dependabot](https://dependabot.com/)** para mantê-las atualizadas e também utilizando ferramentas como o **[Snyk](https://snyk.io/)** para ficar de olho nos riscos de segurança.
-
-## Pacotes Utilitários (Dependencias de Desenvolvimento)
-
--   @commitlint/cli: Lint mensagens de commit
--   @commitLint/config-conventional: Lint mensagens de commit
--   @release-it/conventional-changelog: Gera changelog
--   dotenv: Carregar variáveis de ambiente
--   husky: Git hooks
--   prettier: Formatador de códigos
--   eslint: Linting code
--   ts-node-dev: Executa arquivos de typescript
--   tsconfig-paths: Resolve caminhos através do tsconfig.json
-
-## Pacotes Core
-
--   express: Servidor Http
--   inversify: IoC container
--   inversify-binding-decorators: Decoradores do inversify
--   reflect-metadata: Polyfill para metadados e reflexão
-
-## Teste
-
--   vitest: Framework de teste
--   vite: Vitest's requerimento
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/di.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/di.md
deleted file mode 100644
index 39a145ba..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/di.md
+++ /dev/null
@@ -1,124 +0,0 @@
----
-sidebar_position: 12
----
-
-# Injeção de Dependências
-
-Dependency Injection (DI) é um padrão de design usado no desenvolvimento de software que envolve fornecer a um objeto as instâncias das classes necessárias para executar suas tarefas, em vez de fazer com que ele mesmo construa essas instâncias. Este processo de `fornecer` instâncias é chamado de `injetar` nelas, daí o termo Injeção de Dependência.
-
-## Benefícios do DI
-
-Aqui estão alguns dos principais benefícios do uso da injeção de dependência:
-
--   Desacoplamento: DI ajuda a desacoplar os componentes do seu aplicativo. Em vez de os componentes criarem os objetos dos quais dependem, esses objetos são passados (injetados) por uma estrutura ou contêiner de DI. Isso significa que os componentes não precisam saber sobre o funcionamento interno de suas dependências, e as dependências podem ser trocadas sem que o componente saiba ou se importe.
-
--   Testabilidade: DI facilita o teste de unidade. Como as dependências são injetadas, você pode facilmente fornecer objetos fictícios durante o teste. Isso permite que cada unidade de código seja testada isoladamente, com controle total sobre suas dependências.
-
--   Código reutilizável: com DI, suas classes são normalmente projetadas para funcionar com interfaces em vez de classes concretas. Isso significa que você pode reutilizar a mesma classe em diferentes contextos, com diferentes dependências injetadas.
-
--   Manutenção mais fácil e maior eficiência: centralizando a criação de objetos e reduzindo a quantidade de instanciação de classe codificada, a manutenção se torna mais fácil. Quando uma classe muda, normalmente você só precisa atualizar o código em um lugar.
-
--   Configurabilidade: Você pode configurar sua estrutura de aplicação externamente, normalmente através de XML ou arquivos similares. Isso significa que você pode modificar a estrutura e as dependências de seus componentes sem precisar modificar o próprio código.
-
--   Ciclos de vida e escopo: gerencie o ciclo de vida de objetos injetados e controle seu escopo (por exemplo, escopo singleton, escopo de solicitação).
-
--   Gerenciamento de simultaneidade: os contêineres podem lidar automaticamente com tempos de vida de serviço em um ambiente simultâneo, o que pode ser uma tarefa complexa para lidar corretamente sem essa ferramenta.
-
-Em conclusão, DI é uma técnica que facilita o acoplamento fraco, maior capacidade de teste e código mais flexível e de fácil manutenção.
-
-## DI no ExpressoTS
-
-Aqui está como o ExpressoTS implementa DI:
-
-![Application Overview](./img/di.png)
-
-## Divisão dos componentes DI
-
-Aqui está uma análise dos componentes DI usados no ExpressoTS:
-
-| Componentes | Descrição                                                                                                             |
-| ----------- | --------------------------------------------------------------------------------------------------------------------- |
-| Container   | O container DI do aplicativo ExpressoTS.                                                                              |
-| Module      | Um módulo de contêiner é normalmente usado para agrupar controladores relacionados e suas dependências.               |
-| Controller  | Interface primária entre o cliente e o servidor. Responsável por lidar com as solicitações recebidas.                 |
-| Classes     | Qualquer outra classe que faça parte do ecossistema ExpressoTS, por exemplo, fornecedores, entidades, ajudantes, etc. |
-
-### Resumo
-
--   O contêiner tem seu escopo padrão que pode ser substituído pelo módulo. O escopo padrão é o escopo `Request`.
--   Definir um escopo para um módulo força todos os controladores desse módulo a terem o mesmo escopo.
--   Não definir um escopo para um módulo permite que os controladores tenham seu próprio escopo usando o decorador `@scope()`.
--   Todas as outras classes cadastradas como provedores, entidades, helpers podem ter seu escopo específico baseado no decorador utilizado.
--   Decoradores:
-
-| Decoradores       | Descrição                                                                      |
-| ----------------- | ------------------------------------------------------------------------------ |
-| @provide          | Vincula uma classe a um contêiner de injeção de dependência como RequestScope. |
-| @provideSingleton | Vincula uma classe a um contêiner de injeção de dependência como Singleton.    |
-| @provideTransient | Vincula uma classe a um contêiner de injeção de dependência como Transient.    |
-
-### Container
-
-O contêiner é o principal componente do sistema DI. Ele é responsável por gerenciar o ciclo de vida dos objetos que cria e por injetar dependências nesses objetos.
-
-O escopo padrão do contêiner é o escopo `Request`. Isso significa que o contêiner criará uma nova instância de uma classe para cada solicitação. Para obter mais informações sobre **[Contêineres](app-container.md)**, consulte a seção de contêineres do aplicativo.
-
-### Módulos
-
-Um módulo contêiner é usado para organizar controladores relacionados e suas dependências e unidades coerentes. Os módulos também podem ter sua própria definição de escopo específica. Para obter mais informações sobre os módulos, consulte a seção **[Módulos](module.md)**.
-
-### Controladores
-
-Os controladores são agrupados em módulos que geralmente representam um recurso do aplicativo. Os controladores estão sempre associados a módulos. Se um módulo tiver um escopo específico definido, todos os controladores desse módulo serão criados com o escopo do módulo. Caso o módulo não tenha um escopo definido, ele herda o escopo do container Application, que é o escopo `Request`.
-
-Neste caso particular, controladores individuais podem ter seu próprio escopo definido usando o decorador `@scope()`. Para obter mais informações sobre controladores, consulte a seção **[Controllers](controller.md)**.
-
-### Classes
-
-Qualquer outra classe que faz parte do ecossistema ExpressoTS, por exemplo, provedores, entidades, classes auxiliares, etc são injetadas automaticamente no Application Container através do decorador `@provide()` no qual injeta as classes como `Request` por padrão.
-
-Se você quiser definir um escopo diferente para sua classe, você pode usar o decorador `@provideSingleton()` para injetar a classe como um singleton ou `@provideTransient()` para injetar a classe como transiente.
-
-Exemplo de uso:
-
-#### Request
-
-```typescript
-@provide(MyRequest)
-class MyRequest {}
-```
-
-#### Singleton
-
-```typescript
-@provideSingleton(MySingleton)
-class MySingleton {}
-```
-
-#### Transient
-
-```typescript
-@provideTransient(MyTransient)
-class MyTransient {}
-```
-
-:::tip
-Para definir as ligações de escopo, o enum BindingScopeEnum pode ser usado.
-:::
-
--   `BindingScopeEnum.Singleton` - A dependência será criada uma vez e será compartilhada entre todas as solicitações.
--   `BindingScopeEnum.Request` - A dependência será criada uma vez por solicitação.
--   `BindingScopeEnum.Transient` - A dependência será criada toda vez que for solicitada.
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/entities.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/entities.md
deleted file mode 100644
index be779fd8..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/entities.md
+++ /dev/null
@@ -1,135 +0,0 @@
----
-sidebar_position: 10
----
-
-# Entidades
-
-As entidades são os componentes principais de uma aplicação ExpressoTS. Elas são os objetos que são usados para representar os dados que serão manipulados pela aplicação.
-
-Se uma entidade mudar, provavelmente os casos de uso e controladores também mudarão. Isso ocorre porque os casos de uso e controladores são responsáveis por manipular os dados representados pelas entidades.
-
-## Exemplo de entidade
-
-Um exemplo simples de uma entidade User e suas propriedades:
-
-```typescript
-@provide(User)
-class User {
-    private id: string;
-    public name: string;
-    public email: string;
-
-    constructor() {
-        this.id = uuidv4();
-    }
-
-    get Id(): string {
-        return this.id;
-    }
-}
-```
-
-:::tip
-Lembre-se que você deve ter um arquivo por entidade
-:::
-
-## Entidades e encapsulamento
-
-Esta seção é dedicada a promover uma reflexão quando se pensa em entidades. Por anos, nos foi dito que as propriedades das entidades ou classes devem ser encapsuladas, seus métodos devem abstrair a implementação interna e expor apenas as informações necessárias para o mundo externo. Esta é uma boa prática ao pensar no Paradigma de Programação Orientada a Objetos, no entanto, nem sempre é a melhor abordagem.
-
-Se você pensar sobre isso, classes ou entidades, qualquer que seja o nome que você dê a elas, são apenas uma maneira de representar dados. Elas são apenas uma maneira de agrupar dados juntos. Com isso em mente, as classes ou entidades se tornam muito mais simples de manter e entender, pois não contêm nenhuma lógica.
-
-Esta forma de pensar é chamada de **[Modelo de Domínio Anêmico](https://martinfowler.com/bliki/AnemicDomainModel.html)** e é um tópico muito controverso. Não é o objetivo desta documentação discutir este tópico, mas é importante mencioná-lo, já que é um conceito muito importante quando se pensa em ExpressoTS.
-
-**Diga adeus as classes God, seja bemvindo simples entidades, seja bemvindo o dado.**
-
-## Injeção de entidade
-
-Se sua entidade tiver dependências, você pode injetá-las usando o decorador `@inject`.
-
-```typescript
-@provide(User)
-class User {
-    constructor(@inject("logger") private logger: Logger) {}
-}
-```
-
-## Evite isso
-
-Evite marcar construtores com parâmetros primitivos como injetáveis. Isso ocorre porque pode ser difícil para o contêiner de DI inferir quais valores fornecer para esses parâmetros. Aqui está um exemplo do que você deve evitar:
-
-```typescript
-@provide(User)
-class User {
-    name: string;
-    constructor(name: string) {
-        this.name = name;
-    }
-}
-```
-
-:::caution
-Em muitos sistemas de injeção de dependência (DI), incluindo InversifyJS, o contêiner de DI é responsável por construir objetos e injetar dependências. Quando um construtor de classe contém parâmetros primitivos, pode ser difícil para o contêiner de DI inferir quais valores fornecer para esses parâmetros. Isso ocorre porque os valores primitivos (como strings, números e booleanos) não carregam nenhum significado semântico inerente que o contêiner possa entender.
-:::
-
-### Razões para evitar parâmetro primitivo em classes injetáveis
-
-Aqui estão algumas das razões pelas quais construtores com parâmetros primitivos podem ser problemáticos em DI:
-
--   Ambigüidade: Se uma classe tiver um construtor que requer tipos primitivos, o contêiner DI não saberá quais valores injetar. Por exemplo, se uma classe requer um número em seu construtor, o container DI não sabe o que esse número representa e qual valor ele deve ter.
-
--   Inflexibilidade: Um valor primitivo no construtor implica que o valor é uma parte fixa da classe. No entanto, a DI é frequentemente usada para gerenciar partes intercambiáveis de um aplicativo (por exemplo, diferentes implementações de uma interface).
-
--   Não descritivo: valores primitivos geralmente não são descritivos e podem levar a códigos confusos. Por exemplo, um construtor que usa dois parâmetros de string pode levantar questões como: O que essas strings representam? Existem formatos ou restrições específicas nessas strings?
-
-## Injeção adequada de entidade
-
-Se você deseja injetar uma entidade em outra classe, deve repensar seu design. Se você realmente precisa de parâmetros primitivos em seu construtor, use fábricas para criar suas entidades ou o padrão Repository.
-
-Aqui está um exemplo de uma fábrica:
-
-```typescript
-@provide(User)
-class User implements IEntity {
-    public id: string;
-    public name!: string;
-    public email!: string;
-
-    constructor() {
-        this.id = randomUUID();
-    }
-}
-
-interface IUserFactory {
-    create(name: string, email: string): User;
-}
-
-@provide(UserFactory)
-class UserFactory implements IUserFactory {
-    create(name: string, email: string): User {
-        const user = new User();
-        user.name = name;
-        user.email = email;
-        return user;
-    }
-}
-
-export { User, UserFactory };
-```
-
-Agora `UserFactory` pode ser facilmente injetado em outras classes.
-
-Como mencionado acima, existem várias outras abordagens, desde que você permaneça forte 😁 de não usar construtores com parâmetros primitivos nas classes que planeja injetar.
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/error-handling.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/error-handling.md
deleted file mode 100644
index 57c73016..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/error-handling.md
+++ /dev/null
@@ -1,159 +0,0 @@
----
-sidebar_position: 15
----
-
-# Gerenciamento de Error
-
-Quando se trata de tratamento de erros nas APIs TypeScript do Node.js, existem várias práticas recomendadas e abordagens que você pode seguir. O ExpressoTS fornece uma maneira simples e fácil de lidar com erros.
-
--   Usamos códigos de status HTTP apropriadamente: HTTP **[códigos de status](./status-code.md)** são usados para indicar o status de uma resposta. É importante utilizá-los adequadamente em sua API para indicar o sucesso ou falha de uma operação.
-
--   Usamos um formato de erro consistente: defina um formato de erro consistente em sua API para que os consumidores possam entender e lidar facilmente com os erros.
-
--   Lidamos com erros em middleware: as funções de middleware são uma ótima maneira de lidar com erros em um local centralizado.
-
--   Usamos blocos try-catch: Use blocos try-catch para lidar com erros síncronos em seu código. Se ocorrer um erro no bloco try, o bloco catch pode lidar com isso. Certifique-se de lançar o erro para que ele possa ser tratado por nosso middleware de tratamento de erros.
-
--   Usamos tratamento de erro async/await: ao usar async/await, você pode usar blocos try-catch para lidar com erros síncronos em seu código. No entanto, você também precisa lidar com quaisquer erros assíncronos que possam ocorrer.
-
--   Registramos erros: o registro de erros é importante para depuração e monitoramento.
-
-## Nossa Abordagem
-
-Desenvolvemos uma classe de relatório de erro padronizada chamada Report que oferece um local centralizado para lançar e tratar erros, o que pode simplificar o tratamento de erros em toda a aplicação.
-
-Ao definir um formato de resposta de erro padrão, ajuda a garantir consistência nas mensagens de erro retornadas aos clientes.
-
-Esta abordagem é melhor usada em aplicações com um grande código-base ou lógica de negócios complexa, onde erros podem ocorrer com frequência e precisam ser tratados de forma consistente em diferentes partes da aplicação.
-
-### Report Error
-
-A classe Report é uma classe de utilitário para gerenciar e lançar erros específicos do aplicativo.
-
-```typescript
-class Report {
-    /**
-     * O método Error pega uma instância de Error e a lança.
-     * @param error - Uma instância de Error ou uma string que representa a mensagem de erro.
-     * @param statusCode - O código de status HTTP do erro.
-     * @param service - O serviço onde ocorreu o erro.
-     */
-    public static Error(error: Error | string, statusCode?: number, service?: string): void {}
-}
-```
-
-Depois de relatar um erro conhecido por meio do método `Report.Error()`, o erro será tratado pelo middleware `defaultErrorHandler()` e será retornado ao cliente no formato json analisado.
-
-### Middleware
-
-Essa função de middleware é usada para manipular erros que ocorrem durante o processamento da solicitação.
-
-```typescript
-/**
- * errorHandler é uma função de middleware de tratamento de erros personalizada do Express.
- * Ela registra o erro, define o código de status e envia uma resposta JSON contendo o código de status e a mensagem de erro.
- * @param error - Uma instância de AppError contendo detalhes do erro.
- * @param req - O objeto de solicitação do Express.
- * @param res - O objeto de resposta do Express.
- * @param next - A função next do Express para passar o controle para a próxima função de middleware.
- */
-function defaultErrorHandler(error: Error, req: Request, res: Response, next: NextFunction): void {
-    if (error instanceof AppError) {
-        res.status(error.statusCode).json({ statusCode: error.statusCode, error: error.message });
-    } else {
-        res.status(StatusCode.InternalServerError).json({
-            statusCode: StatusCode.InternalServerError,
-            error: "Ocorreu um erro inesperado.",
-        });
-    }
-}
-
-export default defaultErrorHandler;
-```
-
-:::info
-A função `defaultErrorHandler()` é uma função de middleware de tratamento de erros personalizada do Express.
-Ela registra o erro, define o código de status e envia uma resposta JSON contendo o código de status e a mensagem de erro.
-:::
-
-## Exemplo de uso
-
-```typescript
-class FooClass {
-    constructor(private report: Report) {}
-
-    execute() {
-        try {
-            // fazer algo
-        } catch (error: any) {
-            this.report.Error(error, StatusCode.BadRequest, "seu-servico");
-        }
-    }
-}
-```
-
-Use case example:
-
-```typescript
-@provide(CreateUserUseCase)
-class CreateUserUseCase {
-    constructor(private userRepository: UserRepository, private report: Report) {}
-
-    execute(data: ICreateUserRequestDTO): ICreateUserResponseDTO | null {
-        try {
-            const { name, email } = data;
-
-            const userAlreadyExists = await this.userRepository.findByEmail(email);
-
-            if (userAlreadyExists) {
-                this.report.Error(
-                    "User already exists",
-                    StatusCode.BadRequest,
-                    "create-user-usecase"
-                );
-            }
-
-            const user: User | null = this.userRepository.create(new User(name, email));
-
-            let response: ICreateUserResponseDTO;
-
-            if (user !== null) {
-                response = {
-                    id: user.Id,
-                    name: user.name,
-                    email: user.email,
-                    status: "success",
-                };
-                return response;
-            }
-
-            return null;
-        } catch (error: any) {
-            throw error;
-        }
-    }
-}
-```
-
-## Descrição dos componentes de tratamento de erro
-
-| Objeto        | Descrição                                                            |
-| ------------- | -------------------------------------------------------------------- |
-| Report.Error  | Método estático para reportar erros conhecidos.                      |
-| AppError      | Classe de erro do aplicativo que define o formato do objeto de erro. |
-| StatusCode    | Código de status HTTP.                                               |
-| Error Message | Detalhes da mensagem de erro que o desenvolvedor deseja registrar.   |
-| Error Service | Serviço que originou o erro, a ser utilizado no sistema de log.      |
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/expressots-config.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/expressots-config.md
deleted file mode 100644
index d418ead6..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/expressots-config.md
+++ /dev/null
@@ -1,59 +0,0 @@
----
-sidebar_position: 18
----
-
-# ExpressoTS Arquivo de Configuração
-
-O arquivo de configuração do ExpressoTS está localizado na pasta raiz do projeto e é chamado de `expressots.config.ts`. Este arquivo é usado para configurar o CLI e o projeto.
-
-Aqui está o arquivo de configuração atual com todas as opções disponíveis:
-
-```typescript
-import { ExpressoConfig, Pattern } from "@expressots/core";
-
-const config: ExpressoConfig = {
-    sourceRoot: "src",
-    scaffoldPattern: Pattern.KEBAB_CASE,
-    opinionated: true,
-    scaffoldSchematics: {
-        entity: "entity",
-        provider: "provider",
-        module: "module",
-        controller: "controller",
-        dto: "dto",
-        middleware: "middleware",
-        usecase: "useCases",
-    },
-};
-
-export default config;
-```
-
--   **sourceRoot**: a pasta raiz que será usada pelo CLI para criar os recursos. Padrão: `src`
-
--   **scaffoldPattern**: o padrão que será usado para criar os recursos. Padrão: `Pattern.KEBAB_CASE`. Exemplo: `user-create`
-
--   **opinionated**: se verdadeiro, o CLI criará os recursos usando a estrutura de pastas opinativa
-
--   **scaffoldSchematics**: os nomes de convenção de pasta para cada recurso. Padrão: `useCases`, `entities`, `providers`, `middlewares`, `controllers`, `dtos`. Com esquemas de montagem, você pode personalizar os nomes de pasta e recursos.
-
-:::caution
-Os esquemas de montagem são projetados apenas para o modelo não opinativo. O modelo opinativo tem uma estrutura predefinida.
-:::
-
-## Recomendações
-
-Tente usar o máximo de formas diferentes de criar recursos quanto possível. Isso ajudará você a entender como o CLI funciona e como usá-lo a seu favor. Também nos ajuda a melhorar o CLI para torná-lo mais robusto.
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/first-steps.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/first-steps.md
deleted file mode 100644
index 3353d82b..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/first-steps.md
+++ /dev/null
@@ -1,131 +0,0 @@
----
-sidebar_position: 1
----
-
-# Primeiros Passos
-
-Comece sua jornada com o ExpressoTS, um framework TypeScript para construir aplicações Node.js escaláveis e mantíveis. Esta seção orienta você através dos conceitos fundamentais, configuração e arquitetura do ExpressoTS.
-
-## Por que TypeScript?
-
-**[TypeScript](https://www.typescriptlang.org/)** é um elemento chave no desenvolvimento de aplicações robustas do lado do servidor devido à sua tipagem forte, que melhora significativamente a qualidade do código, escalabilidade, produtividade e colaboração. A tipagem forte não apenas ajuda a capturar erros precocemente, mas também aprimora a documentação e manutenção do código, fazendo do TypeScript uma escolha excelente para aplicações de grande escala.
-
-## Pre-requisito
-
-Por favor, verifique se o [Node.js](https://nodejs.org) `version >=18.10.0` está instalado no seu sistema operacional.
-
-## Setup
-
-Instale o **[CLI do ExpressoTS](../cli/overview.md)** globalmente usando o NPM para começar a configuração do seu projeto:
-
-Configurar um novo projeto ExpressoTS é bastante simples com o CLI do ExpressoTS. Primeiro, instale o CLI globalmente com o `NPM`:
-
-```bash
-npm i -g @expressots/cli
-```
-Crie um novo projeto executando:
-
-```bash
-expressots new <nome-do-projeto>
-```
-
-Para uma estrutura de projeto específica e gerenciador de pacotes, especifique diretamente o template e o gerenciador de pacotes:
-
-```bash
-expressots new <nome-do-projeto> -p <gerenciador-de-pacotes> -t <nome-do-template>
-```
-
-## Templates de projeto
-
-O ExpressoTS oferece dois modelos de projeto para atender a diferentes necessidades de desenvolvimento:
-
--   Não opinativo (Non-opinionated): Oferece flexibilidade na estruturação do projeto com uma configuração mínima.
--   Opinativo (Opinionated): Vem pré-configurado para projetos complexos, reforçando uma estrutura de projeto específica e um padrão de scaffolding.
-
-### Estrutura de projeto não opinativa
-
-```tree
-project-name/
-├── src/
-│   ├── app.container.ts
-│   ├── app.controller.ts
-│   ├── app.module.ts
-│   ├── app.provider.ts
-│   ├── main.ts
-├── test/
-│   ├── app.controller.spec.ts
-```
-
-| Nome do Arquivo          | Descrição                                                               |
-| ------------------------ | ----------------------------------------------------------------------- |
-| `app.container.ts`       | Contêiner de injeção de dependências. Organiza os módulos da aplicação. |
-| `app.controller.ts`      | Um controlador básico com uma única rota.                               |
-| `app.module.ts`          | Módulo raiz da aplicação.                                               |
-| `app.provider.ts`        | Gerenciador do ciclo de vida da aplicação.                              |
-| `main.ts`                | O ponto de entrada principal de uma aplicação ExpressoTS.               |
-| `app.controller.spec.ts` | Teste unitário para o app.controller.                                   |
-
-### Estrutura de projeto opinativo
-
-
-```tree
-project-name/
-├── src/
-│   ├── providers/
-│   │   └── app/
-│   │       └── app.provider.ts
-│   ├── useCases/
-│   │   └── app/
-│   │       └── app.controller.ts
-│   │       └── app.module.ts
-│   │       └── app.usecase.ts
-│   ├── app.container.ts
-│   ├── env.ts
-│   ├── main.ts
-├── test/
-│   ├── app.usecase.spec.ts
-```
-
-| Nome do Arquivo       | Descrição                                                                                                              |
-| --------------------- | ---------------------------------------------------------------------------------------------------------------------- |
-| `providers/`          | Esta pasta contém a camada responsável por fornecer recursos externos à aplicação, também conhecidos como adaptadores. |
-| `app/app.provider.ts` | Gerenciador do ciclo de vida da aplicação.                                                                             |
-| `useCases/`           | A pasta de casos de uso contém a implementação dos casos de uso de operações que podem ser realizadas na aplicação.    |
-| `app.container.ts`    | Contêiner de injeção de dependências. Organiza os módulos da aplicação.                                                |
-| `env.ts`              | Este é um recurso de utilidade que mapeia variáveis .env.                                                              |
-| `main.ts`             | O ponto de entrada principal de uma aplicação ExpressoTS.                                                              |
-| `app.usecase.spec.ts` | Um teste unitário básico para o app.usecase.                                                                           |
-
-Essa estrutura fornece um framework robusto para o desenvolvimento de endpoints de API, mostrando as capacidades de organização e camadas do ExpressoTS.
-
-## Inicialização e configuração da aplicação
-
-Inicialize sua aplicação com o método `AppFactory.create()`, passando o contêiner e uma classe App para gerenciamento do ciclo de vida. Esta etapa é crucial para configurar a injeção de dependência e a configuração de middleware da sua aplicação.
-
-Executando sua aplicação
-Com sua aplicação configurada, inicie seu servidor de desenvolvimento ou construa sua aplicação com os seguintes comandos:
-
--   Modo de Desenvolvimento: `npm run dev`
--   Construção para Produção: `npm run build`
--   Modo de Produção: `npm run prod`
-
-:::info
-Uma vez que a aplicação esteja em funcionamento, você pode acessá-la navegando para `http://localhost:3000/`.
-:::
-
-## Flexibilidade do framework
-
-ExpressoTS é um framework versátil que não está vinculado a nenhuma plataforma ou tecnologia específica. Utilizando bibliotecas populares do Node.js, como InversifyJS e Express.js, ele foi projetado para ser leve, modular, personalizável e fácil de usar. Os desenvolvedores podem expandir as capacidades do framework criando novos provedores que podem ser incorporados às suas aplicações.
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/app-life-cycle-white.png b/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/app-life-cycle-white.png
deleted file mode 100644
index 78d1c38d..00000000
Binary files a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/app-life-cycle-white.png and /dev/null differ
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/app-life-cycle.png b/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/app-life-cycle.png
deleted file mode 100644
index e12d9c46..00000000
Binary files a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/app-life-cycle.png and /dev/null differ
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/app-overview.png b/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/app-overview.png
deleted file mode 100644
index 48cdec2d..00000000
Binary files a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/app-overview.png and /dev/null differ
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/container-bindings.png b/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/container-bindings.png
deleted file mode 100644
index cf35a7ca..00000000
Binary files a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/container-bindings.png and /dev/null differ
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/controller-mvc.png b/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/controller-mvc.png
deleted file mode 100644
index 6d5921c5..00000000
Binary files a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/controller-mvc.png and /dev/null differ
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/controller-single-resp.png b/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/controller-single-resp.png
deleted file mode 100644
index efbd0c31..00000000
Binary files a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/controller-single-resp.png and /dev/null differ
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/di.png b/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/di.png
deleted file mode 100644
index 89394932..00000000
Binary files a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/di.png and /dev/null differ
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/inMemoryDB.png b/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/inMemoryDB.png
deleted file mode 100644
index d5800028..00000000
Binary files a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/inMemoryDB.png and /dev/null differ
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/middleware-view.png b/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/middleware-view.png
deleted file mode 100644
index 8413b839..00000000
Binary files a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/middleware-view.png and /dev/null differ
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/plugin-pattern.png b/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/plugin-pattern.png
deleted file mode 100644
index 1d4819e5..00000000
Binary files a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/plugin-pattern.png and /dev/null differ
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/project-demo-msg.png b/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/project-demo-msg.png
deleted file mode 100644
index be5f59e3..00000000
Binary files a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/project-demo-msg.png and /dev/null differ
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/scaffold-resources.png b/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/scaffold-resources.png
deleted file mode 100644
index f7af925e..00000000
Binary files a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/scaffold-resources.png and /dev/null differ
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/use-case-project-x.png b/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/use-case-project-x.png
deleted file mode 100644
index 151b50f5..00000000
Binary files a/i18n/pt/docusaurus-plugin-content-docs/current/overview/img/use-case-project-x.png and /dev/null differ
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/intro.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/intro.md
deleted file mode 100644
index 8ec2d62a..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/intro.md
+++ /dev/null
@@ -1,81 +0,0 @@
----
-sidebar_position: 0
----
-
-# Introdução
-
-O ExpressoTS oferece uma camada aprimorada sobre o **[Express.js](https://expressjs.com/)**, enriquecendo o desenvolvimento de aplicações TypeScript do lado do servidor. Ele combina a robustez do Express.js com as funcionalidades avançadas do TypeScript, facilitando a criação de aplicações escaláveis, mantíveis e legíveis.
-
-## Filosofia
-
-Projetado para eficiência, o ExpressoTS simplifica o desenvolvimento do lado do servidor. Ele reduz o código repetitivo (boilerplate), priorizando a clareza e a estrutura do código. A flexibilidade do framework, através de um abrangente **[Sistema de Injeção de Dependência](./di.md)**, facilita a integração de funcionalidades personalizadas com escopos predefinidos (Transient, Scoped, Singleton), promovendo um design modular e desacoplado. Seja para uma API simples ou um sistema empresarial complexo, o ExpressoTS acelera o desenvolvimento, garantindo a entrega de aplicações de alta qualidade dentro do prazo e do orçamento.
-
-## Configuração
-
-### Instalação
-
-Instale o CLI do ExpressoTS globalmente:
-
-```bash
-npm i -g @expressots/cli
-```
-
-### Inicialização do projeto
-
-Crie um novo projeto usando o CLI:
-
-```bash
-expressots new <nome-do-projeto>
-```
-
-Para uma configuração rápida, especifique o gerenciador de pacotes e o template do projeto diretamente:
-
-```bash
-expressots new <nome-do-projeto> -t <template> -p <gerenciador-de-pacotes>
-```
-
-## Templates de projeto
-
-O ExpressoTS oferece dois templates de projeto iniciais: `opinionated` e `non-opinionated`.
-
--   `non-opinionated`: Oferece flexibilidade estrutural.
--   `opinionated`: Fornece uma estrutura de projeto abrangente com esquemas de scaffolding predefinidos.
-
-## Fluxo de Trabalho de Desenvolvimento
-
-### Acessando seu projeto
-
-```bash
-cd <seu-projeto> 
-```
-
-### Executando em modo de desenvolvimento
-
-```bash
-npm run dev
-```
-
-### Gerando compilação de produção
-
-```bash
-npm run build
-```
-
-### Executando em modo de produção
-
-```bash
-npm run prod
-```
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
-- Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
-- Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
-- Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Compartilhe o projeto com seus amigos e colegas
\ No newline at end of file
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/middleware.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/middleware.md
deleted file mode 100644
index b9cc8566..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/middleware.md
+++ /dev/null
@@ -1,206 +0,0 @@
----
-sidebar_position: 5
----
-
-# Middleware
-
-Funções de middleware são fundamentais no ciclo de request-response (solicitação-resposta) de uma aplicação ExpressoTS, fornecendo a capacidade de executar código, modificar objetos de request-response, encerrar o ciclo de request-response ou chamar o próximo middleware na pilha. É essencial chamar `next()` para evitar timeouts de solicitação, a menos que seu middleware conclua o ciclo.
-
-O ExpressoTS integra-se perfeitamente com o middleware do Express, permitindo o uso de seu extenso ecossistema para aprimorar sua aplicação.
-
-:::info
-O ExpressoTS suporta totalmente o middleware do [Express](https://expressjs.com/en/resources/middleware.html).
-:::
-
-## Lista de middlewares disponíveis
-
-Middlewares do Expressjs suportados pelo ExpressoTS:
-
-| Nome do Middleware | Descrição                                                |
-| ------------------ | -------------------------------------------------------- |
-| addBodyParser      | Adiciona o middleware body parser à aplicação.           |
-| addCompression     | Adiciona o middleware de compressão à aplicação.         |
-| addCors            | Adiciona o middleware cors à aplicação.                  |
-| addHelmet          | Adiciona o middleware cors à aplicação.                  |
-| addCookieParser    | Adiciona o middleware de parser de cookies à aplicação.  |
-| addCookieSession   | Adiciona o middleware de sessão de cookies à aplicação.  |
-| addSession         | Adiciona o middleware de sessão à aplicação.             |
-| addServerStatic    | Adiciona o middleware estático à aplicação.              |
-| addRateLimit       | Adiciona o middleware de limite de taxa à aplicação.     |
-| addMorgan          | Adiciona o middleware morgan à aplicação.                |
-| addPassport        | Adiciona o middleware passport à aplicação.              |
-| setMulter          | Adiciona o middleware multer à aplicação.                |
-| addServeFavicon    | Adiciona o middleware de favicon à aplicação.            |
-| setErrorHandler    | Adiciona o middleware de tratamento de erro à aplicação. |
-
-## Adicionando middleware
-
-A aplicação ExpressoTS suporta a adição de middleware globalmente à aplicação, bem como por rota. Oferece todos os [middlewares suportados pela equipe do Express](https://expressjs.com/en/resources/middleware.html) prontamente através do uso da propriedade `this.middleware`.
-
-```typescript
-@provide(App)
-export class App extends AppExpress {
-    private middleware: IMiddleware;
-
-    constructor() {
-        super();
-        this.middleware = container.get<IMiddleware>(Middleware);
-    }
-
-    protected configureServices(): void {
-        this.middleware.addBodyParser();
-        this.middleware.addCors();
-        this.middleware.addHelmet();
-    }
-}
-```
-
-:::caution
-Se você adicionar um middleware que não está instalado como dependência, a aplicação exibirá uma mensagem de aviso e continuará a funcionar.
-:::
-
-## Adicionando middleware global
-Middlewares podem ser adicionados globalmente usando a classe `App` através da propriedade `this.middleware`, usando a lista de middlewares fornecida pela equipe do Express:
-
-```typescript
-protected configureServices(): void {
-        this.middleware.addBodyParser();
-        this.middleware.addCors();
-        this.middleware.addHelmet();
-    }
-```
-## Usando o método `addMiddleware`
-
-Para qualquer outro middleware ou um middleware personalizado, você pode adicioná-lo usando o método `this.middleware.addMiddleware()`. Com o método `addMiddleware`, você pode adicionar qualquer middleware do Registro NPM, middleware personalizado do Expressjs ou um middleware personalizado.
-
-Middleware do Registro NPM:
-```typescript
-this.middleware.addMiddleware(cors());
-```
-
-### Criando middleware expressjs
-
-```typescript
-function myMiddleware(req: Request, res: Response, next: NextFunction) {
-    // Do something
-    next();
-}
-```
-
-```typescript
-this.middleware.addMiddleware(myMiddleware);
-```
-
-### Criando middleware expressots
-
-Middleware personalizado do ExpressoTS:
-
-```typescript
-class CustomMiddleware extends ExpressoMiddleware {
-    use(req: Request, res: Response, next: NextFunction): void | Promise<void> {
-        // Do something
-        next();
-    }
-}
-```
-
-```typescript
-this.middleware.addMiddleware(new CustomMiddleware());
-```
-## Middleware de Rota
-
-Middlewares podem ser adicionados por rota na classe `App` através do método `this.middleware.addMiddleware()`. Você pode adicionar qualquer middleware do Registro NPM, middleware personalizado do Expressjs ou um middleware personalizado.
-
-```typescript
-this.middleware.addMiddleware({ path: "/api", middlewares: [] });
-```
-
-:::info
-Cada rota pode ter múltiplos middlewares.
-:::
-
-### Adicionando middleware a uma rota específica
-
-Ou você adiciona um middleware a uma rota específica na classe `Controller` através dos decoradores `@controller()` e/ou dos métodos `HTTP`.
-
-```typescript
-@controller("/")
-export class AppController {
-    @Post("", express.json())
-    execute() {
-        return "Hello World";
-    }
-}
-```
-
-### Adicionando middleware a todas as rotas em um controlador
-Se você quiser aplicar um middleware a todas as rotas sob um controlador específico, você pode adicioná-lo ao decorador `@controller()`.
-
-```typescript
-@controller("/app", express.json())
-export class AppController {
-    @Post("/create")
-    createApp() {
-        return "Create App";
-    }
-
-    @Patch("/update")
-    updateApp() {
-        return "Update App";
-    }
-}
-```
-
-## Exemplo de middleware personalizado expressoTS
-
-Para criar um middleware personalizado, você precisa estender a classe `ExpressoMiddleware` e implementar o método `use`.
-
-```typescript
-class CustomMiddleware extends ExpressoMiddleware {
-    private isOn: boolean;
-
-    constructor(isOn: boolean) {
-        super();
-        this.isOn = isOn;
-    }
-
-    use(req: Request, res: Response, next: NextFunction): void | Promise<void> {
-        // Do something
-        if (this.isOn) {
-            next();
-        } else {
-            res.status(403).send("Forbidden");
-        }
-    }
-}
-```
-
-Middleware personalizado permite que você passe parâmetros para o construtor e os use como opções no método `use` do seu middleware.
-
-## Visualizar toda a pipeline de middlewares
-
-Você pode visualizar todos os middlewares adicionados à aplicação usando o método `this.middleware.viewMiddlewarePipeline()`.
-
-![Visualizar Pipeline de Middleware](./img/middleware-view.png)
-
-:::tip Use o CLI do ExpressoTS para gerar um middleware personalizado.
-:::
-
-Comando CLI para gerar um middleware personalizado:
-
-```bash
-expressots g mi <<nome-do-middleware>>
-```
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/module.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/module.md
deleted file mode 100644
index 65a2eb7c..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/module.md
+++ /dev/null
@@ -1,50 +0,0 @@
----
-sidebar_position: 4
----
-
-# Módulos
-
-Módulos, ou módulos de contêiner no ExpressoTS, são agregações de serviços — principalmente Controladores e suas dependências — que são gerenciados pelo contêiner do framework. Esses módulos facilitam a organização, registro e resolução de vários componentes da aplicação dentro do ecossistema ExpressoTS.
-
-## Entendendo os módulos
-
-Um módulo exporta um objeto de Módulo Inversify, servindo como uma entidade de configuração para as vinculações de controladores e suas dependências. Ele utiliza um método bind para estabelecer relações entre serviços e suas dependências. Para entender o registro de classes como casos de uso, entidades, provedores, repositórios e mais, mergulhe na [seção de Injeção de Dependência](./di.md)**, que elabora sobre decoradores influenciando o escopo padrão do contêiner.
-
-## Simplificando vinculações com `CreateModule`
-
-O ExpressoTS simplifica o processo de vinculação por meio da função `CreateModule`. Esta utilidade registra automaticamente controladores, injetando suas dependências sem necessidade de vinculação manual:
-
-```typescript
-export const AppModule: ContainerModule = CreateModule([AppController]);
-```
-## Definindo o escopo do módulo
-
-Muito semelhante ao `Container`, os desenvolvedores podem definir o escopo de um módulo usando o mesmo enum `BindingScopeEnum`. Aqui estão os valores do enum:
-
--   `BindingScopeEnum.Singleton` - A dependência será criada uma vez e será compartilhada por todas as solicitações.
--   `BindingScopeEnum.Request` - A dependência será criada uma vez por solicitação.
--   `BindingScopeEnum.Transient` - A dependência será criada toda vez que for solicitada.
-
-Ao criar um módulo, você pode passar o escopo como um segundo argumento para a função `CreateModule`. É opcional e, se não fornecido, o escopo padrão é adquirido do `AppContainer`, que é `RequestScope`.
-
-```typescript
-export const AppModule: ContainerModule = CreateModule([AppController], BindingScopeEnum.Singleton);
-```
-Essa flexibilidade permite estratégias de gerenciamento de dependências sob medida, como combinar módulos de escopo Singleton para serviços compartilhados com módulos de escopo de Request para serviços específicos da solicitação.
-
-## Precedência de escopo
-
-A hierarquia de precedência de escopo é `AppContainer` > `Module` > `Controller`, garantindo uma abordagem versátil e hierárquica para o gerenciamento de escopo de dependência. Esta estrutura em camadas permite controle preciso sobre a instanciação e o ciclo de vida do serviço em toda a aplicação.
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
-- Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
-- Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
-- Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/providers.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/providers.md
deleted file mode 100644
index 03356653..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/providers.md
+++ /dev/null
@@ -1,269 +0,0 @@
----
-sidebar_position: 8
----
-
-# Provedores
-
-No ExpressoTS, provedores servem como melhorias modulares para uma aplicação, encapsulando funcionalidades específicas, como serviços de email, mecanismos de autenticação ou conexões de banco de dados. Essa encapsulação é essencial para preservar uma arquitetura fracamente acoplada, permitindo a troca ou atualização dessas funcionalidades sem afetar o sistema geral.
-
-## O papel dos provedores
-
-Provedores encapsulam as operações de componentes de infraestrutura, como bancos de dados, serviços web e sistemas de arquivos, apresentando uma interface unificada para a aplicação. Essa configuração não apenas simplifica a base de código, mas também melhora sua testabilidade, manutenibilidade e escalabilidade.
-
-### Vantagens chave
-
--   Promover o desacoplamento entre as camadas da aplicação.
--   Simplificar o processo de teste ao desacoplar a lógica de implementações específicas.
--   Melhorar a manutenibilidade e flexibilidade do código, suportando trocas fáceis de serviços subjacentes.
-
-:::info
-O ExpressoTS utiliza provedores para aumentar as capacidades da aplicação, facilitando funcionalidades como envio de emails, armazenamento de dados e mais, sem vincular a lógica da aplicação a implementações específicas.
-:::
-
-## Implementando um provedor: Um exemplo de serviço de email
-
-Considere uma aplicação que precisa enviar emails sob várias circunstâncias, como registro de usuário ou recuperação de senha. Implementando um provedor de email, o ExpressoTS pode enviar emails sem interagir diretamente com o serviço de envio de emails na lógica de negócios.
-
-### Configurando o provedor
-
-Primeiro, execute o comando CLI para criar um novo provedor no seu projeto ExpressoTS:
-
-```bash
-expressots g p mailtrap
-```
-O CLI adicionará o sufixo `Provider` ao nome do provedor, criando um novo arquivo no diretório `providers`. Esse arquivo conterá a classe do provedor, que você pode personalizar de acordo com as necessidades da sua aplicação.
-
-Aqui está o arquivo padrão do provedor gerado pelo CLI:
-
-```typescript
-import { provide } from "inversify-binding-decorators";
-
-@provide(MailTrapProvider)
-class MailTrapProvider {}
-```
-
-### Implementando o provedor
-
-
-```typescript
-import nodemailer from "nodemailer";
-import Mail from "nodemailer/lib/mailer";
-
-const enum EmailType {
-    Welcome = 0,
-    CreateUser,
-    ChangePassword,
-    Login,
-    RecoveryPassword,
-}
-
-@provide(MailTrapProvider)
-class MailTrapProvider {
-    private transporter: Mail;
-
-    constructor() {
-        this.transporter = nodemailer.createTransport({
-            host: Env.Mailtrap.HOST,
-            port: Env.Mailtrap.PORT,
-            auth: {
-                user: Env.Mailtrap.USERNAME,
-                pass: Env.Mailtrap.PASSWORD,
-            },
-        });
-    }
-
-    private mailSender(message: IMessage): Promise<void> {
-        await this.transporter.sendMail({
-            to: {
-                name: message.to.name,
-                address: message.to.email,
-            },
-            from: {
-                name: message.from.name,
-                address: message.from.email,
-            },
-            subject: message.subject,
-            html: message.body,
-        });
-    }
-
-    sendEmail(emailType: EmailType): Promise<void> {
-        switch (emailType) {
-            case EmailType.Login:
-                break;
-            case EmailType.Welcome:
-                break;
-            case EmailType.RecoveryPassword:
-                break;
-            case EmailType.ChangePassword:
-                break;
-            case EmailType.CreateUser:
-                this.MailSender({
-                    to: {
-                        name: "User",
-                        email: Env.Mailtrap.INBOX_ALIAS,
-                    },
-                    from: {
-                        name: "ExpressoTS",
-                        email: "noreply@expresso-ts.com",
-                    },
-                    subject: "Successfully logged in!",
-                    body: "<h1>Welcome to the system!</h1>",
-                });
-                break;
-        }
-    }
-}
-
-export { MailTrapProvider, EmailType };
-```
-
-Este `MailTrapProvider` abstrai a complexidade de configurar e usar o nodemailer para operações de email, fornecendo um método simples sendEmail para enviar diferentes tipos de emails.
-
-### Consumindo o provedor em um caso de uso
-
-Aqui está a implementação do caso de uso fazendo uso do provedor mailtrap:
-
-```typescript
-@provide(LoginUserUseCase)
-class LoginUserUseCase {
-    constructor(private mailTrapProvider?: MailTrapProvider) {}
-
-    execute(payload: ILoginUserRequestDTO): boolean {
-        const { email, password } = payload;
-
-        if (isAuthenticated(email, password)) {
-            return true;
-        }
-
-        // Implementation of the use case logic
-        mailTrapProvider?.sendEmail(EmailType.Login);
-
-        return false;
-    }
-}
-
-export { LoginUserUseCase };
-```
-
-Neste caso de uso, o `MailTrapProvider` é injetado através do construtor, aproveitando a injeção de dependência do ExpressoTS. Isso desacopla o processo de envio de email da lógica de autenticação, ilustrando o papel do provedor em manter um código limpo e manutenível.
-
-## Provedores disponíveis no ExpressoTS
-
-O ExpressoTS oferece provedores integrados para funcionalidades comuns, estendendo ainda mais as capacidades da aplicação:
-
-| Nome do Provedor | Descrição                        |
-| ---------------- | -------------------------------- |
-| envValidator     | Valida as variáveis de ambiente. |
-| logger           | Adiciona logger à aplicação.     |
-
-Provedores são essenciais para construir aplicações escaláveis, manuteníveis com o ExpressoTS, enfatizando uma arquitetura limpa e separação de preocupações.
-
-## Registro automático com decoradores fluentes
-
-O ExpressoTS facilita o registro de provedores em seu sistema de injeção de dependência por meio do uso de decoradores fluentes:
-
--   @provide
--   @provideSingleton
--   @provideTransient
-
-Esses decoradores garantem que os provedores sejam automaticamente registrados, simplificando sua integração e reduzindo o código repetitivo.
-
-## Criando e registrando um provedor externo
-
-O ExpressoTS incentiva a extensibilidade por meio do uso de provedores externos. Desenvolvedores podem criar pacotes reutilizáveis, seguindo o padrão de design de plugin, para introduzir novas funcionalidades em uma aplicação ExpressoTS. Isso é particularmente útil para recursos que precisam ser compartilhados entre vários projetos ou para integrar serviços de terceiros.
-
-### Criando um provedor externo
-
-Um provedor externo deve ser um pacote CommonJS implementando a interface IProvider:
-
-```typescript
-import { IProvider } from "expressots";
-
-@injectable()
-class Logger implements IProvider {
-    log(message: string): void {
-        console.log(message);
-    }
-}
-```
-
-Interface `IProvider`:
-
-```typescript
-export interface IProvider {
-    name: string;
-    version: string;
-    author: string;
-    repo: string;
-}
-```
-
-Uma vez que o pacote é desenvolvido e publicado no registro npm, ele pode ser facilmente integrado em qualquer aplicação ExpressoTS.
-
-### Registrando provedores em tempo de execução
-
-Provedores são registrados na classe `App` de uma aplicação ExpressoTS usando o `ProviderManager`. O decorador `@injectable` do InversifyJS torna o provedor disponível para registro e resolução dentro do sistema de injeção de dependência do aplicativo.
-
-```typescript
-@provide(App)
-export class App extends AppExpress {
-    private provider: ProviderManager;
-
-    constructor() {
-        super();
-        this.provider = container.get(ProviderManager);
-    }
-
-    protected configureServices(): void {
-        // Registrando provedores core e externos
-        this.provider.register(Logger);
-    }
-
-    protected postServerInitialization(): void {}
-
-    protected serverShutdown(): void {}
-}
-```
-
-:::info
-Por padrão, o registro do provedor vincula o provedor como escopo de solicitação. Para alterar o escopo, use o `BindingScopeEnum`.
-:::
-
-Exemplo de registro de um provedor como singleton:
-
-```typescript
-this.provider.register(Logger, BindingScopeEnum.Singleton);
-```
-
-Este processo concede flexibilidade para melhorar a aplicação em tempo de execução integrando provedores adicionais, permitindo a escala dinâmica e extensão das capacidades da aplicação.
-
-## Visualizando o padrão de design de plugin
-
-O diagrama ilustra o padrão de design de plugin do ExpressoTS, demonstrando como os provedores externos são integrados de maneira transparente à aplicação cliente através do Gerenciador de Provedores. Ele destaca o processo de registrar novos provedores e seus respectivos escopos de ciclo de vida, que podem ser singleton, request ou scoped.
-
-![Plugin Design Pattern](./img/plugin-pattern.png)
-
-## Recomendações para usar provedores externos
-
-Ao desenvolver provedores externos para o ExpressoTS, considere as seguintes melhores práticas:
-
--   **Implementação de Interface**: Garanta que os provedores externos estejam em conformidade com a interface IProvider para consistência.
--   **Gerenciamento de Ciclo de Vida**: Escolha o escopo apropriado para o provedor com base em seu padrão de uso pretendido.
--   **Testes**: Teste os provedores minuciosamente de forma isolada antes de integrá-los à aplicação principal.
--   **Documentação**: Forneça instruções de uso detalhadas e opções de configuração para o provedor externo.
-
-Ao aderir a essas práticas, os desenvolvedores podem garantir que seus provedores externos sejam robustos, mantíveis e facilmente integrados a qualquer aplicação ExpressoTS.
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/render.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/render.md
deleted file mode 100644
index 3563becf..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/render.md
+++ /dev/null
@@ -1,201 +0,0 @@
----
-sidebar_position: 17
----
-
-# Motor de Renderização
-
-**[ExpressoTS](https://expresso-ts.com/)** melhora as capacidades do servidor web do Express.js, proporcionando uma experiência simplificada para renderização de views. ExpressoTS suporta vários motores de renderização prontos para uso, incluindo EJS, PUG e Handlebars (HBS). Isso facilita para os desenvolvedores começarem a renderizar views sem necessidade de configuração adicional, pois são fornecidas configurações padrão para cada motor suportado.
-
-## Motores de Renderização Suportados
-
-ExpressoTS suporta os seguintes motores de renderização:
-
--   EJS
--   PUG
--   HBS (Handlebars)
-
-### Opções de Configuração do Handlebars
-
-```typescript
-export type HandlebarsOptions = {
-    viewEngine?: string; // O motor de visualização a ser usado
-    viewsDir?: string; // O caminho para a pasta de views
-    partialsDir?: string; // O caminho para a pasta de partials
-};
-```
-
-### Opções de configuração padrão do Handlebars
-
-```typescript
-{
-    viewEngine: "hbs",
-    viewsDir: <root>/views,
-    partialsDir: <root>/views/partials,
-}
-```
-
-### Estrutura de Pastas Padrão
-
-Estrutura de pastas padrão para Handlebars:
-
-```tree
-src
-views
-|--partials
-|   |--partial.hbs
-|--index.hbs
-```
-
-Todos os outros motores seguem a mesma estrutura, com exceção da pasta `partials`, que é específica para Handlebars.
-
-### Exemplo de Arquivo Handlebars
-
-```html
-<html lang="en">
-    <head>
-        <meta charset="UTF-8" />
-        <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-        <title>Exemplo HBS</title>
-    </head>
-    <body>
-        <h1>Olá do HBS</h1>
-        <p>Renderizar partial: {{> partial}}</p>
-    </body>
-</html>
-```
-
-## Outras Opções de Configuração de Motores
-
-### Opções de Configuração do Pug
-
-```typescript
-export type PugOptions = {
-    viewEngine?: string; // O motor de visualização a ser usado
-    viewsDir?: string; // O caminho para a pasta de views
-};
-```
-
-### Opções de configuração padrão do Pug
-
-```typescript
-{
-    viewEngine: "pug",
-    viewsDir: <root>/views,
-}
-```
-
-### Opções de Configuração do EJS
-
-```typescript
-export type EjsOptions = {
-    viewEngine?: string; // O motor de visualização a ser usado
-    viewsDir?: string; // O caminho para a pasta de views
-};
-```
-
-### Opções de configuração padrão do EJS
-
-```typescript
-{
-    viewEngine: "ejs",
-    viewsDir: <root>/views,
-    serverOptions: {
-        cache: true,
-        compileDebug: false,
-        debug: false,
-        delimiter: "%",
-        strict: false,
-    },
-}
-```
-
-## Como Usar
-
-Aqui está como você pode configurar o ExpressoTS para usar um motor de renderização como HBS (handlebars) em sua aplicação:
-
-Na configuração do `app.provider`, você pode definir o motor de renderização:
-
-```typescript
-export class App extends AppExpress {
-    private middleware: IMiddleware;
-    private provider: ProviderManager;
-
-    constructor() {
-        super();
-        this.middleware = container.get<IMiddleware>(Middleware);
-        this.provider = container.get(ProviderManager);
-    }
-
-    protected configureServices(): void {
-        // Definir o motor de renderização como HBS
-        this.setEngine(Engine.HBS);
-
-        this.middleware.setErrorHandler();
-    }
-
-    protected async postServerInitialization(): Promise<void> {
-        if (this.isDevelopment()) {
-            this.provider.get(Env).checkAll();
-        }
-    }
-
-    protected serverShutdown(): void {}
-}
-```
-
-:::note
-Se você deseja passar opções personalizadas para o motor de renderização, você pode fazer isso passando um objeto com as opções desejadas para o método `setEngine`. Por exemplo, para definir o diretório de views para um caminho personalizado, você pode fazer o seguinte:
-
-```typescript
-this.setEngine<HBS>(Engine.HBS, { viewsDir: <<custom-path>> });
-```
-
-:::
-
-### Como Renderizar Views no ExpressoTS
-
-Para renderizar uma view no ExpressoTS, você pode usar o método `render` fornecido pelo objeto `Response`. Aqui está um exemplo de como você pode renderizar uma view no ExpressoTS:
-
-```typescript
-@Get("/")
-root(@response() res: Response) {
-    res.render("index", { date: new Date(), name: "Informação Aleatória" });
-}
-```
-
-No exemplo acima, o método render é chamado no objeto Response, passando o nome da view a ser renderizada e um objeto com os dados a serem passados para a view. O motor de visualização renderizará a view com os dados fornecidos e retornará o HTML renderizado para o cliente.
-
-### Decorador Render
-
-O decorador `@Render` pode ser usado em métodos de controladores para renderizar views usando o motor de visualização especificado. Aqui está um exemplo de como você pode usar o decorador `@Render` para renderizar uma view no ExpressoTS:
-
-#### Renderização passando a view e dados padrão no decorador
-
-```typescript
-@Get("/")
-@Render("index", { date: new Date(), name: "Informação Aleatória" })
-root() {}
-```
-
-#### Renderização passando apenas a view no decorador
-
-```typescript
-@Get("/")
-@Render("index")
-root() {
-    return { date: new Date(), name: "Informação Aleatória" };
-}
-```
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/repositories.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/repositories.md
deleted file mode 100644
index 66d2ee5c..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/repositories.md
+++ /dev/null
@@ -1,75 +0,0 @@
----
-sidebar_position: 9
----
-
-# Repositórios
-
-
-O padrão de repositório no ExpressoTS fornece uma camada de abstração para o acesso a dados, encapsulando operações CRUD (Criar, Ler, Atualizar, Deletar) dentro de classes de repositório. Esses repositórios atuam como intermediários entre a lógica de negócios e as camadas de mapeamento de dados, utilizando ORMs como **[TypeORM](https://typeorm.io/), [Prisma](https://www.prisma.io/) ou [Sequelize](https://sequelize.org/),** para interagir com o banco de dados.
-
-## Entendendo o padrão de repositório
-
-Um padrão de repositório é uma estratégia de design que abstrai a persistência de dados, permitindo que a lógica de negócios seja agnóstica em relação à tecnologia ou ao esquema do banco de dados subjacente. O ExpressoTS utiliza esse padrão para facilitar a manutenibilidade e escalabilidade.
-
-## Objetivos e benefícios
-
-O principal objetivo do padrão de repositório é separar a lógica de negócios da lógica de acesso a dados. Isso permite que os desenvolvedores escrevam código mais focado nos requisitos de negócios da aplicação, em vez dos detalhes técnicos de como os dados são armazenados e acessados.
-
--   **Separação de Preocupações**: Desacopla a lógica de negócios da lógica de acesso a dados, permitindo que os desenvolvedores se concentrem nas regras de negócio sem se preocupar com operações de banco de dados.
--   **Manutenibilidade**: Centraliza a lógica de acesso a dados dentro dos repositórios, simplificando a manutenção e atualizações das implementações de armazenamento de dados.
--   **Abstração**: Esconde as complexidades da camada de dados do resto da aplicação, fornecendo uma interface simplificada e consistente para operações de dados.
--   **Testabilidade**: Facilita os testes ao permitir o uso de repositórios falsos ou bancos de dados em memória para simular a persistência de dados.
-
-## Exemplo de implementação do padrão de repositório
-
-No seguinte exemplo, criaremos uma implementação simples do padrão de repositório usando TypeScript. Definiremos uma interface de repositório base e uma classe, bem como uma classe de repositório concreta para uma entidade User.
-
-### Interface do base repositório
-
-```typescript
-interface IBaseRepository<T> {
-    create(item: T): T | null;
-    update(item: T): T | null;
-    delete(id: string): boolean;
-    find(id: string): T | null;
-    findAll(): T[];
-}
-```
-
-### Classe base repositório
-
-```typescript
-@provide(BaseRepository)
-class BaseRepository<T> implements IBaseRepository<T> {
-    // Implemente os métodos de interface aqui
-}
-```
-
-### Classe de repositório específica
-
-```typescript
-@provide(UserRepository)
-class UserRepository extends BaseRepository<User> {}
-```
-O exemplo acima demonstra a simplicidade de criar um repositório base que pode ser estendido para entidades específicas como `User`.
-
-## Repositórios vs provedores
-
-Enquanto os repositórios focam na interação com dados, os provedores no ExpressoTS tipicamente oferecem funcionalidades como validação de ambiente ou logging. Manter repositórios e provedores distintos garante uma separação clara e adere ao princípio da responsabilidade única.
-
-:::info
-No ExpressoTS, os repositórios são armazenados dentro de uma pasta dedicada "repositories", distinguindo-os da pasta "providers". Essa escolha estrutural enfatiza seus papéis distintos e facilita uma base de código modular.
-:::
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/status-code.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/status-code.md
deleted file mode 100644
index 2984f4ca..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/status-code.md
+++ /dev/null
@@ -1,106 +0,0 @@
----
-sidebar_position: 14
----
-
-# Código de Status
-
-O código de status é uma forma de representar o resultado de uma requisição. Essas respostas HTTP indicam se uma solicitação HTTP específica foi concluída com êxito. As respostas são agrupadas em cinco classes:
-
--   Respostas informativas (100-199)
--   Respostas bem-sucedidas (200-299)
--   Mensagens de redirecionamento (300-399)
--   Respostas de erro do cliente (400-499)
--   Respostas de erro do servidor (500-599)
-
-Você encontra aqui mais detalhes sobre os códigos de status **[MDN Web Docs](https://developer.mozilla.org/en-US/docs/Web/HTTP/Status)**.
-
-:::tip
-Os códigos de status aqui mostrados estão definidos na [RFC 9110](https://httpwg.org/specs/rfc9110.html#overview.of.status.codes)
-:::
-
-## ExpressoTS código de status
-
-Em ExpressoTS, temos uma lista de todos os códigos de status listados na MDN que você pode usar em sua aplicação. Aqui está um exemplo de uso:
-
-### Em uma controladora
-
-```typescript
-import { StatusCode } from "@expressots/core";
-
-@controller("/user/create")
-class CreateUserController extends BaseController {
-    constructor(private createUserUseCase: CreateUserUseCase) {
-        super("create-user-controller");
-    }
-
-    @httpPost("/")
-    execute(
-        @requestBody() data: ICreateUserRequestDTO,
-        @response() res: any
-    ): ICreateUserResponseDTO {
-        return this.callUseCase(
-            this.createUserUseCase.execute(data),
-            res,
-            StatusCode.Created // Status code
-        );
-    }
-}
-```
-
-### Em um caso de uso
-
-```typescript
-import { StatusCode } from "@expressots/core";
-
-@provide(CreateUserUseCase)
-class CreateUserUseCase {
-    constructor(private userRepository: UserRepository) {}
-
-    execute(data: ICreateUserRequestDTO): ICreateUserResponseDTO | null {
-        try {
-            const { name, email } = data;
-
-            const user: User | null = this.userRepository.create(new User(name, email));
-
-            if (!user) {
-                Report.Error(
-                    new AppError(
-                        StatusCode.BadRequest, // Status code
-                        "User already exists",
-                        "create-user-usecase"
-                    )
-                );
-            }
-
-            let response: ICreateUserResponseDTO;
-
-            if (user !== null) {
-                response = {
-                    id: user.Id,
-                    name: user.name,
-                    email: user.email,
-                    status: "success",
-                };
-                return response;
-            }
-
-            return null;
-        } catch (error: any) {
-            throw error;
-        }
-    }
-}
-```
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/test.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/test.md
deleted file mode 100644
index e3cc9cd3..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/test.md
+++ /dev/null
@@ -1,61 +0,0 @@
----
-sidebar_position: 16
----
-
-# Teste
-
-Os testes de unidade e os testes de integração são importantes em qualquer processo de desenvolvimento de aplicativos porque servem a propósitos diferentes.
-
--   **Testes de unidade**: focam na realização de testes em unidades individuais de código, como uma única função ou método, isoladamente do restante do aplicativo. Eles normalmente envolvem simulação de dependências e serviços externos para garantir que a unidade sendo testada se comporte como esperado em um ambiente controlado. Os testes de unidade são importantes porque permitem que os desenvolvedores identifiquem bugs e erros precocemente no processo de desenvolvimento, quando são mais fáceis e baratos de corrigir. Eles também ajudam a garantir que unidades individuais de código estejam funcionando corretamente, o que pode facilitar a depuração e solução de problemas mais tarde.
-
--   **Testes de integração**: por outro lado, testam as interações entre diferentes componentes ou módulos do aplicativo, incluindo como eles interagem com dependências e serviços externos. Ao contrário dos testes de unidade, os testes de integração envolvem testar o aplicativo como um todo, em vez de unidades individuais de forma isolada. Os testes de integração são importantes porque ajudam a garantir que o aplicativo esteja funcionando corretamente como um todo e que os diferentes componentes estejam trabalhando juntos conforme o esperado.
-
-:::tip
-Combinar testes unitários e testes de integração pode ser benéfico porque permite que os desenvolvedores testem tanto unidades individuais de código quanto o aplicativo como um todo. Isso ajuda a garantir que cada parte do código esteja funcionando corretamente por si só e em conjunto com outras partes do aplicativo. Além disso, a combinação de testes pode fornecer uma cobertura de teste mais completa e identificar problemas em diferentes níveis de abstração, desde funções individuais até a interação completa do sistema com componentes externos.
-:::
-
-## Exemplo usando Jest como exector de teste
-
-Abaixo estamos testando o retorno do endpoint PingUseCase. Estamos utilizando o **[Jest](https://jestjs.io/)** como test runner e **[ts-jest](https://www.npmjs.com/package/ts-jest)** como pre-processador TypeScript.
-
-```typescript
-describe("PingUseCase", () => {
-    let pingUseCase: PingUseCase;
-
-    beforeEach(() => {
-        pingUseCase = new PingUseCase();
-    });
-
-    it("should return a valid PingResponseDTO", () => {
-        const start: Date = new Date();
-        const response = pingUseCase.execute(start);
-        const end: Date = new Date(response.end);
-        const ttl = parseFloat(response.ttl.split(" ")[0]);
-
-        expect(response).toHaveProperty("start");
-        expect(response).toHaveProperty("end");
-        expect(response).toHaveProperty("ttl");
-        expect(response).toHaveProperty("message");
-        expect(response.message).toBe("Pong!");
-        expect(start <= end).toBe(true);
-        expect(ttl >= 0).toBe(true);
-    });
-});
-```
-
-:::caution SPOILER ALERT
-Temos em nosso Roadmap a implementação de uma biblioteca de testes que envolve um framework de testes moderno para fornecer uma API simples e intuitiva para escrever testes unitários e de integração.
-:::
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/overview/usecase.md b/i18n/pt/docusaurus-plugin-content-docs/current/overview/usecase.md
deleted file mode 100644
index 1c17fde6..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/overview/usecase.md
+++ /dev/null
@@ -1,90 +0,0 @@
----
-sidebar_position: 7
----
-
-# Casos de Uso
-
-Do ponto de vista da UML, os casos de uso fornecem uma maneira de modelar as interações entre usuários, outros sistemas e um aplicativo de software. Um caso de uso descreve um cenário específico ou fluxo de eventos entre os atores e o sistema, levando a um determinado resultado.
-
-No contexto do ExpressoTS, os casos de uso servem para representar a lógica de negócios da aplicação, permitindo uma clara separação entre o controlador e a execução da solicitação.
-
-## Nós recomendamos
-
-Apesar de você poder usar qualquer padrão de design que desejar como **[MVC](./controller.md#padrão-mvc)**, no template opinativo do ExpressoTS reforçamos o uso da **[Arquitetura Limpa](https://blog.cleancoder.com/uncle-bob/2012/08/13/the-clean-architecture.html)** e **[princípios SOLID](https://medium.com/backticks-tildes/the-s-o-l-i-d-princípios-em-imagens-b34ce2f1e898)**. Acreditamos que essa abordagem ajudará você a criar um aplicativo mais sustentável e escalável.
-
-É uma prática recomendada ter um caso de uso por controlador, sendo o controlador responsável por chamar o caso de uso correspondente que irá implementar a lógica de negócios da solicitação. A carga útil da solicitação, também conhecida como DTO de solicitação no ExpressoTS, contém as informações necessárias para executar o caso de uso.
-
-Um caso de uso no ExpressoTS contém apenas a lógica de negócios da aplicação, mantendo-a separada da lógica do controlador. É comum ter DTOs de resposta como parte do caso de uso, definindo o formato de resposta da solicitação. O caso de uso normalmente contém uma única função chamada "execute", responsável por executar a lógica desse caso de uso específico.
-
-:::tip
-Vale ressaltar que ter vários casos de uso implementados em uma única classe viola o princípio da responsabilidade única e deve ser evitado.
-:::
-
-## Exemplo
-
-Aqui está um exemplo de diagrama de casos de uso para um projeto x:
-
-![Projeto X Diagrama de Caso de Uso](./img/use-case-project-x.png)
-
-Na diagrama de caso de uso acima, o ator representa o usuário interagindo com o sistema. Para executar o caso de uso de login, o usuário deve fornecer informações específicas conhecidas como payload ou, no caso do ExpressoTS, o DTO de solicitação. Essas informações são necessárias para acionar o caso de uso e para o sistema fornecer o resultado desejado.
-
-É importante observar que o caso de uso deve conter exclusivamente a lógica de negócios da aplicação, sem funcionalidades adicionais ou não relacionadas. Essa abordagem ajuda a garantir uma clara separação de preocupações, promovendo a manutenibilidade e escalabilidade do sistema.
-
-Aqui está nossa implementação simples do caso de uso no ExpressoTS:
-
-```typescript
-@provide(LoginUserUseCase)
-class LoginUserUseCase {
-    execute(payload: ILoginUserRequestDTO): boolean {
-        const { email, password } = payload;
-
-        if (isAuthenticated(email, password)) {
-            return true;
-        }
-
-        return false;
-    }
-}
-
-export { LoginUserUseCase };
-```
-
-## Explicação
-
-A implementação de casos de uso no ExpressoTS segue as melhores práticas de design de software, em que cada caso de uso é responsável por implementar uma lógica de negócios específica. Como mostrado no exemplo de código, um caso de uso geralmente contém apenas uma função, chamada execute, que é responsável por executar a lógica de negócios definida naquele caso de uso. O caso de uso também pode incluir um DTO de resposta que define o formato da resposta para aquele caso de uso específico.
-
-Além disso, é comum usar construtores nos casos de uso para injetar dependências, como provedores e repositórios. Isso permite uma melhor modularidade e testabilidade do código.
-
-### Injeção de construtor
-
-Com o sistema ExpressoTS **[Dependency Injection](di.md)** podemos usar o construtor nos casos de uso para injetar dependências, como provedores, repositórios, entidades ou qualquer outra classe auxiliar necessária para entregar a resposta do caso de uso. Isso permite uma melhor modularidade e testabilidade do código.
-
-Aqui está um exemplo de um caso de uso com injeção de construtor:
-
-```typescript
-class ExampleUseCase {
-    constructor(private yourInjection1: Injection1, private yourInjection2: Injection2) {}
-
-    execute() {
-        this.yourInjection1.foo();
-        this.yourInjection2.bar();
-    }
-}
-```
-
-:::info
-É importante aderir ao princípio da responsabilidade única ao implementar casos de uso. Cada caso de uso deve lidar apenas com uma lógica de negócios específica, e se você se encontrar implementando vários casos de uso em uma única classe, é hora de revisar sua implementação para garantir que cada caso de uso tenha uma responsabilidade clara e concisa.
-:::
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/providers/_category_.json b/i18n/pt/docusaurus-plugin-content-docs/current/providers/_category_.json
deleted file mode 100644
index 26604b54..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/providers/_category_.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "label": "Provedores",
-  "position": 3,
-  "link": {
-    "type": "generated-index",
-    "description": "ExpressoTS Framework Provedores."
-  }
-}
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/providers/dto-validator.md b/i18n/pt/docusaurus-plugin-content-docs/current/providers/dto-validator.md
deleted file mode 100644
index 92fa3254..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/providers/dto-validator.md
+++ /dev/null
@@ -1,107 +0,0 @@
----
-sidebar_position: 1
----
-
-# Validador de DTO
-
-O provedor Validador de DTO é um recurso que o ExpressoTS oferece nativamente. É usado para validar os dados vindos do cliente. Ajuda o desenvolvedor a evitar erros em tempo de execução causados por dados faltantes ou inválidos.
-
-Quando você cria um novo projeto, o provedor Validador de DTO já vem incluído como um middleware que pode ser usado em qualquer endpoint. O middleware é chamado `validateDTO`.
-
-## Pré-requisitos
-
-O validador de DTO é baseado nos pacotes [class-validator](https://www.npmjs.com/package/class-validator) e [class-transformer](https://www.npmjs.com/package/class-transformer). Utiliza decoradores para validar os DTOs.
-
-:::tip
-Se você não tiver class-validator e class-transformer instalados e tentar usar o validador de DTO, você receberá uma mensagem de aviso no console indicando que você precisa instalar os pacotes.
-:::
-
-Outra coisa importante a mencionar é que o validador de DTO funciona apenas com classes, já que interfaces não existem em tempo de execução. Portanto, se você deseja usar o validador de DTO, você precisa criar uma classe que represente seu DTO em vez da interface atual fornecida pelo ExpressoTS.
-
-## Como Usar
-
-Você pode usar o validador de DTO em qualquer endpoint, adicionando o middleware validateDTO na rota do endpoint.
-
-Endpoint que cria um novo usuário:
-
-```typescript
-@httpPost("/", ValidateDTO(CreateUserDTO))
-execute(@requestBody() payload: CreateUserDTO, @response() res: Response) {
-  return res.status(StatusCode.Created).json(this.createUserUseCase.execute(payload));
-}
-```
-
-Aqui está a classe `CreateUserDTO`:
-
-```typescript
-import { IsEmail, IsNotEmpty, MinLength } from "class-validator";
-
-class CreateUserDTO {
-  @IsNotEmpty()
-  @MinLength(10)
-  name: string;
-  @IsNotEmpty()
-  @IsEmail({}, { message: "Invalid email" })
-  email: string;
-}
-
-export { CreateUserDTO };
-```
-
-:::info
-Para mais informações sobre os decoradores, consulte o pacote [class-validator](https://www.npmjs.com/package/class-validator).
-:::
-
-## Mensagens de Erro do Validador de DTO
-
-Se você enviar um payload que não corresponde ao DTO CreateUserDTO acima, o validador de DTO retornará uma mensagem de erro com o seguinte formato:
-
-**Payload:**
-
-```json
-{
-  "name": "",
-  "email": ""
-}
-```
-
-**Resposta:**
-
-```json
-{
-  "errorCode": 400,
-  "errorMessage": "Bad Request",
-  "DTO": [
-    {
-      "property": "name",
-      "messages": [
-        "name must be longer than or equal to 10 characters",
-        "name should not be empty"
-      ]
-    },
-    {
-      "property": "email",
-      "messages": ["invalid email", "email should not be empty"]
-    }
-  ]
-}
-```
-
-As mensagens são divididas por propriedade, facilitando a identificação de qual propriedade tem um erro e qual é a mensagem de erro. Isso é útil quando você tem um DTO com muitas propriedades, pois permite identificar facilmente qual propriedade tem um erro. Também ajuda a aplicação frontend a receber as mensagens de erro de forma mais fácil.
-
-:::caution ALERTA DE SPOILER
-O ValidateDTO faz parte das funcionalidades que o ExpressoTS oferece nativamente para ajudá-lo a construir sua aplicação mais rapidamente. Nas próximas versões do ExpressoTS para cada funcionalidade que o ExpressoTS oferece nativamente, forneceremos uma maneira de você personalizá-la ou usar sua própria implementação baseada em seu pacote ou biblioteca favorita.
-:::
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
-- Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
-- Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
-- Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/providers/envvalidator.md b/i18n/pt/docusaurus-plugin-content-docs/current/providers/envvalidator.md
deleted file mode 100644
index 1fbb2373..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/providers/envvalidator.md
+++ /dev/null
@@ -1,49 +0,0 @@
----
-sidebar_position: 2
----
-
-# Validator de ambiente
-
-O provedor de validação de ambiente é um provedor que o ExpressoTS oferece por padrão. Ele é usado para validar a existência do arquivo `.env` e seu conteúdo.
-Ele ajuda o desenvolvedor a evitar erros em tempo de execução causados por variáveis de ambiente ausentes.
-
-:::tip
-Ele está incluso apenas no modelo opinativo ou quando você cria uma classe que estende a classe `Application`.
-:::
-
-Você pode encontrá-lo na pasta `src/providers/application` no modelo opinativo.
-
-O `application.provider` é o provedor principal do aplicativo responsável por controlar o **[Application Lifecycle](../overview/application.md#hooks-de-ciclo-de-vida-da-aplicação)**.
-
-Dentro da classe Application você pode encontrar três métodos que são chamados na seguinte ordem:
-
--   `configureServices()` : Configura serviços que devem ser inicializados antes do início do servidor.
--   `postServerInitialization()` : Configura serviços que devem ser executados após o início do servidor.
--   `serverShutdown()` : Realiza ações ou limpezas após o desligamento do servidor.
-
-O provedor de validação de ambiente é chamado no método `configureServices()`, prevenindo que o aplicativo inicie se o arquivo `.env` estiver faltando ou se tiver variáveis de ambiente ausentes.
-
-```typescript
-protected configureServices(): void {
-    Environments.checkAll();
-}
-```
-
-O provedor de validação de ambiente também tem um método chamado `get()` que retorna o valor de uma variável de ambiente. Ele é usado para obter um valor específico de variável de ambiente passando seu nome como parâmetro.
-
-```typescript
-Environments.get("PORT");
-```
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/providers/in-memory-db.md b/i18n/pt/docusaurus-plugin-content-docs/current/providers/in-memory-db.md
deleted file mode 100644
index e5b750ed..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/providers/in-memory-db.md
+++ /dev/null
@@ -1,168 +0,0 @@
----
-sidebar_position: 3
----
-
-# Banco de Dados na Memória
-
-O Banco de Dados na Memória (In Memory DB) é um provedor que utiliza um banco de dados simples em memória para armazenar dados. É uma classe que pode ser registrada no sistema de injeção de dependência do ExpressoTS como um singleton.
-
-```typescript
-this.provider.register(InMemoryDB, "Singleton");
-```
-
-A classe InMemoryDB oferece uma maneira simples e eficiente de simular um banco de dados inteiramente na memória, o que pode ser particularmente útil para testes e desenvolvimento rápido, onde um banco de dados completo pode ser excessivo.
-
-## Inspetor de BD
-
-Outra funcionalidade interessante adicionada à classe InMemoryDB é a capacidade de imprimir tabelas no console usando console.table. Esta funcionalidade é especialmente útil para fins de depuração e teste. Também pode ser usada para inspecionar rapidamente o conteúdo de uma tabela.
-
-O conteúdo da tabela será impresso no console toda vez que o repositório for usado por qualquer endpoint que tenha operações de leitura ou escrita no banco de dados.
-
-Aqui está uma imagem mostrando a saída no console do InMemoryDB quando criamos um novo usuário:
-
-![Application Overview](../overview/img/inMemoryDB.png)
-
-:::info
-O Inspetor de BD está ativado por padrão. Assim que você criar uma nova entidade e estender a classe BaseRepository, o InMemoryDB imprimirá a tabela no console.
-:::
-
-## Como Usar o InMemoryDB
-
-Para usar a classe InMemoryDB, você precisa importá-la do pacote expressots e registrá-la como um singleton no sistema de injeção de dependência. Aqui está um exemplo de como fazer isso em uma classe de serviço:
-
-### Registrar InMemoryDB
-
-```typescript
-export class App extends AppExpress {
-    private middleware: IMiddleware;
-    private provider: ProviderManager;
-
-    constructor() {
-        super();
-        this.middleware = container.get<IMiddleware>(Middleware);
-        this.provider = container.get(ProviderManager);
-    }
-
-    protected configureServices(): void {
-        this.provider.register(InMemoryDB, "Singleton");
-    }
-
-    protected postServerInitialization(): void {}
-
-    protected serverShutdown(): void {}
-}
-```
-
-Ao registrar a classe `InMemoryDB`, você pode especificar o escopo como string ou usando o `BindingScopeEnum`.
-
-### Defina sua Entidade
-
-```typescript
-@provide(UserEntity)
-export class UserEntity {
-    id: string;
-    name: string;
-    email: string;
-
-    constructor() {
-        this.id = randomUUID();
-    }
-}
-```
-
-### Crie o Padrao de Repositorio
-
-O repositório é uma classe que estende a classe BaseRepository e é usada para gerenciar entidades de um tipo específico. A classe do repositório faz parte do sistema de injeção de dependência e é marcada pelo decorador @provide.
-
-```typescript
-@provide(UserRepository)
-export class UserRepository extends BaseRepository<UserEntity> {
-    constructor() {
-        super("users");
-    }
-}
-```
-
-Na classe acima, estamos criando um repositório para a classe UserEntity. O repositório é inicializado com o nome da tabela users no construtor.
-
-Você também pode definir métodos personalizados para o repositório de usuários.
-
-```typescript
-@provide(UserRepository)
-class UserRepository extends BaseRepository<UserEntity> {
-    constructor() {
-        super("users");
-    }
-
-    // Custom method implemented for the UserRepository only
-    findByEmail(email: string): User | null {
-        const user = this.table.find((item) => item.email === email);
-        return user || null;
-    }
-}
-```
-
-### Usando o Repositório
-
-Você pode injetar o repositório no construtor ou via injeção de propriedade.
-
-Injeção de Propriedade:
-
-```typescript
-@provide(UserCreateUseCase)
-export class UserCreateUseCase {
-    @inject(UserRepository)
-    private userRepo: UserRepository;
-
-    @inject(UserEntity)
-    private userEntity: UserEntity;
-
-    execute(payload: IUserCreateRequestDTO): IUserCreateResponseDTO {
-        this.userEntity.name = payload.name;
-        this.userEntity.email = payload.email;
-
-        this.userRepo.create(this.userEntity);
-
-        return {
-            id: this.userEntity.id,
-            name: this.userEntity.name,
-            email: this.userEntity.email,
-        };
-    }
-}
-```
-
-Injeção no Construtor:
-
-```typescript
-@provide(UserCreateUseCase)
-export class UserCreateUseCase {
-    constructor(private userEntity: UserEntity, private userRepo: UserRepository) {}
-
-    execute(payload: IUserCreateRequestDTO): IUserCreateResponseDTO {
-        this.userEntity.name = payload.name;
-        this.userEntity.email = payload.email;
-
-        this.userRepo.create(this.userEntity);
-
-        return {
-            id: this.userEntity.id,
-            name: this.userEntity.name,
-            email: this.userEntity.email,
-        };
-    }
-}
-```
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/providers/prisma.mdx b/i18n/pt/docusaurus-plugin-content-docs/current/providers/prisma.mdx
deleted file mode 100644
index 0a4f1071..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/providers/prisma.mdx
+++ /dev/null
@@ -1,599 +0,0 @@
----
-sidebar_position: 4
----
-
-import Tabs from "@theme/Tabs";
-import TabItem from "@theme/TabItem";
-
-# Prisma Provider
-
-:::danger Prisma foi removido e será servido como um pacote separado via [add provider] comando.
-:::
-
-O Provedor Prisma do ExpressoTS encapsula o robusto ORM (Object-Relational Mapper) [Prisma](https://www.prisma.io/) dentro do framework ExpressoTS, criando uma interface transparente para operações de dados. O Prisma facilita um acesso seguro, tipo-seguro e simplificado ao seu banco de dados, garantindo que as interações de dados dentro das suas aplicações sejam precisas e eficientes. Seu potente motor de consulta simplifica significativamente o acesso ao banco de dados e mitiga bugs comuns associados à recuperação e manipulação de dados.
-
-## Como Instalar
-
-Aproveitar as capacidades do Prisma dentro do seu framework ExpressoTS é simplificado com a ajuda do [ExpressoTS CLI](https://github.com/expressots/expressots-cli). O CLI fornece um assistente dedicado para simplificar a configuração do Prisma, garantindo uma integração sem complicações.
-
-```bash title="terminal"
-expressots add prisma
-
-- Type the prisma client version (default=latest): (latest)
-- Type the schema name (default=schema): (schema)
-- Where do you want to save your prisma schema (default=./): (.)
-- Select your database:
-  CockroachDB
-  Microsoft SQL Server
-  MongoDB
-  MySQL
-> PostgreSQL
-  SQLite
-- Do you want to install the latest recommended database driver for PostgreSQL? (Y/n)
-- Do you want to add BaseRepository Pattern in this project? this will replace the existing BaseRepository and BaseRepositoryInterface if it exists. (Y/n)
-```
-
-Ao seguir estas instruções, o ExpressoTS garante uma instalação e configuração sem problemas do Prisma, adaptadas às necessidades do seu projeto.
-
-## Atualização de Configuração
-
-Após a instalação, um novo conjunto de configurações referentes ao provedor Prisma está disponível para você ajustar. Isso inclui schemaName, schemaPath, entitiesPath e entityNamePattern. Personalize essas configurações para se alinhar com a arquitetura e convenções de nomenclatura do seu projeto.
-
-```ts title="expressots.config.ts"
-import { ExpressoConfig, Pattern } from "@expressots/core";
-
-const config: ExpressoConfig = {
-    sourceRoot: "src",
-    scaffoldPattern: Pattern.KEBAB_CASE,
-    opinionated: true,
-    providers: {
-        // highlight-start
-        prisma: {
-            schemaName: "schema",
-            schemaPath: "./prisma",
-            entitiesPath: "entities",
-            entityNamePattern: "entity",
-        },
-        // highlight-end
-    },
-};
-
-export default config;
-```
-
-## Extensão do Repositório Base
-
-Durante o processo de configuração, será solicitado a você estender o seu repositório base existente ou criar um novo, caso nenhum exista. Isso inclui tanto a interface quanto a implementação, permitindo uma maneira padronizada de interagir com suas entidades de banco de dados.
-
-<Tabs>
-
-  <TabItem label="Interface" value="interface">
-
-```ts title="./src/repositories/base-repository.interface.ts"
-import { Prisma, PrismaClient } from "@prisma/client";
-import { CreateInput, ModelsOf, DeleteWhere, Select, PrismaAction } from "@expressots/prisma";
-
-interface IBaseRepository<ModelName extends ModelsOf<PrismaClient>> {
-    // highlight-start
-    aggregate: (args: PrismaAction<ModelName, "aggregate">) => Promise<any>;
-    count: (args: PrismaAction<ModelName, "count">) => Promise<number>;
-    // highlight-end
-    create: (
-        data:
-            | CreateInput<ModelName>["data"]
-            | {
-                  data: CreateInput<ModelName>["data"];
-                  select?: Select<ModelName, "create">["select"];
-              }
-    ) => Promise<ModelName | never>;
-    // ...
-}
-```
-
-  </TabItem>
-
-  <TabItem label="Implementation" value="implementation">
-
-```ts title="./src/repositories/base-repository.ts"
-import { PrismaClient, Prisma } from "@prisma/client";
-import {
-  CreateInput,
-  ModelsOf,
-  DeleteWhere,
-  Select,
-  PrismaAction,
-} from "@expressots/prisma";
-import { provide } from "inversify-binding-decorators";
-import { IBaseRepository } from "./base-repository.interface";
-
-@provide(BaseRepository)
-class BaseRepository<ModelName extends ModelsOf<PrismaClient>>
-  implements IBaseRepository<ModelName>
-{
-  protected prismaModel: any;
-  protected prismaClient: PrismaClient;
-  constructor(modelName: keyof PrismaClient) {
-    this.prismaClient = new PrismaClient();
-    this.prismaModel = this.prismaClient[modelName];
-  }
-
-  // highlight-start
-  async aggregate(args: PrismaAction<ModelName, "aggregate">): Promise<any> {
-    return await this.prismaModel.aggregate(args);
-  }
-  // highlight-end
-
-  // highlight-start
-  async count(args: PrismaAction<ModelName, "count">): Promise<number> {
-    return await this.prismaModel.count(args);
-  }
-  // highlight-end
-```
-
-  </TabItem>
-
-</Tabs>
-
-## Utilizando Decoradores Prisma do ExpressoTS
-
-Desenvolvemos decoradores para facilitar o uso do Prisma com o ExpressoTS. Você pode usar os decoradores com Entidades, enums e tipos para gerar o esquema Prisma automaticamente.
-
-### Decoradores
-
-| Decorador       | Descrição                                                        | Opções                                                                |
-| --------------- | ---------------------------------------------------------------- | --------------------------------------------------------------------- |
-| @prismaModel    | Decora uma classe como um modelo Prisma                          | map                                                                   |
-| @prismaField    | Decora uma propriedade com atributo específico do banco de dados | attr, isId, isOptional, type, isUnique, prismaDefault, mapField, name |
-| @prismaRelation | Decora uma propriedade como uma relação Prisma                   | relation, name, model, refs, fields, onDelete, onUpdate, isRequired   |
-| @prismaIndex    | Decora uma propriedade como um índice Prisma                     | name, fields, map, type                                               |
-
-### Decorador PrismaModel
-
-O decorador @prismaModel() é essencial para designar uma classe como um modelo Prisma, o que por sua vez desencadeia a geração automática do esquema Prisma correspondente.
-
-Opções:
-
--   `map`: A opção map está disponível para mapear o nome da classe para um nome diferente no esquema Prisma, garantindo a flexibilidade de aderir às convenções ou requisitos de nomenclatura. Para uma compreensão aprofundada da opção de mapa, consulte a documentação do Prisma.
-
-Vamos ilustrar isso com um exemplo extraído do modelo Opinativo. Inicialmente, a entidade está estruturada da seguinte forma:
-
-<div style={{ display: 'flex', justifyContent: 'center', alignItems: 'center' }}>
-
-<div style={{ display: 'flex', justifyContent: 'center', alignItems: 'center' }}>
-
-```mermaid
-classDiagram
-class User {
-    +id: string
-    +name: string
-    +email: string
-    +constructor()
-}
-```
-
-</div>
-
-<div style={{ flex: 1 }}>
-
-```ts title="./src/entities/user.entity.ts"
-import { provide } from "inversify-binding-decorators";
-import { randomUUID } from "node:crypto";
-import { IEntity } from "./base.entity";
-
-// highlight-start
-@provide(User)
-export class User implements IEntity {
-    id: string;
-    name!: string;
-    email!: string;
-
-    constructor() {
-        this.id = randomUUID();
-    }
-}
-// highlight-end
-```
-
-</div>
-
-</div>
-
-A única adição necessária para começar é o decorador `@prismaModel()` à classe:
-
-<Tabs>
-
-<TabItem label="Entity" value="entity">
-
-```ts title="./src/entities/user.entity.ts"
-import { provide } from "inversify-binding-decorators";
-import { randomUUID } from "node:crypto";
-import { IEntity } from "./base.entity";
-// highlight-start
-import { prismaModel } from "@expressots/prisma";
-// highlight-end
-
-@provide(User)
-// highlight-start
-@prismaModel({ map: "user" })
-// highlight-end
-export class User implements IEntity {
-    id: string;
-    name!: string;
-    email!: string;
-
-    constructor() {
-        this.id = randomUUID();
-    }
-}
-```
-
-</TabItem>
-
-<TabItem label="Terminal" value="terminal">
-
-```bash title="Terminal"
-npm run prisma
-```
-
-</TabItem>
-
-<TabItem label="Prisma Schema" value="prisma-schema">
-
-```typescript title="./prisma/schema.prisma"
-model User {
-
-  @@map("users")
-}
-```
-
-</TabItem>
-</Tabs>
-
----
-
-Ao executar isso, você poderá encontrar uma mensagem de erro conforme mostrado abaixo. Este é um comportamento previsto, pois o Prisma exige pelo menos um critério exclusivo por modelo e não fornecemos nenhum por meio dos decoradores.
-
-```ansii
-error: Error validating model "User": Each model must have at least one unique criteria that has only required fields. Either mark a single field with `@id`, `@unique` or add a multi field criterion with `@@id([])` or `@@unique([])` to the model.
-  -->  schema.prisma:13
-   |
-12 |
-13 | model User {
-14 |
-15 |   @@map("users")
-16 | }
-   |
-```
-
-:::note
-Para gerar o modelo Prisma, `@prismaModel()` deve ser usado o decorador. Todas as entidades devem ser decoradas com `@prismaModel()`.
-:::
-
-### Decorador PrismaField
-
-O decorador `@prismaField()` é usado para decorar uma propriedade com atributos específicos do prisma disponíveis na [documentação do Prisma](https://www.prisma.io/docs/reference/api-reference/prisma-schema-reference# campos do modelo).
-
-Opções:
-
--   `attr`: Você pode usar a opção `attr` para adicionar atributos específicos ao campo por banco de dados. Para obter mais informações sobre a opção `attr`, consulte a [documentação do Prisma](https://www.prisma.io/docs/reference/api-reference/prisma-schema-reference#model-fields).
-
-<Tabs>
-
-<TabItem label="Entity" value="entity">
-
-```ts title="./src/entities/user.entity.ts"
-import { provide } from "inversify-binding-decorators";
-import { randomUUID } from "node:crypto";
-import { IEntity } from "./base.entity";
-import { prismaModel, prismaField, db } from "@expressots/prisma";
-
-@provide(User)
-@prismaModel({ map: "users" })
-export class User implements IEntity {
-    @prismaField({ attr: db.Postgres.Uuid, isUnique: true, isId: true })
-    id: string;
-
-    @prismaField({ attr: db.Postgres.Char(36) })
-    name!: string;
-
-    @prismaField({ attr: db.Postgres.Char(36) })
-    email!: string;
-
-    constructor() {
-        this.id = randomUUID();
-    }
-}
-```
-
-</TabItem>
-
-<TabItem label="Terminal" value="terminal">
-
-```bash title="Terminal"
-npm run prisma
-```
-
-</TabItem>
-
-<TabItem label="Prisma Schema" value="prisma-schema">
-
-```typescript title="./prisma/schema.prisma"
-model User {
-  // highlight-start
-  id    String @id @unique @db.Uuid
-  name  String @db.Char(36)
-  email String @db.Char(36)
-  // highlight-end
-
-  @@map("user")
-}
-```
-
-</TabItem>
-</Tabs>
-
-:::note
-`db` é um namespace que contém todos os atributos disponíveis por banco de dados.
-:::
-
-### Decorador de Relação Prisma
-
-O decorador `@prismaRelation()` é um recurso poderoso que agiliza a criação de relacionamentos entre modelos Prisma. Simplifica o processo ao permitir a definição de relações a partir da perspectiva do modelo onde o relacionamento é iniciado de forma mais lógica. Isso significa que em vez de definir uma chave estrangeira em um modelo filho, você pode declarar o relacionamento no modelo pai, o que pode ser mais intuitivo, especialmente ao lidar com relacionamentos um-para-muitos (1-M).
-
-As opções para `@prismaRelation()` incluem:
-
--   `model`: Especifica o modelo Prisma relacionado.
--   `relação`: Define o tipo de relacionamento, como um para muitos, um para um, etc.
--   `refs`: Uma matriz que denota o(s) campo(s) aos quais o relacionamento está referenciando.
--   `fields`: Especifica o(s) campo(s) no modelo que são usados para a relação.
--   `onDelete` e `onUpdate`: Definem as ações referenciais nas operações de exclusão e atualização.
--   `isRequired`: Determina se o campo relacionado é obrigatório.
-
-Agora, vamos aplicar isso a um exemplo específico para melhor compreensão.
-
-#### Exemplo: relacionamento User-Post
-
-<div style={{ display: 'flex', justifyContent: 'center', gap: '2rem' }}>
-
-<div style={{ display: "flex", width: "50%" }}>
-
-```mermaid
-classDiagram
-  class User {
-    +String id
-    +String name
-    +String email
-    +Array~Post~ posts
-  }
-  class Post {
-    +String id
-  }
-
-  User "1" --> "*" Post : has many
-```
-
-</div>
-
-<div>
-
-Considere uma plataforma de blog onde um usuário pode criar várias postagens. Queremos definir um relacionamento um-para-muitos dos modelos `User` para `Post`. Do ponto de vista do desenvolvimento de aplicações, é mais natural expressar que um usuário “tem muitas” postagens do que dizer que uma postagem “pertence a” um usuário. Com o decorador `@prismaRelation()`, podemos declarar diretamente esse relacionamento no modelo `User`.
-
-</div>
-
-</div>
-
-Veja como podemos usar o decorador `@prismaRelation()` no contexto:
-
-<Tabs>
-
-<TabItem label="User Entity" value="user-entity">
-
-```ts title="./src/entities/user.entity.ts"
-import { provide } from "inversify-binding-decorators";
-import { randomUUID } from "node:crypto";
-import { IEntity } from "./base.entity";
-import {
-    prismaModel,
-    prismaField,
-    // highlight-start
-    prismaRelation,
-    Relation,
-    // highlight-end
-    db,
-} from "@expressots/prisma";
-import { Post } from "./post.entity";
-
-@provide(User)
-@prismaModel({ map: "user" })
-export class User implements IEntity {
-    @prismaField({ attr: db.Postgres.Uuid, isUnique: true, isId: true })
-    id: string;
-
-    @prismaField({ attr: db.Postgres.Char(36) })
-    name!: string;
-
-    @prismaField({ attr: db.Postgres.Char(36) })
-    email!: string;
-
-    // highlight-start
-    // Define the one-to-many relationship to Post.
-    @prismaField({ type: Post })
-    @prismaRelation({
-        model: "Post",
-        relation: Relation.OneToMany,
-        refs: ["id"],
-    })
-    posts: Post[]; // This is where the User-Post relationship is expressed.
-    // highlight-end
-
-    constructor() {
-        this.id = randomUUID();
-    }
-}
-```
-
-</TabItem>
-
-<TabItem label="Post Entity" value="post-entity">
-
-```ts title="./src/entities/post.entity.ts"
-import { provide } from "inversify-binding-decorators";
-import { prismaModel, prismaField } from "@expressots/prisma";
-import { randomUUID } from "node:crypto";
-
-@prismaModel({ map: "posts" })
-@provide(Post)
-export class Post {
-    @prismaField({ isId: true })
-    id: string;
-
-    // highlight-next-line
-    // No need to explicitly define the foreign key field here; it's handled by the provider. 🥳
-
-    constructor() {
-        this.id = randomUUID();
-    }
-}
-```
-
-</TabItem>
-
-<TabItem label="Terminal" value="terminal">
-
-```bash title="Terminal"
-npm run prisma
-```
-
-</TabItem>
-
-<TabItem label="Prisma Schema" value="prisma-schema">
-
-```typescript title="./prisma/schema.prisma"
-model User {
-  id    String @id @unique @db.Uuid
-  name  String @db.Char(36)
-  email String @db.Char(36)
-  // highlight-next-line
-  posts Post[]
-
-  @@map("user")
-}
-
-model Post {
-  id     String  @id @unique @db.Uuid
-  // highlight-start
-  user   User?   @relation(fields: [userId], references: [id])
-  userId String? @unique
-  // highlight-end
-
-  @@map("posts")
-}
-```
-
-</TabItem>
-</Tabs>
-
-Neste exemplo, o modelo `User` usa o decorador `@prismaRelation()` para declarar sua conexão com múltiplas instâncias `Post`. O Prisma cuidará automaticamente da criação da chave estrangeira correspondente no modelo `Post`, tornando o relacionamento gerenciado de forma explícita e implícita, reduzindo assim o potencial de erro e confusão.
-
-:::observação
-A sintaxe declarativa do decorador `@prismaRelation()` se alinha estreitamente com a forma como os desenvolvedores conceituam os relacionamentos no aplicativo, fornecendo uma ponte entre o modelo de objeto e o esquema de banco de dados subjacente.
-:::
-
-### Decorador PrismaIndex
-
-O decorador `@prismaIndex()` é essencial para otimizar consultas ao banco de dados, definindo índices em campos específicos de um modelo Prisma. Os índices são tabelas de pesquisa especiais que o mecanismo de pesquisa do banco de dados pode usar para acelerar a recuperação de dados. A indexação adequada de um banco de dados pode melhorar drasticamente o desempenho de um aplicativo.
-
-Ao aplicar o decorador `@prismaIndex()` a um modelo, você fornece ao Prisma as informações necessárias para criar um índice no banco de dados subjacente. O decorador pega um objeto com diversas opções:
-
--   `name`: Especifica um nome para o índice, permitindo fácil referência e gerenciamento.
--   `fields`: Define um array de campos a serem incluídos no índice. Estas são as propriedades do modelo que você espera consultar com frequência.
--   `type`: Dita o tipo de índice a ser utilizado, influenciando como o banco de dados organiza e recupera os dados.
-
-#### Tipos de índice
-
-O enum `IndexType` oferece uma seleção de tipos de índice adequados para diferentes tipos de dados e padrões de consulta:
-
--   `Brin`: Índices de intervalo de blocos são adequados para tabelas grandes nas quais certas colunas têm uma correlação linear com sua localização física no disco.
--   `Btree`: Os índices de árvore balanceada são os mais comuns e excelentes para uso geral. Eles suportam consultas de igualdade e intervalo de forma eficiente.
--   `Gist`: índices de árvore de pesquisa generalizada suportam tipos complexos como dados geométricos e podem lidar com dados multidimensionais.
--   `Gin`: Índices invertidos generalizados são otimizados para indexar valores compostos onde cada item indexado pode conter vários valores de componentes.
--   `Hash`: Os índices hash fornecem recuperação rápida para pesquisas de igualdade, mas não suportam consultas de intervalo.
--   `Spgist`: índices de árvore de pesquisa generalizada particionados em espaço são bons para dados que não se ajustam bem a uma estrutura de árvore B, como números de telefone ou endereços IP.
-
-Cada tipo de índice vem com suas próprias características de desempenho e é otimizado para tipos específicos de consultas e padrões de dados. A escolha do tipo de índice correto é crucial para o desempenho das operações de leitura e, consequentemente, para o desempenho geral da aplicação.
-
-#### Exemplo de uso
-
-Abaixo está um exemplo de como usar o decorador `@prismaIndex()` para definir um índice hash no campo `email` de um modelo `User`, o que aceleraria consultas que procuram usuários por seus endereços de email:
-
-<Tabs>
-
-<TabItem label="Entity" value="entity">
-
-```ts title="./src/entities/user.entity.ts"
-import {
-    prismaModel,
-    prismaField,
-    prismaRelation,
-    // highlight-next-line
-    prismaIndex,
-    Relation,
-    // highlight-next-line
-    IndexType,
-    db,
-} from "@expressots/prisma";
-
-@provide(User)
-@prismaModel({ map: "user" })
-// highlight-next-line
-@prismaIndex({ name: "emailIndex", fields: ["email"], type: IndexType.Hash })
-export class User implements IEntity {
-    // ...
-
-    // highlight-next-line
-    @prismaField({ attr: db.Postgres.Char(36), isUnique: true })
-    email!: string;
-}
-```
-
-</TabItem>
-
-<TabItem label="Terminal" value="terminal">
-
-```bash title="Terminal"
-npm run prisma
-```
-
-</TabItem>
-
-<TabItem label="Prisma Schema" value="prisma-schema">
-
-```prisma title="./prisma/schema.prisma"
-model User {
-  email String @db.Char(36)
-
-  @@unique([id, email])
-  @@index([email], name: "emailIndex", type: Hash)
-  @@map("user")
-}
-```
-
-</TabItem>
-</Tabs>
-
-:::note
-Os índices são cruciais para otimizar seu banco de dados, mas devem ser usados criteriosamente, pois podem afetar o desempenho de gravação e consumir armazenamento adicional.
-:::
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/roadmap.md b/i18n/pt/docusaurus-plugin-content-docs/current/roadmap.md
deleted file mode 100644
index f43fb30d..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/roadmap.md
+++ /dev/null
@@ -1,20 +0,0 @@
----
-sidebar_position: 6
----
-
-# Roadmap
-
-Em breve...
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
-- Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
-- Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
-- Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
-- Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
-- Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
-- Compartilhe o projeto com seus amigos e colegas
\ No newline at end of file
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/sidebar.json b/i18n/pt/docusaurus-plugin-content-docs/current/sidebar.json
deleted file mode 100644
index 7f4ab7ae..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/sidebar.json
+++ /dev/null
@@ -1,4 +0,0 @@
-{
-    "title": "Expresso TS",
-    "config.tagline": "Um framework TypeScript leve, rápido e fácil de usar"
-}
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/tutorials/_category_.json b/i18n/pt/docusaurus-plugin-content-docs/current/tutorials/_category_.json
deleted file mode 100644
index c743db20..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/tutorials/_category_.json
+++ /dev/null
@@ -1,8 +0,0 @@
-{
-  "label": "Tutoriais",
-  "position": 5,
-  "link": {
-    "type": "generated-index",
-    "description": "Expresso TS Tutoriais."
-  }
-}
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/tutorials/compression.md b/i18n/pt/docusaurus-plugin-content-docs/current/tutorials/compression.md
deleted file mode 100644
index 5c97f4bb..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/tutorials/compression.md
+++ /dev/null
@@ -1,132 +0,0 @@
----
-sidebar_position: 1
----
-
-# Compressão
-
-O pacote npm compression é um middleware que pode comprimir corpos de resposta para solicitações que passam por ele, o que pode ajudar a reduzir o tamanho dos dados que são enviados pela rede, levando a tempos de resposta mais rápidos e uso menor de largura de banda. Ele usa a biblioteca zlib para realizar a compressão gzip ou deflate, ambos amplamente suportados pelos navegadores da web modernos.
-
-## Como usar Compression no ExpressoTS
-
-Instale o middleware de compressão npm.
-
-```bash
-npm i compression
-npm i -D @types/compression
-```
-
-### Adicione o Middleware Globalmente
-
-**Modelo não opinativo**: adicione o middleware de compressão no método `create` da classe `AppFactory`.
-
-```typescript
-import compression from "compression";
-
-async function bootstrap() {
-    const app = await AppFactory.create(container, [compression()]);
-    await app.listen(3001, ServerEnvironment.Development);
-}
-
-bootstrap();
-```
-
-**Modelo opinativo**: configure o middleware de compressão na classe `App` do provedor. No modelo opinativo, middlewares comuns do `expressjs` são oferecidos por padrão para uso. Explore as opções na propriedade `this.middleware`.
-
-```typescript
-@provide(App)
-export class App extends AppExpress {
-    private middleware: IMiddleware;
-    private provider: IProvider;
-
-    constructor() {
-        super();
-        this.middleware = container.get<IMiddleware>(Middleware);
-        this.provider = container.get<IProvider>(Provider);
-    }
-
-    protected configureServices(): void {
-        this.middleware.addCompression();
-    }
-
-    protected postServerInitialization(): void {
-        if (this.isDevelopment()) {
-            this.provider.envValidator.checkAll();
-        }
-    }
-
-    protected serverShutdown(): void {}
-}
-```
-
-Um exemplo usando compressão com filtros, selecionando solicitações que contêm payloads de carga útil maiores que 100 \* 1024 bytes:
-
-```typescript
-async function bootstrap() {
-    const app = await AppFactory.create(container, [
-        compression({
-            level: 6,
-            threshold: 100 * 1024,
-            filter: (req, res) => {
-                if (req.headers["x-no-compression"]) {
-                    return false;
-                }
-                return compression.filter(req, res);
-            },
-        }),
-    ]);
-    await app.listen(3001, ServerEnvironment.Development);
-}
-
-bootstrap();
-```
-
-### Adicione o Middleware a Rotas Específicas
-
-O código a seguir adiciona o middleware de compressão a rotas específicas validos em ambos os modelos opinativo e não opinativo.
-
-```typescript
-@Get("/", compression())
-execute(){};
-```
-
-:::tip
-Para mais informações sobre o pacote de compressão npm, por favor visite o **[pacote compression do npm](https://www.npmjs.com/package/compression)**.
-:::
-
-## Pacote de compressão
-
--   Desempenho: Pode reduzir significativamente o tamanho do corpo da resposta, diminuindo assim o tempo que um cliente leva para baixar a resposta e renderizar o conteúdo.
-
--   Eficiência: Ajuda na redução do consumo de largura de banda, o que é especialmente útil se o seu servidor estiver enviando grandes quantidades de dados ou se você tiver largura de banda limitada.
-    Contras do pacote npm Compression:
-
--   Sobrecarga: Embora a compressão reduza o tamanho do corpo da resposta, ela adiciona alguma sobrecarga computacional do lado do servidor, pois o servidor deve comprimir o corpo da resposta antes de enviá-lo.
-
-:::caution SOBRECARGA DA COMPRESSÃO
-Isso pode não ser ideal para sites de alto tráfego onde os recursos do servidor estão em alta demanda.
-:::
-
-Nem todo conteúdo se beneficia da compressão. Arquivos binários como imagens e vídeos já são comprimidos e tentar comprimi-los ainda mais às vezes pode até aumentar o tamanho deles.
-
-## Quando usar
-
-Decidir quando usar a compressão depende do caso de uso. Se o seu site serve muitos dados textuais (HTML, CSS, JS, JSON, XML etc.), então usar o pacote de compressão npm pode resultar em economias significativas de largura de banda e benefícios de desempenho. No entanto, se o seu site tem um tráfego extremamente alto, a sobrecarga computacional adicional da compressão pode começar a se tornar um gargalo.
-
-Em cenários de alto tráfego, pode ser mais benéfico usar um proxy reverso ou uma CDN (Rede de Entrega de Conteúdo) que pode servir ativos estáticos e realizar caching. Isso pode desviar parte do tráfego dos seus servidores principais e também servir conteúdo de locais geograficamente mais próximos dos usuários, resultando em tempos de resposta mais rápidos. Esses serviços geralmente lidam com a compressão por conta própria, o que significa que você não precisaria usar o pacote de compressão npm.
-
-As abordagens modernas podem envolver uma combinação de técnicas - servir ativos estáticos de uma CDN, armazenar em cache respostas quando apropriado, utilizar HTTP/2 para multiplexação e dividir seu aplicativo em microserviços para distribuir a carga.
-
-Lembre-se, essas abordagens não são mutuamente exclusivas. Muitas vezes, a melhor abordagem é usar uma combinação dessas técnicas com base nos requisitos específicos do seu aplicativo. Testar e monitorar seu aplicativo sob cargas de trabalho realistas pode ajudá-lo a tomar a melhor decisão.
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-plugin-content-docs/current/tutorials/cookies.md b/i18n/pt/docusaurus-plugin-content-docs/current/tutorials/cookies.md
deleted file mode 100644
index 41caba48..00000000
--- a/i18n/pt/docusaurus-plugin-content-docs/current/tutorials/cookies.md
+++ /dev/null
@@ -1,150 +0,0 @@
----
-sidebar_position: 2
----
-
-# Cookies
-
-Cookies são pequenos pedaços de dados que um site envia para o navegador da web de um usuário enquanto o usuário está navegando nesse site. Sempre que o usuário carrega o site, o navegador envia o cookie de volta ao servidor para notificar o site da atividade anterior do usuário.
-
-## Como Usar Cookies no ExpressoTS
-
-Instale o middleware cookie-parser npm e a definição de tipo.
-
-```bash
-npm i cookie-parser
-npm i -D @types/cookie-parser
-```
-
-### Adicione o Middleware Globalmente
-
-**Modelo não opinativo**: adicione o middleware cookie-parser no método de criação da aplicação no `AppFactory`.
-
-```typescript
-import cookieParser from "cookie-parser";
-
-// Adicione o middleware no método de criação da aplicação
-async function bootstrap() {
-    const app = await AppFactory.create(container, [cookieParser()]);
-    await app.listen(3000, ServerEnvironment.Development);
-}
-
-bootstrap();
-```
-
-**Modelo opinativo**: configure o middleware cookie-parser na classe provedora `App`. No modelo opinativo, os middlewares comuns do `expressjs` são oferecidos prontos para uso. Explore as opções na propriedade `this.middleware`.
-
-```typescript
-@provide(App)
-export class App extends AppExpress {
-    private middleware: IMiddleware;
-    private provider: IProvider;
-
-    constructor() {
-        super();
-        this.middleware = container.get<IMiddleware>(Middleware);
-        this.provider = container.get<IProvider>(Provider);
-    }
-
-    protected configureServices(): void {
-        this.middleware.addCookieParser();
-    }
-
-    protected postServerInitialization(): void {
-        if (this.isDevelopment()) {
-            this.provider.envValidator.checkAll();
-        }
-    }
-
-    protected serverShutdown(): void {}
-}
-```
-
-### Adicione o Middleware a uma Rota
-
-Isso é válido para ambos os modelos. Você pode adicionar o middleware cookie-parser a uma rota específica.
-
-```typescript
-@Get("get-cookie", cookieParser())
-getCookie(){};
-```
-
-Vamos criar uma rota para definir um cookie com um UUID aleatório como valor, que expira em 1 hora e é acessível apenas via HTTP:
-
-```typescript
-@httpGet("set-cookie")
-setCookie(@response() res: Response) {
-    res.cookie("authToken", randomUUID(), {
-        maxAge: 60 * 60 * 1000, // 1 hour
-        httpOnly: true,
-    });
-    return res.send("Cookie set!");
-}
-```
-
-Crie uma rota para obter o valor do cookie:
-
-```typescript
-@httpGet("get-cookie")
-getCookie(@cookies() cookieInfo: string, @response() res: Response) {
-    return res.send(`Your token: ${cookieInfo["authToken"]}`);
-}
-```
-
-:::tip
-`@cookies()` é um decorador auxiliar para obter todos os cookies da requisição. Você também pode usar `@cookies('cookieName')` para obter um cookie específico.
-:::
-
-## Quando Usar Cookies
-
-Os cookies servem a vários propósitos primários:
-
-1. Gerenciamento de sessão: Os cookies são frequentemente usados para lidar com sessões de usuário. Por exemplo, quando você faz login em um site, um cookie é definido para lembrar seu estado de login. Assim, enquanto você navega pelo site, você permanece logado.
-
-2. Personalização: Os cookies podem armazenar preferências do usuário para personalizar a experiência do usuário no site. Por exemplo, cookies podem armazenar informações sobre o idioma preferido do usuário, tema ou outras configurações.
-
-3. Rastreamento: Alguns cookies rastreiam o comportamento do usuário no site ao longo do tempo. Esses são frequentemente usados por ferramentas de análise de terceiros para entender o comportamento do usuário e otimizar o site de acordo. Anunciantes também usam cookies de rastreamento para exibir anúncios direcionados com base na atividade do usuário.
-
-4. Segurança: Os cookies podem ser usados para suportar funções seguras do site. Por exemplo, um cookie pode ser usado para lembrar que um usuário se autenticou em um site para que o servidor saiba que o usuário já forneceu credenciais de login válidas.
-
-Também é importante notar que existem diferentes tipos de cookies - cookies de sessão, que expiram quando a sessão do navegador termina, e cookies persistentes, que permanecem no dispositivo do usuário por um período de tempo definido ou até que sejam explicitamente excluídos.
-
-:::caution USANDO COOKIE PARA RASTREAMENTO
-Tenha em mente que o uso de cookies, especialmente para rastreamento e personalização, levantou preocupações com a privacidade, levando a regulamentações como o GDPR na Europa e o CCPA na Califórnia que exigem que os sites divulguem seu uso de cookies e obtenham o consentimento do usuário.
-:::
-
-## Pacote cookie-parser
-
--   Facilidade de Uso: o cookie-parser torna muito fácil ler valores de cookies, que são frequentemente usados para rastrear sessões de usuários, personalização e gerenciamento de aplicações com estado. Sem esta biblioteca, você teria que analisar manualmente o cabeçalho do Cookie e lidar com as nuances da formatação de cookies.
-
--   Cookies Assinados: O pacote também suporta cookies assinados, que são uma maneira de verificar a integridade dos cookies (ou seja, se eles foram adulterados). Esta é uma funcionalidade importante para garantir a segurança das informações sensíveis armazenadas nos cookies.
-
-## O que considerar ao usar o cookie-parser
-
--   Sobrecarga: Embora não seja uma biblioteca pesada, usar o cookie-parser adiciona um pouco de sobrecarga a cada requisição, pois ele analisa todos os cookies, independentemente de serem usados no manipulador de rota.
-
--   Estado: Os cookies, por natureza, tornam uma aplicação com estado. Ao escalar uma aplicação, o estado pode ser problemático. Portanto, métodos de autenticação alternativos sem estado, como tokens, podem ser preferíveis em uma arquitetura de microserviços.
-
-## Quando usar
-
-Decidir quando usar o cookie-parser depende em grande parte das necessidades de sua aplicação. Se sua aplicação web requer gerenciamento de estado e você escolheu fazer isso por meio de cookies, o cookie-parser pode facilitar sua vida e tornar sua aplicação mais segura com cookies assinados.
-
-No entanto, se seu site tem um tráfego pesado, a sobrecarga pode se tornar uma preocupação. Se sua arquitetura é baseada em serviços sem estado (comum em arquiteturas de microserviços), você pode querer evitar cookies e optar por outros métodos de manter o estado, como JWTs (JSON Web Tokens).
-
-:::info
-Caso você esteja lidando com um site de alto tráfego, considere alternativas como sessões armazenadas em um banco de dados, JWTs, ou tokens armazenados em cabeçalhos HTTP. Além disso, usar um balanceador de carga para distribuir o tráfego e módulos de armazenamento de sessão para manter dados de sessão em vários servidores pode ajudar a gerenciar alto tráfego e dados com estado.
-:::
-
-Assim como antes, a melhor abordagem geralmente envolve combinar várias técnicas, adaptadas às necessidades específicas de sua aplicação. Testar e monitorar sua aplicação sob condições realistas pode ajudar a orientar seu processo de tomada de decisão.
-
----
-
-## Apoie o projeto
-
-ExpressoTS é um projeto de código aberto licenciado sob o MIT. É um projeto independente com desenvolvimento contínuo possibilitado graças ao seu suporte. Se você deseja ajudar, por favor considere:
-
--   Se tornar um **[Sponsor no GitHub](https://github.com/sponsors/expressots)**
--   Siga a **[organização](https://github.com/expressots)** no GitHub e de um Star ⭐ no projeto
--   Subscreva no nosso canal na Twitch: **[Richard Zampieri](https://www.twitch.tv/richardzampieri)**
--   Entre no nosso **[Discord](https://discord.com/invite/PyPJfGK)**
--   Contribua submetendo **[issues e pull requests](https://github.com/expressots/expressots/issues/new/choose)**
--   Compartilhe o projeto com seus amigos e colegas
diff --git a/i18n/pt/docusaurus-theme-classic/footer.json b/i18n/pt/docusaurus-theme-classic/footer.json
deleted file mode 100644
index 43e71d37..00000000
--- a/i18n/pt/docusaurus-theme-classic/footer.json
+++ /dev/null
@@ -1,38 +0,0 @@
-{
-  "link.title.Docs": {
-    "message": "Documentação",
-    "description": "O título da coluna de links do rodapé com título=Docs no rodapé"
-  },
-  "link.title.Community": {
-    "message": "Comunidade",
-    "description": "O título da coluna de links do rodapé com título=Community no rodapé"
-  },
-  "link.title.Code": {
-    "message": "Código",
-    "description": "O título da coluna de links do rodapé com título=Code no rodapé"
-  },
-  "link.item.label.Tutorial": {
-    "message": "Tutorial",
-    "description": "O rótulo do link do rodapé com rótulo=Tutorial apontando para /docs/intro"
-  },
-  "link.item.label.Twitch TV": {
-    "message": "Twitch TV",
-    "description": "O rótulo do link do rodapé com rótulo=Twitch TV apontando para https://www.twitch.tv/richardzampieri"
-  },
-  "link.item.label.NPM Core": {
-    "message": "NPM Core",
-    "description": "O rótulo do link do rodapé com rótulo=NPM Core apontando para https://www.npmjs.com/package/@expressots/core"
-  },
-  "link.item.label.NPM CLI": {
-    "message": "NPM CLI",
-    "description": "O rótulo do link do rodapé com rótulo=NPM CLI apontando para https://www.npmjs.com/package/@expressots/cli"
-  },
-  "link.item.label.GitHub": {
-    "message": "GitHub",
-    "description": "O rótulo do link do rodapé com rótulo=GitHub apontando para https://github.com/expressots"
-  },
-  "copyright": {
-    "message": "Direitos autorais © 2023 ExpressoTS oficial, lançado sob a licença MIT.",
-    "description": "O aviso de direitos autorais no rodapé"
-  }
-}
diff --git a/i18n/pt/docusaurus-theme-classic/navbar.json b/i18n/pt/docusaurus-theme-classic/navbar.json
deleted file mode 100644
index bb86dad0..00000000
--- a/i18n/pt/docusaurus-theme-classic/navbar.json
+++ /dev/null
@@ -1,34 +0,0 @@
-{
-  "title": {
-    "message": "Expresso TS",
-    "description": "O título na barra de navegação"
-  },
-  "logo.alt": {
-    "message": "Expresso TS",
-    "description": "O texto alternativo do logotipo da barra de navegação"
-  },
-  "item.label.Documentation": {
-    "message": "Documentação",
-    "description": "Item da barra de navegação com rótulo Documentação"
-  },
-  "item.label.Governance": {
-    "message": "Governança",
-    "description": "Item da barra de navegação com rótulo Governança"
-  },
-  "item.label.GitHub": {
-    "message": "GitHub",
-    "description": "Item da barra de navegação com rótulo GitHub"
-  },
-  "item.label.Language": {
-    "message": "Idioma",
-    "description": "Item da barra de navegação com rótulo Idioma"
-  },
-  "item.label.English": {
-    "message": "Inglês",
-    "description": "Item da barra de navegação com rótulo Inglês"
-  },
-  "item.label.Português": {
-    "message": "Português",
-    "description": "Item da barra de navegação com rótulo Português"
-  }
-}
diff --git a/package-lock.json b/package-lock.json
index 7ce640f3..7b1baac2 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -8,10 +8,10 @@
             "name": "classic",
             "version": "1.0.0",
             "dependencies": {
-                "@docusaurus/core": "3.4.0",
-                "@docusaurus/preset-classic": "3.4.0",
-                "@docusaurus/remark-plugin-npm2yarn": "3.4.0",
-                "@docusaurus/theme-mermaid": "3.4.0",
+                "@docusaurus/core": "^3.5.2",
+                "@docusaurus/preset-classic": "^3.5.2",
+                "@docusaurus/remark-plugin-npm2yarn": "^3.5.2",
+                "@docusaurus/theme-mermaid": "^3.5.2",
                 "@mdx-js/react": "3.0.1",
                 "axios": "1.7.2",
                 "clsx": "2.1.1",
@@ -21,9 +21,9 @@
                 "react-dom": "18.3.1"
             },
             "devDependencies": {
-                "@docusaurus/module-type-aliases": "3.4.0",
-                "@docusaurus/tsconfig": "3.4.0",
-                "@docusaurus/types": "3.4.0",
+                "@docusaurus/module-type-aliases": "^3.5.2",
+                "@docusaurus/tsconfig": "^3.5.2",
+                "@docusaurus/types": "^3.5.2",
                 "@types/react": "18.3.3",
                 "typescript": "5.5.4"
             },
@@ -2273,20 +2273,20 @@
             }
         },
         "node_modules/@docsearch/css": {
-            "version": "3.6.0",
-            "resolved": "https://registry.npmjs.org/@docsearch/css/-/css-3.6.0.tgz",
-            "integrity": "sha512-+sbxb71sWre+PwDK7X2T8+bhS6clcVMLwBPznX45Qu6opJcgRjAp7gYSDzVFp187J+feSj5dNBN1mJoi6ckkUQ==",
+            "version": "3.6.1",
+            "resolved": "https://registry.npmjs.org/@docsearch/css/-/css-3.6.1.tgz",
+            "integrity": "sha512-VtVb5DS+0hRIprU2CO6ZQjK2Zg4QU5HrDM1+ix6rT0umsYvFvatMAnf97NHZlVWDaaLlx7GRfR/7FikANiM2Fg==",
             "license": "MIT"
         },
         "node_modules/@docsearch/react": {
-            "version": "3.6.0",
-            "resolved": "https://registry.npmjs.org/@docsearch/react/-/react-3.6.0.tgz",
-            "integrity": "sha512-HUFut4ztcVNmqy9gp/wxNbC7pTOHhgVVkHVGCACTuLhUKUhKAF9KYHJtMiLUJxEqiFLQiuri1fWF8zqwM/cu1w==",
+            "version": "3.6.1",
+            "resolved": "https://registry.npmjs.org/@docsearch/react/-/react-3.6.1.tgz",
+            "integrity": "sha512-qXZkEPvybVhSXj0K7U3bXc233tk5e8PfhoZ6MhPOiik/qUQxYC+Dn9DnoS7CxHQQhHfCvTiN0eY9M12oRghEXw==",
             "license": "MIT",
             "dependencies": {
                 "@algolia/autocomplete-core": "1.9.3",
                 "@algolia/autocomplete-preset-algolia": "1.9.3",
-                "@docsearch/css": "3.6.0",
+                "@docsearch/css": "3.6.1",
                 "algoliasearch": "^4.19.1"
             },
             "peerDependencies": {
@@ -2311,9 +2311,9 @@
             }
         },
         "node_modules/@docusaurus/core": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/core/-/core-3.4.0.tgz",
-            "integrity": "sha512-g+0wwmN2UJsBqy2fQRQ6fhXruoEa62JDeEa5d8IdTJlMoaDaEDfHh7WjwGRn4opuTQWpjAwP/fbcgyHKlE+64w==",
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/core/-/core-3.5.2.tgz",
+            "integrity": "sha512-4Z1WkhCSkX4KO0Fw5m/Vuc7Q3NxBG53NE5u59Rs96fWkMPZVSrzEPP16/Nk6cWb/shK7xXPndTmalJtw7twL/w==",
             "license": "MIT",
             "dependencies": {
                 "@babel/core": "^7.23.3",
@@ -2326,12 +2326,12 @@
                 "@babel/runtime": "^7.22.6",
                 "@babel/runtime-corejs3": "^7.22.6",
                 "@babel/traverse": "^7.22.8",
-                "@docusaurus/cssnano-preset": "3.4.0",
-                "@docusaurus/logger": "3.4.0",
-                "@docusaurus/mdx-loader": "3.4.0",
-                "@docusaurus/utils": "3.4.0",
-                "@docusaurus/utils-common": "3.4.0",
-                "@docusaurus/utils-validation": "3.4.0",
+                "@docusaurus/cssnano-preset": "3.5.2",
+                "@docusaurus/logger": "3.5.2",
+                "@docusaurus/mdx-loader": "3.5.2",
+                "@docusaurus/utils": "3.5.2",
+                "@docusaurus/utils-common": "3.5.2",
+                "@docusaurus/utils-validation": "3.5.2",
                 "autoprefixer": "^10.4.14",
                 "babel-loader": "^9.1.3",
                 "babel-plugin-dynamic-import-node": "^2.3.3",
@@ -2392,14 +2392,15 @@
                 "node": ">=18.0"
             },
             "peerDependencies": {
+                "@mdx-js/react": "^3.0.0",
                 "react": "^18.0.0",
                 "react-dom": "^18.0.0"
             }
         },
         "node_modules/@docusaurus/cssnano-preset": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/cssnano-preset/-/cssnano-preset-3.4.0.tgz",
-            "integrity": "sha512-qwLFSz6v/pZHy/UP32IrprmH5ORce86BGtN0eBtG75PpzQJAzp9gefspox+s8IEOr0oZKuQ/nhzZ3xwyc3jYJQ==",
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/cssnano-preset/-/cssnano-preset-3.5.2.tgz",
+            "integrity": "sha512-D3KiQXOMA8+O0tqORBrTOEQyQxNIfPm9jEaJoALjjSjc2M/ZAWcUfPQEnwr2JB2TadHw2gqWgpZckQmrVWkytA==",
             "license": "MIT",
             "dependencies": {
                 "cssnano-preset-advanced": "^6.1.2",
@@ -2412,9 +2413,9 @@
             }
         },
         "node_modules/@docusaurus/logger": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/logger/-/logger-3.4.0.tgz",
-            "integrity": "sha512-bZwkX+9SJ8lB9kVRkXw+xvHYSMGG4bpYHKGXeXFvyVc79NMeeBSGgzd4TQLHH+DYeOJoCdl8flrFJVxlZ0wo/Q==",
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/logger/-/logger-3.5.2.tgz",
+            "integrity": "sha512-LHC540SGkeLfyT3RHK3gAMK6aS5TRqOD4R72BEU/DE2M/TY8WwEUAMY576UUc/oNJXv8pGhBmQB6N9p3pt8LQw==",
             "license": "MIT",
             "dependencies": {
                 "chalk": "^4.1.2",
@@ -2425,14 +2426,14 @@
             }
         },
         "node_modules/@docusaurus/mdx-loader": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/mdx-loader/-/mdx-loader-3.4.0.tgz",
-            "integrity": "sha512-kSSbrrk4nTjf4d+wtBA9H+FGauf2gCax89kV8SUSJu3qaTdSIKdWERlngsiHaCFgZ7laTJ8a67UFf+xlFPtuTw==",
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/mdx-loader/-/mdx-loader-3.5.2.tgz",
+            "integrity": "sha512-ku3xO9vZdwpiMIVd8BzWV0DCqGEbCP5zs1iHfKX50vw6jX8vQo0ylYo1YJMZyz6e+JFJ17HYHT5FzVidz2IflA==",
             "license": "MIT",
             "dependencies": {
-                "@docusaurus/logger": "3.4.0",
-                "@docusaurus/utils": "3.4.0",
-                "@docusaurus/utils-validation": "3.4.0",
+                "@docusaurus/logger": "3.5.2",
+                "@docusaurus/utils": "3.5.2",
+                "@docusaurus/utils-validation": "3.5.2",
                 "@mdx-js/mdx": "^3.0.0",
                 "@slorber/remark-comment": "^1.0.0",
                 "escape-html": "^1.0.3",
@@ -2464,12 +2465,12 @@
             }
         },
         "node_modules/@docusaurus/module-type-aliases": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/module-type-aliases/-/module-type-aliases-3.4.0.tgz",
-            "integrity": "sha512-A1AyS8WF5Bkjnb8s+guTDuYmUiwJzNrtchebBHpc0gz0PyHJNMaybUlSrmJjHVcGrya0LKI4YcR3lBDQfXRYLw==",
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/module-type-aliases/-/module-type-aliases-3.5.2.tgz",
+            "integrity": "sha512-Z+Xu3+2rvKef/YKTMxZHsEXp1y92ac0ngjDiExRdqGTmEKtCUpkbNYH8v5eXo5Ls+dnW88n6WTa+Q54kLOkwPg==",
             "license": "MIT",
             "dependencies": {
-                "@docusaurus/types": "3.4.0",
+                "@docusaurus/types": "3.5.2",
                 "@types/history": "^4.7.11",
                 "@types/react": "*",
                 "@types/react-router-config": "*",
@@ -2482,27 +2483,27 @@
                 "react-dom": "*"
             }
         },
-        "node_modules/@docusaurus/plugin-content-blog": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-blog/-/plugin-content-blog-3.4.0.tgz",
-            "integrity": "sha512-vv6ZAj78ibR5Jh7XBUT4ndIjmlAxkijM3Sx5MAAzC1gyv0vupDQNhzuFg1USQmQVj3P5I6bquk12etPV3LJ+Xw==",
-            "license": "MIT",
-            "dependencies": {
-                "@docusaurus/core": "3.4.0",
-                "@docusaurus/logger": "3.4.0",
-                "@docusaurus/mdx-loader": "3.4.0",
-                "@docusaurus/types": "3.4.0",
-                "@docusaurus/utils": "3.4.0",
-                "@docusaurus/utils-common": "3.4.0",
-                "@docusaurus/utils-validation": "3.4.0",
-                "cheerio": "^1.0.0-rc.12",
-                "feed": "^4.2.2",
+        "node_modules/@docusaurus/plugin-content-docs": {
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-docs/-/plugin-content-docs-3.5.2.tgz",
+            "integrity": "sha512-Bt+OXn/CPtVqM3Di44vHjE7rPCEsRCB/DMo2qoOuozB9f7+lsdrHvD0QCHdBs0uhz6deYJDppAr2VgqybKPlVQ==",
+            "license": "MIT",
+            "dependencies": {
+                "@docusaurus/core": "3.5.2",
+                "@docusaurus/logger": "3.5.2",
+                "@docusaurus/mdx-loader": "3.5.2",
+                "@docusaurus/module-type-aliases": "3.5.2",
+                "@docusaurus/theme-common": "3.5.2",
+                "@docusaurus/types": "3.5.2",
+                "@docusaurus/utils": "3.5.2",
+                "@docusaurus/utils-common": "3.5.2",
+                "@docusaurus/utils-validation": "3.5.2",
+                "@types/react-router-config": "^5.0.7",
+                "combine-promises": "^1.1.0",
                 "fs-extra": "^11.1.1",
+                "js-yaml": "^4.1.0",
                 "lodash": "^4.17.21",
-                "reading-time": "^1.5.0",
-                "srcset": "^4.0.0",
                 "tslib": "^2.6.0",
-                "unist-util-visit": "^5.0.0",
                 "utility-types": "^3.10.0",
                 "webpack": "^5.88.1"
             },
@@ -2514,28 +2515,18 @@
                 "react-dom": "^18.0.0"
             }
         },
-        "node_modules/@docusaurus/plugin-content-docs": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-docs/-/plugin-content-docs-3.4.0.tgz",
-            "integrity": "sha512-HkUCZffhBo7ocYheD9oZvMcDloRnGhBMOZRyVcAQRFmZPmNqSyISlXA1tQCIxW+r478fty97XXAGjNYzBjpCsg==",
-            "license": "MIT",
-            "dependencies": {
-                "@docusaurus/core": "3.4.0",
-                "@docusaurus/logger": "3.4.0",
-                "@docusaurus/mdx-loader": "3.4.0",
-                "@docusaurus/module-type-aliases": "3.4.0",
-                "@docusaurus/types": "3.4.0",
-                "@docusaurus/utils": "3.4.0",
-                "@docusaurus/utils-common": "3.4.0",
-                "@docusaurus/utils-validation": "3.4.0",
-                "@types/react-router-config": "^5.0.7",
-                "combine-promises": "^1.1.0",
+        "node_modules/@docusaurus/plugin-debug": {
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-debug/-/plugin-debug-3.5.2.tgz",
+            "integrity": "sha512-kBK6GlN0itCkrmHuCS6aX1wmoWc5wpd5KJlqQ1FyrF0cLDnvsYSnh7+ftdwzt7G6lGBho8lrVwkkL9/iQvaSOA==",
+            "license": "MIT",
+            "dependencies": {
+                "@docusaurus/core": "3.5.2",
+                "@docusaurus/types": "3.5.2",
+                "@docusaurus/utils": "3.5.2",
                 "fs-extra": "^11.1.1",
-                "js-yaml": "^4.1.0",
-                "lodash": "^4.17.21",
-                "tslib": "^2.6.0",
-                "utility-types": "^3.10.0",
-                "webpack": "^5.88.1"
+                "react-json-view-lite": "^1.2.0",
+                "tslib": "^2.6.0"
             },
             "engines": {
                 "node": ">=18.0"
@@ -2545,20 +2536,16 @@
                 "react-dom": "^18.0.0"
             }
         },
-        "node_modules/@docusaurus/plugin-content-pages": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-pages/-/plugin-content-pages-3.4.0.tgz",
-            "integrity": "sha512-h2+VN/0JjpR8fIkDEAoadNjfR3oLzB+v1qSXbIAKjQ46JAHx3X22n9nqS+BWSQnTnp1AjkjSvZyJMekmcwxzxg==",
+        "node_modules/@docusaurus/plugin-google-analytics": {
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-google-analytics/-/plugin-google-analytics-3.5.2.tgz",
+            "integrity": "sha512-rjEkJH/tJ8OXRE9bwhV2mb/WP93V441rD6XnM6MIluu7rk8qg38iSxS43ga2V2Q/2ib53PcqbDEJDG/yWQRJhQ==",
             "license": "MIT",
             "dependencies": {
-                "@docusaurus/core": "3.4.0",
-                "@docusaurus/mdx-loader": "3.4.0",
-                "@docusaurus/types": "3.4.0",
-                "@docusaurus/utils": "3.4.0",
-                "@docusaurus/utils-validation": "3.4.0",
-                "fs-extra": "^11.1.1",
-                "tslib": "^2.6.0",
-                "webpack": "^5.88.1"
+                "@docusaurus/core": "3.5.2",
+                "@docusaurus/types": "3.5.2",
+                "@docusaurus/utils-validation": "3.5.2",
+                "tslib": "^2.6.0"
             },
             "engines": {
                 "node": ">=18.0"
@@ -2568,17 +2555,16 @@
                 "react-dom": "^18.0.0"
             }
         },
-        "node_modules/@docusaurus/plugin-debug": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-debug/-/plugin-debug-3.4.0.tgz",
-            "integrity": "sha512-uV7FDUNXGyDSD3PwUaf5YijX91T5/H9SX4ErEcshzwgzWwBtK37nUWPU3ZLJfeTavX3fycTOqk9TglpOLaWkCg==",
+        "node_modules/@docusaurus/plugin-google-gtag": {
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-google-gtag/-/plugin-google-gtag-3.5.2.tgz",
+            "integrity": "sha512-lm8XL3xLkTPHFKKjLjEEAHUrW0SZBSHBE1I+i/tmYMBsjCcUB5UJ52geS5PSiOCFVR74tbPGcPHEV/gaaxFeSA==",
             "license": "MIT",
             "dependencies": {
-                "@docusaurus/core": "3.4.0",
-                "@docusaurus/types": "3.4.0",
-                "@docusaurus/utils": "3.4.0",
-                "fs-extra": "^11.1.1",
-                "react-json-view-lite": "^1.2.0",
+                "@docusaurus/core": "3.5.2",
+                "@docusaurus/types": "3.5.2",
+                "@docusaurus/utils-validation": "3.5.2",
+                "@types/gtag.js": "^0.0.12",
                 "tslib": "^2.6.0"
             },
             "engines": {
@@ -2589,15 +2575,15 @@
                 "react-dom": "^18.0.0"
             }
         },
-        "node_modules/@docusaurus/plugin-google-analytics": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-google-analytics/-/plugin-google-analytics-3.4.0.tgz",
-            "integrity": "sha512-mCArluxEGi3cmYHqsgpGGt3IyLCrFBxPsxNZ56Mpur0xSlInnIHoeLDH7FvVVcPJRPSQ9/MfRqLsainRw+BojA==",
+        "node_modules/@docusaurus/plugin-google-tag-manager": {
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-google-tag-manager/-/plugin-google-tag-manager-3.5.2.tgz",
+            "integrity": "sha512-QkpX68PMOMu10Mvgvr5CfZAzZQFx8WLlOiUQ/Qmmcl6mjGK6H21WLT5x7xDmcpCoKA/3CegsqIqBR+nA137lQg==",
             "license": "MIT",
             "dependencies": {
-                "@docusaurus/core": "3.4.0",
-                "@docusaurus/types": "3.4.0",
-                "@docusaurus/utils-validation": "3.4.0",
+                "@docusaurus/core": "3.5.2",
+                "@docusaurus/types": "3.5.2",
+                "@docusaurus/utils-validation": "3.5.2",
                 "tslib": "^2.6.0"
             },
             "engines": {
@@ -2608,16 +2594,20 @@
                 "react-dom": "^18.0.0"
             }
         },
-        "node_modules/@docusaurus/plugin-google-gtag": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-google-gtag/-/plugin-google-gtag-3.4.0.tgz",
-            "integrity": "sha512-Dsgg6PLAqzZw5wZ4QjUYc8Z2KqJqXxHxq3vIoyoBWiLEEfigIs7wHR+oiWUQy3Zk9MIk6JTYj7tMoQU0Jm3nqA==",
+        "node_modules/@docusaurus/plugin-sitemap": {
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-sitemap/-/plugin-sitemap-3.5.2.tgz",
+            "integrity": "sha512-DnlqYyRAdQ4NHY28TfHuVk414ft2uruP4QWCH//jzpHjqvKyXjj2fmDtI8RPUBh9K8iZKFMHRnLtzJKySPWvFA==",
             "license": "MIT",
             "dependencies": {
-                "@docusaurus/core": "3.4.0",
-                "@docusaurus/types": "3.4.0",
-                "@docusaurus/utils-validation": "3.4.0",
-                "@types/gtag.js": "^0.0.12",
+                "@docusaurus/core": "3.5.2",
+                "@docusaurus/logger": "3.5.2",
+                "@docusaurus/types": "3.5.2",
+                "@docusaurus/utils": "3.5.2",
+                "@docusaurus/utils-common": "3.5.2",
+                "@docusaurus/utils-validation": "3.5.2",
+                "fs-extra": "^11.1.1",
+                "sitemap": "^7.1.1",
                 "tslib": "^2.6.0"
             },
             "engines": {
@@ -2628,16 +2618,25 @@
                 "react-dom": "^18.0.0"
             }
         },
-        "node_modules/@docusaurus/plugin-google-tag-manager": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-google-tag-manager/-/plugin-google-tag-manager-3.4.0.tgz",
-            "integrity": "sha512-O9tX1BTwxIhgXpOLpFDueYA9DWk69WCbDRrjYoMQtFHSkTyE7RhNgyjSPREUWJb9i+YUg3OrsvrBYRl64FCPCQ==",
+        "node_modules/@docusaurus/preset-classic": {
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/preset-classic/-/preset-classic-3.5.2.tgz",
+            "integrity": "sha512-3ihfXQ95aOHiLB5uCu+9PRy2gZCeSZoDcqpnDvf3B+sTrMvMTr8qRUzBvWkoIqc82yG5prCboRjk1SVILKx6sg==",
             "license": "MIT",
             "dependencies": {
-                "@docusaurus/core": "3.4.0",
-                "@docusaurus/types": "3.4.0",
-                "@docusaurus/utils-validation": "3.4.0",
-                "tslib": "^2.6.0"
+                "@docusaurus/core": "3.5.2",
+                "@docusaurus/plugin-content-blog": "3.5.2",
+                "@docusaurus/plugin-content-docs": "3.5.2",
+                "@docusaurus/plugin-content-pages": "3.5.2",
+                "@docusaurus/plugin-debug": "3.5.2",
+                "@docusaurus/plugin-google-analytics": "3.5.2",
+                "@docusaurus/plugin-google-gtag": "3.5.2",
+                "@docusaurus/plugin-google-tag-manager": "3.5.2",
+                "@docusaurus/plugin-sitemap": "3.5.2",
+                "@docusaurus/theme-classic": "3.5.2",
+                "@docusaurus/theme-common": "3.5.2",
+                "@docusaurus/theme-search-algolia": "3.5.2",
+                "@docusaurus/types": "3.5.2"
             },
             "engines": {
                 "node": ">=18.0"
@@ -2647,49 +2646,54 @@
                 "react-dom": "^18.0.0"
             }
         },
-        "node_modules/@docusaurus/plugin-sitemap": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-sitemap/-/plugin-sitemap-3.4.0.tgz",
-            "integrity": "sha512-+0VDvx9SmNrFNgwPoeoCha+tRoAjopwT0+pYO1xAbyLcewXSemq+eLxEa46Q1/aoOaJQ0qqHELuQM7iS2gp33Q==",
-            "license": "MIT",
-            "dependencies": {
-                "@docusaurus/core": "3.4.0",
-                "@docusaurus/logger": "3.4.0",
-                "@docusaurus/types": "3.4.0",
-                "@docusaurus/utils": "3.4.0",
-                "@docusaurus/utils-common": "3.4.0",
-                "@docusaurus/utils-validation": "3.4.0",
+        "node_modules/@docusaurus/preset-classic/node_modules/@docusaurus/plugin-content-blog": {
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-blog/-/plugin-content-blog-3.5.2.tgz",
+            "integrity": "sha512-R7ghWnMvjSf+aeNDH0K4fjyQnt5L0KzUEnUhmf1e3jZrv3wogeytZNN6n7X8yHcMsuZHPOrctQhXWnmxu+IRRg==",
+            "license": "MIT",
+            "dependencies": {
+                "@docusaurus/core": "3.5.2",
+                "@docusaurus/logger": "3.5.2",
+                "@docusaurus/mdx-loader": "3.5.2",
+                "@docusaurus/theme-common": "3.5.2",
+                "@docusaurus/types": "3.5.2",
+                "@docusaurus/utils": "3.5.2",
+                "@docusaurus/utils-common": "3.5.2",
+                "@docusaurus/utils-validation": "3.5.2",
+                "cheerio": "1.0.0-rc.12",
+                "feed": "^4.2.2",
                 "fs-extra": "^11.1.1",
-                "sitemap": "^7.1.1",
-                "tslib": "^2.6.0"
+                "lodash": "^4.17.21",
+                "reading-time": "^1.5.0",
+                "srcset": "^4.0.0",
+                "tslib": "^2.6.0",
+                "unist-util-visit": "^5.0.0",
+                "utility-types": "^3.10.0",
+                "webpack": "^5.88.1"
             },
             "engines": {
                 "node": ">=18.0"
             },
             "peerDependencies": {
+                "@docusaurus/plugin-content-docs": "*",
                 "react": "^18.0.0",
                 "react-dom": "^18.0.0"
             }
         },
-        "node_modules/@docusaurus/preset-classic": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/preset-classic/-/preset-classic-3.4.0.tgz",
-            "integrity": "sha512-Ohj6KB7siKqZaQhNJVMBBUzT3Nnp6eTKqO+FXO3qu/n1hJl3YLwVKTWBg28LF7MWrKu46UuYavwMRxud0VyqHg==",
-            "license": "MIT",
-            "dependencies": {
-                "@docusaurus/core": "3.4.0",
-                "@docusaurus/plugin-content-blog": "3.4.0",
-                "@docusaurus/plugin-content-docs": "3.4.0",
-                "@docusaurus/plugin-content-pages": "3.4.0",
-                "@docusaurus/plugin-debug": "3.4.0",
-                "@docusaurus/plugin-google-analytics": "3.4.0",
-                "@docusaurus/plugin-google-gtag": "3.4.0",
-                "@docusaurus/plugin-google-tag-manager": "3.4.0",
-                "@docusaurus/plugin-sitemap": "3.4.0",
-                "@docusaurus/theme-classic": "3.4.0",
-                "@docusaurus/theme-common": "3.4.0",
-                "@docusaurus/theme-search-algolia": "3.4.0",
-                "@docusaurus/types": "3.4.0"
+        "node_modules/@docusaurus/preset-classic/node_modules/@docusaurus/plugin-content-pages": {
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-pages/-/plugin-content-pages-3.5.2.tgz",
+            "integrity": "sha512-WzhHjNpoQAUz/ueO10cnundRz+VUtkjFhhaQ9jApyv1a46FPURO4cef89pyNIOMny1fjDz/NUN2z6Yi+5WUrCw==",
+            "license": "MIT",
+            "dependencies": {
+                "@docusaurus/core": "3.5.2",
+                "@docusaurus/mdx-loader": "3.5.2",
+                "@docusaurus/types": "3.5.2",
+                "@docusaurus/utils": "3.5.2",
+                "@docusaurus/utils-validation": "3.5.2",
+                "fs-extra": "^11.1.1",
+                "tslib": "^2.6.0",
+                "webpack": "^5.88.1"
             },
             "engines": {
                 "node": ">=18.0"
@@ -2700,9 +2704,9 @@
             }
         },
         "node_modules/@docusaurus/remark-plugin-npm2yarn": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/remark-plugin-npm2yarn/-/remark-plugin-npm2yarn-3.4.0.tgz",
-            "integrity": "sha512-MXcYAkKu6544h7J4vbKdeH+G5HZf6LF3qZORQqWzxOi2p82PTLRu0YM6ZgzfPjH5nZClgLBHypPbyO9qhkxPKw==",
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/remark-plugin-npm2yarn/-/remark-plugin-npm2yarn-3.5.2.tgz",
+            "integrity": "sha512-EAD7R/skPuhW3lWZyDhRuFs3m2EGaR008tuoe6SrFre7PifoxmSCwXk8Nb4VtVRKnnbn4IgHyqq+ma47gGmKwg==",
             "license": "MIT",
             "dependencies": {
                 "mdast-util-mdx": "^3.0.0",
@@ -2716,27 +2720,27 @@
             }
         },
         "node_modules/@docusaurus/theme-classic": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/theme-classic/-/theme-classic-3.4.0.tgz",
-            "integrity": "sha512-0IPtmxsBYv2adr1GnZRdMkEQt1YW6tpzrUPj02YxNpvJ5+ju4E13J5tB4nfdaen/tfR1hmpSPlTFPvTf4kwy8Q==",
-            "license": "MIT",
-            "dependencies": {
-                "@docusaurus/core": "3.4.0",
-                "@docusaurus/mdx-loader": "3.4.0",
-                "@docusaurus/module-type-aliases": "3.4.0",
-                "@docusaurus/plugin-content-blog": "3.4.0",
-                "@docusaurus/plugin-content-docs": "3.4.0",
-                "@docusaurus/plugin-content-pages": "3.4.0",
-                "@docusaurus/theme-common": "3.4.0",
-                "@docusaurus/theme-translations": "3.4.0",
-                "@docusaurus/types": "3.4.0",
-                "@docusaurus/utils": "3.4.0",
-                "@docusaurus/utils-common": "3.4.0",
-                "@docusaurus/utils-validation": "3.4.0",
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/theme-classic/-/theme-classic-3.5.2.tgz",
+            "integrity": "sha512-XRpinSix3NBv95Rk7xeMF9k4safMkwnpSgThn0UNQNumKvmcIYjfkwfh2BhwYh/BxMXQHJ/PdmNh22TQFpIaYg==",
+            "license": "MIT",
+            "dependencies": {
+                "@docusaurus/core": "3.5.2",
+                "@docusaurus/mdx-loader": "3.5.2",
+                "@docusaurus/module-type-aliases": "3.5.2",
+                "@docusaurus/plugin-content-blog": "3.5.2",
+                "@docusaurus/plugin-content-docs": "3.5.2",
+                "@docusaurus/plugin-content-pages": "3.5.2",
+                "@docusaurus/theme-common": "3.5.2",
+                "@docusaurus/theme-translations": "3.5.2",
+                "@docusaurus/types": "3.5.2",
+                "@docusaurus/utils": "3.5.2",
+                "@docusaurus/utils-common": "3.5.2",
+                "@docusaurus/utils-validation": "3.5.2",
                 "@mdx-js/react": "^3.0.0",
                 "clsx": "^2.0.0",
                 "copy-text-to-clipboard": "^3.2.0",
-                "infima": "0.2.0-alpha.43",
+                "infima": "0.2.0-alpha.44",
                 "lodash": "^4.17.21",
                 "nprogress": "^0.2.0",
                 "postcss": "^8.4.26",
@@ -2755,19 +2759,73 @@
                 "react-dom": "^18.0.0"
             }
         },
+        "node_modules/@docusaurus/theme-classic/node_modules/@docusaurus/plugin-content-blog": {
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-blog/-/plugin-content-blog-3.5.2.tgz",
+            "integrity": "sha512-R7ghWnMvjSf+aeNDH0K4fjyQnt5L0KzUEnUhmf1e3jZrv3wogeytZNN6n7X8yHcMsuZHPOrctQhXWnmxu+IRRg==",
+            "license": "MIT",
+            "dependencies": {
+                "@docusaurus/core": "3.5.2",
+                "@docusaurus/logger": "3.5.2",
+                "@docusaurus/mdx-loader": "3.5.2",
+                "@docusaurus/theme-common": "3.5.2",
+                "@docusaurus/types": "3.5.2",
+                "@docusaurus/utils": "3.5.2",
+                "@docusaurus/utils-common": "3.5.2",
+                "@docusaurus/utils-validation": "3.5.2",
+                "cheerio": "1.0.0-rc.12",
+                "feed": "^4.2.2",
+                "fs-extra": "^11.1.1",
+                "lodash": "^4.17.21",
+                "reading-time": "^1.5.0",
+                "srcset": "^4.0.0",
+                "tslib": "^2.6.0",
+                "unist-util-visit": "^5.0.0",
+                "utility-types": "^3.10.0",
+                "webpack": "^5.88.1"
+            },
+            "engines": {
+                "node": ">=18.0"
+            },
+            "peerDependencies": {
+                "@docusaurus/plugin-content-docs": "*",
+                "react": "^18.0.0",
+                "react-dom": "^18.0.0"
+            }
+        },
+        "node_modules/@docusaurus/theme-classic/node_modules/@docusaurus/plugin-content-pages": {
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/plugin-content-pages/-/plugin-content-pages-3.5.2.tgz",
+            "integrity": "sha512-WzhHjNpoQAUz/ueO10cnundRz+VUtkjFhhaQ9jApyv1a46FPURO4cef89pyNIOMny1fjDz/NUN2z6Yi+5WUrCw==",
+            "license": "MIT",
+            "dependencies": {
+                "@docusaurus/core": "3.5.2",
+                "@docusaurus/mdx-loader": "3.5.2",
+                "@docusaurus/types": "3.5.2",
+                "@docusaurus/utils": "3.5.2",
+                "@docusaurus/utils-validation": "3.5.2",
+                "fs-extra": "^11.1.1",
+                "tslib": "^2.6.0",
+                "webpack": "^5.88.1"
+            },
+            "engines": {
+                "node": ">=18.0"
+            },
+            "peerDependencies": {
+                "react": "^18.0.0",
+                "react-dom": "^18.0.0"
+            }
+        },
         "node_modules/@docusaurus/theme-common": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/theme-common/-/theme-common-3.4.0.tgz",
-            "integrity": "sha512-0A27alXuv7ZdCg28oPE8nH/Iz73/IUejVaCazqu9elS4ypjiLhK3KfzdSQBnL/g7YfHSlymZKdiOHEo8fJ0qMA==",
-            "license": "MIT",
-            "dependencies": {
-                "@docusaurus/mdx-loader": "3.4.0",
-                "@docusaurus/module-type-aliases": "3.4.0",
-                "@docusaurus/plugin-content-blog": "3.4.0",
-                "@docusaurus/plugin-content-docs": "3.4.0",
-                "@docusaurus/plugin-content-pages": "3.4.0",
-                "@docusaurus/utils": "3.4.0",
-                "@docusaurus/utils-common": "3.4.0",
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/theme-common/-/theme-common-3.5.2.tgz",
+            "integrity": "sha512-QXqlm9S6x9Ibwjs7I2yEDgsCocp708DrCrgHgKwg2n2AY0YQ6IjU0gAK35lHRLOvAoJUfCKpQAwUykB0R7+Eew==",
+            "license": "MIT",
+            "dependencies": {
+                "@docusaurus/mdx-loader": "3.5.2",
+                "@docusaurus/module-type-aliases": "3.5.2",
+                "@docusaurus/utils": "3.5.2",
+                "@docusaurus/utils-common": "3.5.2",
                 "@types/history": "^4.7.11",
                 "@types/react": "*",
                 "@types/react-router-config": "*",
@@ -2781,21 +2839,22 @@
                 "node": ">=18.0"
             },
             "peerDependencies": {
+                "@docusaurus/plugin-content-docs": "*",
                 "react": "^18.0.0",
                 "react-dom": "^18.0.0"
             }
         },
         "node_modules/@docusaurus/theme-mermaid": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/theme-mermaid/-/theme-mermaid-3.4.0.tgz",
-            "integrity": "sha512-3w5QW0HEZ2O6x2w6lU3ZvOe1gNXP2HIoKDMJBil1VmLBc9PmpAG17VmfhI/p3L2etNmOiVs5GgniUqvn8AFEGQ==",
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/theme-mermaid/-/theme-mermaid-3.5.2.tgz",
+            "integrity": "sha512-7vWCnIe/KoyTN1Dc55FIyqO5hJ3YaV08Mr63Zej0L0mX1iGzt+qKSmeVUAJ9/aOalUhF0typV0RmNUSy5FAmCg==",
             "license": "MIT",
             "dependencies": {
-                "@docusaurus/core": "3.4.0",
-                "@docusaurus/module-type-aliases": "3.4.0",
-                "@docusaurus/theme-common": "3.4.0",
-                "@docusaurus/types": "3.4.0",
-                "@docusaurus/utils-validation": "3.4.0",
+                "@docusaurus/core": "3.5.2",
+                "@docusaurus/module-type-aliases": "3.5.2",
+                "@docusaurus/theme-common": "3.5.2",
+                "@docusaurus/types": "3.5.2",
+                "@docusaurus/utils-validation": "3.5.2",
                 "mermaid": "^10.4.0",
                 "tslib": "^2.6.0"
             },
@@ -2808,19 +2867,19 @@
             }
         },
         "node_modules/@docusaurus/theme-search-algolia": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/theme-search-algolia/-/theme-search-algolia-3.4.0.tgz",
-            "integrity": "sha512-aiHFx7OCw4Wck1z6IoShVdUWIjntC8FHCw9c5dR8r3q4Ynh+zkS8y2eFFunN/DL6RXPzpnvKCg3vhLQYJDmT9Q==",
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/theme-search-algolia/-/theme-search-algolia-3.5.2.tgz",
+            "integrity": "sha512-qW53kp3VzMnEqZGjakaV90sst3iN1o32PH+nawv1uepROO8aEGxptcq2R5rsv7aBShSRbZwIobdvSYKsZ5pqvA==",
             "license": "MIT",
             "dependencies": {
                 "@docsearch/react": "^3.5.2",
-                "@docusaurus/core": "3.4.0",
-                "@docusaurus/logger": "3.4.0",
-                "@docusaurus/plugin-content-docs": "3.4.0",
-                "@docusaurus/theme-common": "3.4.0",
-                "@docusaurus/theme-translations": "3.4.0",
-                "@docusaurus/utils": "3.4.0",
-                "@docusaurus/utils-validation": "3.4.0",
+                "@docusaurus/core": "3.5.2",
+                "@docusaurus/logger": "3.5.2",
+                "@docusaurus/plugin-content-docs": "3.5.2",
+                "@docusaurus/theme-common": "3.5.2",
+                "@docusaurus/theme-translations": "3.5.2",
+                "@docusaurus/utils": "3.5.2",
+                "@docusaurus/utils-validation": "3.5.2",
                 "algoliasearch": "^4.18.0",
                 "algoliasearch-helper": "^3.13.3",
                 "clsx": "^2.0.0",
@@ -2839,9 +2898,9 @@
             }
         },
         "node_modules/@docusaurus/theme-translations": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/theme-translations/-/theme-translations-3.4.0.tgz",
-            "integrity": "sha512-zSxCSpmQCCdQU5Q4CnX/ID8CSUUI3fvmq4hU/GNP/XoAWtXo9SAVnM3TzpU8Gb//H3WCsT8mJcTfyOk3d9ftNg==",
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/theme-translations/-/theme-translations-3.5.2.tgz",
+            "integrity": "sha512-GPZLcu4aT1EmqSTmbdpVrDENGR2yObFEX8ssEFYTCiAIVc0EihNSdOIBTazUvgNqwvnoU1A8vIs1xyzc3LITTw==",
             "license": "MIT",
             "dependencies": {
                 "fs-extra": "^11.1.1",
@@ -2852,16 +2911,16 @@
             }
         },
         "node_modules/@docusaurus/tsconfig": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/tsconfig/-/tsconfig-3.4.0.tgz",
-            "integrity": "sha512-0qENiJ+TRaeTzcg4olrnh0BQ7eCxTgbYWBnWUeQDc84UYkt/T3pDNnm3SiQkqPb+YQ1qtYFlC0RriAElclo8Dg==",
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/tsconfig/-/tsconfig-3.5.2.tgz",
+            "integrity": "sha512-rQ7toURCFnWAIn8ubcquDs0ewhPwviMzxh6WpRjBW7sJVCXb6yzwUaY3HMNa0VXCFw+qkIbFywrMTf+Pb4uHWQ==",
             "dev": true,
             "license": "MIT"
         },
         "node_modules/@docusaurus/types": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/types/-/types-3.4.0.tgz",
-            "integrity": "sha512-4jcDO8kXi5Cf9TcyikB/yKmz14f2RZ2qTRerbHAsS+5InE9ZgSLBNLsewtFTcTOXSVcbU3FoGOzcNWAmU1TR0A==",
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/types/-/types-3.5.2.tgz",
+            "integrity": "sha512-N6GntLXoLVUwkZw7zCxwy9QiuEXIcTVzA9AkmNw16oc0AP3SXLrMmDMMBIfgqwuKWa6Ox6epHol9kMtJqekACw==",
             "license": "MIT",
             "dependencies": {
                 "@mdx-js/mdx": "^3.0.0",
@@ -2880,13 +2939,13 @@
             }
         },
         "node_modules/@docusaurus/utils": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/utils/-/utils-3.4.0.tgz",
-            "integrity": "sha512-fRwnu3L3nnWaXOgs88BVBmG1yGjcQqZNHG+vInhEa2Sz2oQB+ZjbEMO5Rh9ePFpZ0YDiDUhpaVjwmS+AU2F14g==",
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/utils/-/utils-3.5.2.tgz",
+            "integrity": "sha512-33QvcNFh+Gv+C2dP9Y9xWEzMgf3JzrpL2nW9PopidiohS1nDcyknKRx2DWaFvyVTTYIkkABVSr073VTj/NITNA==",
             "license": "MIT",
             "dependencies": {
-                "@docusaurus/logger": "3.4.0",
-                "@docusaurus/utils-common": "3.4.0",
+                "@docusaurus/logger": "3.5.2",
+                "@docusaurus/utils-common": "3.5.2",
                 "@svgr/webpack": "^8.1.0",
                 "escape-string-regexp": "^4.0.0",
                 "file-loader": "^6.2.0",
@@ -2919,9 +2978,9 @@
             }
         },
         "node_modules/@docusaurus/utils-common": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/utils-common/-/utils-common-3.4.0.tgz",
-            "integrity": "sha512-NVx54Wr4rCEKsjOH5QEVvxIqVvm+9kh7q8aYTU5WzUU9/Hctd6aTrcZ3G0Id4zYJ+AeaG5K5qHA4CY5Kcm2iyQ==",
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/utils-common/-/utils-common-3.5.2.tgz",
+            "integrity": "sha512-i0AZjHiRgJU6d7faQngIhuHKNrszpL/SHQPgF1zH4H+Ij6E9NBYGy6pkcGWToIv7IVPbs+pQLh1P3whn0gWXVg==",
             "license": "MIT",
             "dependencies": {
                 "tslib": "^2.6.0"
@@ -2939,14 +2998,14 @@
             }
         },
         "node_modules/@docusaurus/utils-validation": {
-            "version": "3.4.0",
-            "resolved": "https://registry.npmjs.org/@docusaurus/utils-validation/-/utils-validation-3.4.0.tgz",
-            "integrity": "sha512-hYQ9fM+AXYVTWxJOT1EuNaRnrR2WGpRdLDQG07O8UOpsvCPWUVOeo26Rbm0JWY2sGLfzAb+tvJ62yF+8F+TV0g==",
+            "version": "3.5.2",
+            "resolved": "https://registry.npmjs.org/@docusaurus/utils-validation/-/utils-validation-3.5.2.tgz",
+            "integrity": "sha512-m+Foq7augzXqB6HufdS139PFxDC5d5q2QKZy8q0qYYvGdI6nnlNsGH4cIGsgBnV7smz+mopl3g4asbSDvMV0jA==",
             "license": "MIT",
             "dependencies": {
-                "@docusaurus/logger": "3.4.0",
-                "@docusaurus/utils": "3.4.0",
-                "@docusaurus/utils-common": "3.4.0",
+                "@docusaurus/logger": "3.5.2",
+                "@docusaurus/utils": "3.5.2",
+                "@docusaurus/utils-common": "3.5.2",
                 "fs-extra": "^11.2.0",
                 "joi": "^17.9.2",
                 "js-yaml": "^4.1.0",
@@ -4333,9 +4392,9 @@
             }
         },
         "node_modules/algoliasearch-helper": {
-            "version": "3.22.2",
-            "resolved": "https://registry.npmjs.org/algoliasearch-helper/-/algoliasearch-helper-3.22.2.tgz",
-            "integrity": "sha512-3YQ6eo7uYOCHeQ2ZpD+OoT3aJJwMNKEnwtu8WMzm81XmBOSCwRjQditH9CeSOQ38qhHkuGw23pbq+kULkIJLcw==",
+            "version": "3.22.3",
+            "resolved": "https://registry.npmjs.org/algoliasearch-helper/-/algoliasearch-helper-3.22.3.tgz",
+            "integrity": "sha512-2eoEz8mG4KHE+DzfrBTrCmDPxVXv7aZZWPojAJFtARpxxMO6lkos1dJ+XDCXdPvq7q3tpYWRi6xXmVQikejtpA==",
             "license": "MIT",
             "dependencies": {
                 "@algolia/events": "^4.0.1"
@@ -4474,9 +4533,9 @@
             }
         },
         "node_modules/autoprefixer": {
-            "version": "10.4.19",
-            "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.19.tgz",
-            "integrity": "sha512-BaENR2+zBZ8xXhM4pUaKUxlVdxZ0EZhjvbopwnXmxRUfqDmwSpC2lAi/QXvx7NRdPCo1WKEcEF6mV64si1z4Ew==",
+            "version": "10.4.20",
+            "resolved": "https://registry.npmjs.org/autoprefixer/-/autoprefixer-10.4.20.tgz",
+            "integrity": "sha512-XY25y5xSv/wEoqzDyXXME4AFfkZI0P23z6Fs3YgymDnKJkCGOnkL0iTxCa85UTqaSgfcqyf3UA6+c7wUvx/16g==",
             "funding": [
                 {
                     "type": "opencollective",
@@ -4493,11 +4552,11 @@
             ],
             "license": "MIT",
             "dependencies": {
-                "browserslist": "^4.23.0",
-                "caniuse-lite": "^1.0.30001599",
+                "browserslist": "^4.23.3",
+                "caniuse-lite": "^1.0.30001646",
                 "fraction.js": "^4.3.7",
                 "normalize-range": "^0.1.2",
-                "picocolors": "^1.0.0",
+                "picocolors": "^1.0.1",
                 "postcss-value-parser": "^4.2.0"
             },
             "bin": {
@@ -4759,9 +4818,9 @@
             }
         },
         "node_modules/browserslist": {
-            "version": "4.23.1",
-            "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.23.1.tgz",
-            "integrity": "sha512-TUfofFo/KsK/bWZ9TWQ5O26tsWW4Uhmt8IYklbnUa70udB6P2wA7w7o4PY4muaEPBQaAX+CEnmmIA41NVHtPVw==",
+            "version": "4.23.3",
+            "resolved": "https://registry.npmjs.org/browserslist/-/browserslist-4.23.3.tgz",
+            "integrity": "sha512-btwCFJVjI4YWDNfau8RhZ+B1Q/VLoUITrm3RlP6y1tYGWIOa+InuYiRGXUBXo8nA1qKmHMyLB/iVQg5TT4eFoA==",
             "funding": [
                 {
                     "type": "opencollective",
@@ -4778,10 +4837,10 @@
             ],
             "license": "MIT",
             "dependencies": {
-                "caniuse-lite": "^1.0.30001629",
-                "electron-to-chromium": "^1.4.796",
-                "node-releases": "^2.0.14",
-                "update-browserslist-db": "^1.0.16"
+                "caniuse-lite": "^1.0.30001646",
+                "electron-to-chromium": "^1.5.4",
+                "node-releases": "^2.0.18",
+                "update-browserslist-db": "^1.1.0"
             },
             "bin": {
                 "browserslist": "cli.js"
@@ -4895,9 +4954,9 @@
             }
         },
         "node_modules/caniuse-lite": {
-            "version": "1.0.30001640",
-            "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001640.tgz",
-            "integrity": "sha512-lA4VMpW0PSUrFnkmVuEKBUovSWKhj7puyCg8StBChgu298N1AtuF1sKWEvfDuimSEDbhlb/KqPKC3fs1HbuQUA==",
+            "version": "1.0.30001651",
+            "resolved": "https://registry.npmjs.org/caniuse-lite/-/caniuse-lite-1.0.30001651.tgz",
+            "integrity": "sha512-9Cf+Xv1jJNe1xPZLGuUXLNkE1BoDkqRqYyFJ9TDYSqhduqA4hu4oR9HluGoWYQC/aj8WHjsGVV+bwkh0+tegRg==",
             "funding": [
                 {
                     "type": "opencollective",
@@ -6913,9 +6972,9 @@
             "license": "MIT"
         },
         "node_modules/electron-to-chromium": {
-            "version": "1.4.816",
-            "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.4.816.tgz",
-            "integrity": "sha512-EKH5X5oqC6hLmiS7/vYtZHZFTNdhsYG5NVPRN6Yn0kQHNBlT59+xSM8HBy66P5fxWpKgZbPqb+diC64ng295Jw==",
+            "version": "1.5.6",
+            "resolved": "https://registry.npmjs.org/electron-to-chromium/-/electron-to-chromium-1.5.6.tgz",
+            "integrity": "sha512-jwXWsM5RPf6j9dPYzaorcBSUg6AiqocPEyMpkchkvntaH9HGfOOMZwxMJjDY/XEs3T5dM7uyH1VhRMkqUU9qVw==",
             "license": "ISC"
         },
         "node_modules/elkjs": {
@@ -8887,9 +8946,9 @@
             }
         },
         "node_modules/infima": {
-            "version": "0.2.0-alpha.43",
-            "resolved": "https://registry.npmjs.org/infima/-/infima-0.2.0-alpha.43.tgz",
-            "integrity": "sha512-2uw57LvUqW0rK/SWYnd/2rRfxNA5DDNOh33jxF7fy46VWoNhGxiUQyVZHbBMjQ33mQem0cjdDVwgWVAmlRfgyQ==",
+            "version": "0.2.0-alpha.44",
+            "resolved": "https://registry.npmjs.org/infima/-/infima-0.2.0-alpha.44.tgz",
+            "integrity": "sha512-tuRkUSO/lB3rEhLJk25atwAjgLuzq070+pOW8XcvpHky/YbENnRRdPd85IBkyeTgttmOy5ah+yHYsK1HhUd4lQ==",
             "license": "MIT",
             "engines": {
                 "node": ">=12"
@@ -11600,9 +11659,9 @@
             }
         },
         "node_modules/node-releases": {
-            "version": "2.0.14",
-            "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.14.tgz",
-            "integrity": "sha512-y10wOWt8yZpqXmOgRo77WaHEmhYQYGNA6y421PKsKYWEK8aW+cqAphborZDhqfyKrbZEN92CN1X2KbafY2s7Yw==",
+            "version": "2.0.18",
+            "resolved": "https://registry.npmjs.org/node-releases/-/node-releases-2.0.18.tgz",
+            "integrity": "sha512-d9VeXT4SJ7ZeOqGX6R5EM022wpL+eWPooLI+5UpWn2jCT1aosUQEhQP214x33Wkwx3JQMvIm+tIoVOdodFS40g==",
             "license": "MIT"
         },
         "node_modules/non-layered-tidy-tree-layout": {
@@ -13804,9 +13863,9 @@
             "license": "BSD-3-Clause"
         },
         "node_modules/rtlcss": {
-            "version": "4.1.1",
-            "resolved": "https://registry.npmjs.org/rtlcss/-/rtlcss-4.1.1.tgz",
-            "integrity": "sha512-/oVHgBtnPNcggP2aVXQjSy6N1mMAfHg4GSag0QtZBlD5bdDgAHwr4pydqJGd+SUCu9260+Pjqbjwtvu7EMH1KQ==",
+            "version": "4.2.0",
+            "resolved": "https://registry.npmjs.org/rtlcss/-/rtlcss-4.2.0.tgz",
+            "integrity": "sha512-AV+V3oOVvCrqyH5Q/6RuT1IDH1Xy5kJTkEWTWZPN5rdQ3HCFOd8SrbC7c6N5Y8bPpCfZSR6yYbUATXslvfvu5g==",
             "license": "MIT",
             "dependencies": {
                 "escalade": "^3.1.1",
@@ -13923,9 +13982,9 @@
             }
         },
         "node_modules/search-insights": {
-            "version": "2.14.0",
-            "resolved": "https://registry.npmjs.org/search-insights/-/search-insights-2.14.0.tgz",
-            "integrity": "sha512-OLN6MsPMCghDOqlCtsIsYgtsC0pnwVTyT9Mu6A3ewOj1DxvzZF6COrn2g86E/c05xbktB0XN04m/t1Z+n+fTGw==",
+            "version": "2.16.2",
+            "resolved": "https://registry.npmjs.org/search-insights/-/search-insights-2.16.2.tgz",
+            "integrity": "sha512-+KrS5rnYlyWgzoCNJGsNPw7Vv+47Y7Ze7KZ+/9Xls+5BUugEbU2yv1n9JsQOqv+MLKYfg3bxI5K6tYJxXZY8FA==",
             "license": "MIT",
             "peer": true
         },
diff --git a/package.json b/package.json
index 7f91c883..9dbc169a 100644
--- a/package.json
+++ b/package.json
@@ -15,10 +15,10 @@
         "typecheck": "tsc"
     },
     "dependencies": {
-        "@docusaurus/core": "3.4.0",
-        "@docusaurus/preset-classic": "3.4.0",
-        "@docusaurus/remark-plugin-npm2yarn": "3.4.0",
-        "@docusaurus/theme-mermaid": "3.4.0",
+        "@docusaurus/core": "^3.5.2",
+        "@docusaurus/preset-classic": "^3.5.2",
+        "@docusaurus/remark-plugin-npm2yarn": "^3.5.2",
+        "@docusaurus/theme-mermaid": "^3.5.2",
         "@mdx-js/react": "3.0.1",
         "axios": "1.7.2",
         "clsx": "2.1.1",
@@ -28,9 +28,9 @@
         "react-dom": "18.3.1"
     },
     "devDependencies": {
-        "@docusaurus/module-type-aliases": "3.4.0",
-        "@docusaurus/tsconfig": "3.4.0",
-        "@docusaurus/types": "3.4.0",
+        "@docusaurus/module-type-aliases": "^3.5.2",
+        "@docusaurus/tsconfig": "^3.5.2",
+        "@docusaurus/types": "^3.5.2",
         "@types/react": "18.3.3",
         "typescript": "5.5.4"
     },
diff --git a/src/css/custom.css b/src/css/custom.css
index 3a02b038..c7ed370f 100644
--- a/src/css/custom.css
+++ b/src/css/custom.css
@@ -3,57 +3,225 @@
  * bundles Infima by default. Infima is a CSS framework designed to
  * work well for content-centric websites.
  */
- @import url('https://fonts.googleapis.com/css2?family=PT+Sans&display=swap');
- @import url('https://fonts.googleapis.com/css2?family=Montserrat:wght@500;700&display=swap');
+@import url("https://fonts.googleapis.com/css2?family=PT+Sans&display=swap");
+@import url("https://fonts.googleapis.com/css2?family=Montserrat:wght@500;700&display=swap");
 
- body {
-  font-size: 15px;
-  font-weight: 500;
-  font-family: 'Montserrat', sans-serif;
- }
+body {
+    font-size: 16px;
+    font-weight: 500;
+    font-family: "Montserrat", sans-serif;
+}
 
 /* You can override the default Infima variables here. */
 :root {
-  --ifm-color-primary: #111111;
-  --ifm-color-primary-dark: #415171;
-  --ifm-color-primary-darker: #3d4c6b;
-  --ifm-color-primary-darkest: #323f58;
-  --ifm-color-primary-light: #4f638b;
-  --ifm-color-primary-lighter: #536791;
-  --ifm-color-primary-lightest: #5e75a3;
-  --ifm-code-font-size: 95%;
-  --docusaurus-highlighted-code-line-bg: rgba(0, 0, 0, 0.1);
-  --ifm-font-weight-semibold: 700;
-  --ifm-font-family-base: 'Montserrat', sans-serif;
+    --ifm-color-primary: #111111;
+    --ifm-color-primary-dark: #415171;
+    --ifm-color-primary-darker: #3d4c6b;
+    --ifm-color-primary-darkest: #323f58;
+    --ifm-color-primary-light: #4f638b;
+    --ifm-color-primary-lighter: #536791;
+    --ifm-color-primary-lightest: #5e75a3;
+    --ifm-code-font-size: 95%;
+    --docusaurus-highlighted-code-line-bg: rgba(0, 0, 0, 0.1);
+    --ifm-font-weight-semibold: 700;
+    --ifm-font-family-base: "Montserrat", sans-serif;
 }
 
 /* For readability concerns, you should choose a lighter palette in dark mode. */
-[data-theme='dark'] {
-  --ifm-color-primary: #80F5A8;
-  --ifm-color-primary-dark: #4d8497;
-  --ifm-color-primary-darker: #487d8f;
-  --ifm-color-primary-darkest: #3c6776;
-  --ifm-color-primary-light: #659eb1;
-  --ifm-color-primary-lighter: #6ea3b5;
-  --ifm-color-primary-lightest: #87b3c2;
-  --docusaurus-highlighted-code-line-bg: rgba(0, 0, 0, 0.3);
+[data-theme="dark"] {
+    --ifm-color-primary: #80f5a8;
+    --ifm-color-primary-dark: #4d8497;
+    --ifm-color-primary-darker: #487d8f;
+    --ifm-color-primary-darkest: #3c6776;
+    --ifm-color-primary-light: #659eb1;
+    --ifm-color-primary-lighter: #6ea3b5;
+    --ifm-color-primary-lightest: #87b3c2;
+    --docusaurus-highlighted-code-line-bg: rgba(0, 0, 0, 0.3);
+}
+
+html[data-theme="dark"] {
+    background-color: #1f1f22;
+}
+
+[data-theme="dark"] .navbar {
+    background-color: #1b1b1d;
+}
+
+[data-theme="dark"] .menu {
+    background-color: #242427;
+    font-size: 15px;
 }
 
 .navbar {
-  padding: 0 8rem;
-  text-transform: uppercase;
+    padding: 0 8rem;
+    text-transform: uppercase;
 }
 
 .customHeroBanner {
-  background-color: #111111;
+    background-color: #111111;
 }
 
 .customHeroBanner .hero__subtitle {
-  color: #ffffff;
+    color: #ffffff;
 }
 
 @media screen and (max-width: 996px) {
-  .navbar {
-    padding: 0 1.2rem;
-  }
-}
\ No newline at end of file
+    .navbar {
+        padding: 0 1.2rem;
+    }
+}
+
+.span-table {
+    color: #80f5a8;
+}
+
+/* Algolia search */
+
+[data-theme="light"] .DocSearch {
+    /* --docsearch-primary-color: var(--ifm-color-primary); */
+    /* --docsearch-text-color: var(--ifm-font-color-base); */
+    --docsearch-muted-color: var(--ifm-color-secondary-darkest);
+    --docsearch-container-background: rgba(94, 100, 112, 0.7);
+    /* Modal */
+    --docsearch-modal-background: var(--ifm-color-secondary-lighter);
+    /* Search box */
+    --docsearch-searchbox-background: var(--ifm-color-secondary);
+    --docsearch-searchbox-focus-background: var(--ifm-color-white);
+    /* Hit */
+    --docsearch-hit-color: var(--ifm-font-color-base);
+    --docsearch-hit-active-color: var(--ifm-color-white);
+    --docsearch-hit-background: var(--ifm-color-white);
+    /* Footer */
+    --docsearch-footer-background: var(--ifm-color-white);
+}
+
+[data-theme="dark"] .DocSearch {
+    --docsearch-text-color: #80f5a8;
+    --docsearch-muted-color: #80f5a8;
+    --docsearch-container-background: rgba(47, 55, 69, 0.7);
+    /* Modal */
+    --docsearch-modal-background: var(--ifm-background-color);
+    /* Search box */
+    --docsearch-searchbox-background: var(--ifm-background-color);
+    --docsearch-searchbox-focus-background: var(--ifm-color-black);
+    /* Hit */
+    --docsearch-hit-color: var(--ifm-font-color-base);
+    --docsearch-hit-active-color: rgba(0, 0, 0);
+    --docsearch-hit-background: rgb(54, 61, 56);
+    /* Footer */
+    --docsearch-footer-background: var(--ifm-background-surface-color);
+    --docsearch-key-gradient: linear-gradient(
+        -26.5deg,
+        var(--ifm-color-emphasis-200) 0%,
+        var(--ifm-color-emphasis-100) 100%
+    );
+}
+
+/* GitHub Icon Navbar */
+.header-github-link {
+    display: inline-block;
+    width: 24px;
+    height: 24px;
+    background: url("data:image/svg+xml;charset=utf-8,%3Csvg fill='%23ffffff' viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M12 .297c-6.63 0-12 5.373-12 12 0 5.303 3.438 9.8 8.205 11.385.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61C4.422 18.07 3.633 17.7 3.633 17.7c-1.087-.744.084-.729.084-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12'/%3E%3C/svg%3E")
+        no-repeat;
+    background-size: contain; /* Ensure the background fits within the dimensions */
+    background-position: center; /* Center the background image */
+}
+
+/* Hover state */
+.header-github-link:hover {
+    background: url("data:image/svg+xml;charset=utf-8,%3Csvg fill='%2380f5a8' viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M12 .297c-6.63 0-12 5.373-12 12 0 5.303 3.438 9.8 8.205 11.385.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61C4.422 18.07 3.633 17.7 3.633 17.7c-1.087-.744.084-.729.084-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12'/%3E%3C/svg%3E")
+        no-repeat;
+    background-size: contain; /* Ensure the background fits within the dimensions */
+    background-position: center; /* Center the background image */
+    opacity: 0.8;
+}
+
+/* Before state for setting up initial properties */
+.header-github-link:before {
+    content: "";
+    display: inline-block;
+    height: 24px;
+    width: 24px;
+    background-size: contain; /* Ensure the background fits within the dimensions */
+    background-position: center; /* Center the background image */
+}
+
+/* LinkedIn Icon Navbar */
+.header-linkedin-link {
+    display: inline-block;
+    width: 24px;
+    height: 24px;
+    background: url("data:image/svg+xml;charset=utf-8,%3Csvg fill='%23ffffff' viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M19 0h-14c-2.76 0-5 2.24-5 5v14c0 2.76 2.24 5 5 5h14c2.76 0 5-2.24 5-5v-14c0-2.76-2.24-5-5-5zm-11.12 19h-3.88v-11.27h3.88v11.27zm-1.94-12.81c-1.24 0-2.25-1.01-2.25-2.25s1.01-2.25 2.25-2.25 2.25 1.01 2.25 2.25-1.01 2.25-2.25 2.25zm14.06 12.81h-3.88v-5.62c0-1.34-.03-3.06-1.86-3.06s-2.15 1.45-2.15 2.96v5.72h-3.88v-11.27h3.73v1.54h.05c.52-0.99 1.79-2.03 3.69-2.03 3.94 0 4.66 2.59 4.66 5.95v6.81z'/%3E%3C/svg%3E")
+        no-repeat;
+    background-size: contain;
+    background-position: center;
+}
+
+.header-linkedin-link:hover {
+    background: url("data:image/svg+xml;charset=utf-8,%3Csvg fill='%2380f5a8' viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M19 0h-14c-2.76 0-5 2.24-5 5v14c0 2.76 2.24 5 5 5h14c2.76 0 5-2.24 5-5v-14c0-2.76-2.24-5-5-5zm-11.12 19h-3.88v-11.27h3.88v11.27zm-1.94-12.81c-1.24 0-2.25-1.01-2.25-2.25s1.01-2.25 2.25-2.25 2.25 1.01 2.25 2.25-1.01 2.25-2.25 2.25zm14.06 12.81h-3.88v-5.62c0-1.34-.03-3.06-1.86-3.06s-2.15 1.45-2.15 2.96v5.72h-3.88v-11.27h3.73v1.54h.05c.52-0.99 1.79-2.03 3.69-2.03 3.94 0 4.66 2.59 4.66 5.95v6.81z'/%3E%3C/svg%3E")
+        no-repeat;
+    background-size: contain;
+    background-position: center;
+    opacity: 0.8;
+}
+
+.header-linkedin-link:before {
+    content: "";
+    display: inline-block;
+    height: 24px;
+    width: 24px;
+    background-size: contain;
+    background-position: center;
+}
+
+/* Add uniform spacing between navbar items */
+.navbar__item {
+    margin-right: 20px; /* Adjust this value for consistent spacing */
+}
+
+/* Remove extra margin from the last navbar item */
+.navbar__item:last-child {
+    margin-right: 0;
+}
+
+/* Specific adjustments for the GitHub icon */
+.header-github-link {
+    display: inline-block;
+    width: 24px;
+    height: 24px;
+    background: url("data:image/svg+xml;charset=utf-8,%3Csvg fill='%23ffffff' viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M12 .297c-6.63 0-12 5.373-12 12 0 5.303 3.438 9.8 8.205 11.385.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61C4.422 18.07 3.633 17.7 3.633 17.7c-1.087-.744.084-.729.084-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12'/%3E%3C/svg%3E")
+        no-repeat;
+    background-size: contain;
+    background-position: center;
+}
+
+/* Hover state with adjusted color */
+.header-github-link:hover {
+    background: url("data:image/svg+xml;charset=utf-8,%3Csvg fill='%2380f5a8' viewBox='0 0 24 24' xmlns='http://www.w3.org/2000/svg'%3E%3Cpath d='M12 .297c-6.63 0-12 5.373-12 12 0 5.303 3.438 9.8 8.205 11.385.6.113.82-.258.82-.577 0-.285-.01-1.04-.015-2.04-3.338.724-4.042-1.61-4.042-1.61C4.422 18.07 3.633 17.7 3.633 17.7c-1.087-.744.084-.729.084-.729 1.205.084 1.838 1.236 1.838 1.236 1.07 1.835 2.809 1.305 3.495.998.108-.776.417-1.305.76-1.605-2.665-.3-5.466-1.332-5.466-5.93 0-1.31.465-2.38 1.235-3.22-.135-.303-.54-1.523.105-3.176 0 0 1.005-.322 3.3 1.23.96-.267 1.98-.399 3-.405 1.02.006 2.04.138 3 .405 2.28-1.552 3.285-1.23 3.285-1.23.645 1.653.24 2.873.12 3.176.765.84 1.23 1.91 1.23 3.22 0 4.61-2.805 5.625-5.475 5.92.42.36.81 1.096.81 2.22 0 1.606-.015 2.896-.015 3.286 0 .315.21.69.825.57C20.565 22.092 24 17.592 24 12.297c0-6.627-5.373-12-12-12'/%3E%3C/svg%3E")
+        no-repeat;
+    background-size: contain;
+    background-position: center;
+    opacity: 0.8;
+}
+
+/* General navbar styles */
+.navbar {
+    padding: 0 8rem;
+    text-transform: uppercase;
+}
+
+/* Adjust navbar item spacing */
+.navbar__item {
+    margin-right: 10px; /* Adjust for consistent spacing */
+}
+
+/* Remove extra margin from the last navbar item */
+.navbar__item:last-child {
+    margin-right: 0;
+}
+
+/* Specific adjustments for the GitHub icon */
+.header-github-link {
+    margin-right: 20px; /* Match with other navbar items */
+}
diff --git a/src/css/prism.dark-theme.ts b/src/css/prism.dark-theme.ts
new file mode 100644
index 00000000..700b3d0f
--- /dev/null
+++ b/src/css/prism.dark-theme.ts
@@ -0,0 +1,86 @@
+import { PrismTheme } from "prism-react-renderer";
+
+const expressotsDarkTheme: PrismTheme = {
+    plain: {
+        color: "#6a9955", // Light gray for general text
+        backgroundColor: "#2f2f2f", // Very dark gray background
+    },
+    styles: [
+        {
+            types: ["comment"],
+            style: {
+                color: "#6a9955", // Muted green for comments
+                fontStyle: "italic",
+            },
+        },
+        {
+            types: ["string", "inserted"],
+            style: {
+                color: "#b5cea8", // Light green for strings
+            },
+        },
+        {
+            types: ["number", "constant", "builtin", "char", "symbol"],
+            style: {
+                color: "#dcdcaa", // Soft yellow for numbers and constants
+            },
+        },
+        {
+            types: ["variable", "operator", "entity"],
+            style: {
+                color: "#9cdcfe", // Light blue for variables and operators
+            },
+        },
+        {
+            types: ["function", "keyword"],
+            style: {
+                color: "#4ec9b0", // Aqua green for functions and keywords
+            },
+        },
+        {
+            types: ["class-name", "tag"],
+            style: {
+                color: "#569cd6", // Brighter blue for class names and tags
+            },
+        },
+        {
+            types: ["attr-name"],
+            style: {
+                color: "#c586c0", // Purple for attribute names
+            },
+        },
+        {
+            types: ["punctuation", "selector"],
+            style: {
+                color: "#d4d4d4", // Inherit light gray for punctuation
+            },
+        },
+        {
+            types: ["deleted"],
+            style: {
+                color: "#ff6666", // Red for deletions
+                fontStyle: "italic",
+            },
+        },
+        {
+            types: ["important", "bold"],
+            style: {
+                fontWeight: "bold",
+            },
+        },
+        {
+            types: ["italic"],
+            style: {
+                fontStyle: "italic",
+            },
+        },
+        {
+            types: ["underline"],
+            style: {
+                textDecorationLine: "underline",
+            },
+        },
+    ],
+};
+
+export default expressotsDarkTheme;
diff --git a/src/css/prism.light-theme.ts b/src/css/prism.light-theme.ts
new file mode 100644
index 00000000..8bfc29eb
--- /dev/null
+++ b/src/css/prism.light-theme.ts
@@ -0,0 +1,87 @@
+import { PrismTheme } from "prism-react-renderer";
+
+const expressotsLightTheme: PrismTheme = {
+    plain: {
+        color: "#111111", // Dark gray/black for general text
+        backgroundColor: "#ffffff", // White background
+    },
+    styles: [
+        {
+            types: ["comment"],
+            style: {
+                color: "#6a737d", // Gray for comments
+                fontStyle: "italic",
+            },
+        },
+        {
+            types: ["string", "inserted"],
+            style: {
+                color: "#22863a", // Green for strings
+            },
+        },
+        {
+            types: ["number", "constant", "builtin", "char", "symbol"],
+            style: {
+                color: "#d73a49", // Red for numbers and constants
+            },
+        },
+        {
+            types: ["variable", "operator", "entity"],
+            style: {
+                color: "#e36209", // Yellow/Orange for variables and operators
+            },
+        },
+        {
+            types: ["function", "keyword"],
+            style: {
+                color: "#005cc5", // Blue for functions and keywords
+            },
+        },
+        {
+            types: ["class-name", "tag"],
+            style: {
+                color: "#111111", // Black for class names and tags
+                fontWeight: "bold",
+            },
+        },
+        {
+            types: ["attr-name"],
+            style: {
+                color: "#032f62", // Darker blue for attribute names
+            },
+        },
+        {
+            types: ["punctuation", "selector"],
+            style: {
+                color: "#333333", // Dark gray for punctuation
+            },
+        },
+        {
+            types: ["deleted"],
+            style: {
+                color: "#d73a49", // Red for deletions
+                fontStyle: "italic",
+            },
+        },
+        {
+            types: ["important", "bold"],
+            style: {
+                fontWeight: "bold",
+            },
+        },
+        {
+            types: ["italic"],
+            style: {
+                fontStyle: "italic",
+            },
+        },
+        {
+            types: ["underline"],
+            style: {
+                textDecorationLine: "underline",
+            },
+        },
+    ],
+};
+
+export default expressotsLightTheme;
diff --git a/src/pages/index.tsx b/src/pages/index.tsx
index d0e9a22e..a1e7723a 100644
--- a/src/pages/index.tsx
+++ b/src/pages/index.tsx
@@ -1,52 +1,60 @@
-import React from 'react';
-import clsx from 'clsx';
-import Link from '@docusaurus/Link';
-import useDocusaurusContext from '@docusaurus/useDocusaurusContext';
-import Layout from '@theme/Layout';
-import HomepageFeatures from '@site/src/components/HomepageFeatures';
-import BannerImage from '@site/static/img/expressoTS-Banner.png';
-import {translate} from '@docusaurus/Translate';
+import React from "react";
+import clsx from "clsx";
+import Link from "@docusaurus/Link";
+import useDocusaurusContext from "@docusaurus/useDocusaurusContext";
+import Layout from "@theme/Layout";
+import HomepageFeatures from "@site/src/components/HomepageFeatures";
+import BannerImage from "@site/static/img/expressoTS-Banner.png";
+import { translate } from "@docusaurus/Translate";
+import { Redirect } from "@docusaurus/router";
 
-import styles from './index.module.css';
+import styles from "./index.module.css";
 
 function HomepageHeader() {
-  const {siteConfig} = useDocusaurusContext();
-  return (
-    <header className={clsx('hero hero--primary customHeroBanner', styles.heroBanner)}>
-      <div className="container">
-        <h1 className="hero__title"><img height="180px" width="auto" src={BannerImage} alt="Expresso TS Banner" /></h1>
-        <p className="hero__subtitle">{translate({message: "tagline"})}</p>
-        <div className={styles.btnContainer}>
-        <div>
-          <Link
-            className={clsx("button button--secondary button--lg", styles.button)}
-            to="/docs/hello">
-            {translate({message: "homepageDocumentation"})}
-          </Link>
-        </div>
-        <div >
-          <Link
-            className={clsx("button button--secondary button--lg", styles.button)}
-            to="https://github.com/expressots/expressots">
-            {translate({message: "homepageSourceCode"})}
-          </Link>
-        </div>
-        </div>
-      </div>
-    </header>
-  );
+    const { siteConfig } = useDocusaurusContext();
+    return (
+        <header className={clsx("hero hero--primary customHeroBanner", styles.heroBanner)}>
+            <div className="container">
+                <h1 className="hero__title">
+                    <img height="180px" width="auto" src={BannerImage} alt="Expresso TS Banner" />
+                </h1>
+                <p className="hero__subtitle">{translate({ message: "tagline" })}</p>
+                <div className={styles.btnContainer}>
+                    <div>
+                        <Link
+                            className={clsx("button button--secondary button--lg", styles.button)}
+                            to="/docs/intro"
+                        >
+                            {translate({ message: "homepageDocumentation" })}
+                        </Link>
+                    </div>
+                    <div>
+                        <Link
+                            className={clsx("button button--secondary button--lg", styles.button)}
+                            to="https://github.com/expressots/expressots"
+                        >
+                            {translate({ message: "homepageSourceCode" })}
+                        </Link>
+                    </div>
+                </div>
+            </div>
+        </header>
+    );
 }
 
 export default function Home(): JSX.Element {
-  const {siteConfig} = useDocusaurusContext();
-  return (
-    <Layout
-      title={`${siteConfig.title}`}
-      description="Description will go into a meta tag in <head />">
-      <HomepageHeader />
-      <main>
-        <HomepageFeatures />
-      </main>
-    </Layout>
-  );
+    const { siteConfig } = useDocusaurusContext();
+
+    return <Redirect to="/docs/intro" />;
+    return (
+        <Layout
+            title={`${siteConfig.title}`}
+            description="Description will go into a meta tag in <head />"
+        >
+            <HomepageHeader />
+            <main>
+                <HomepageFeatures />
+            </main>
+        </Layout>
+    );
 }
diff --git a/tsconfig.json b/tsconfig.json
index be89e8aa..196531b6 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -3,5 +3,6 @@
     "extends": "@docusaurus/tsconfig",
     "compilerOptions": {
         "baseUrl": "."
-    }
+    },
+    "exclude": ["node_modules", "build", "dist"]
 }