docs: add Gotify notifications and update build type documentation

apps/docs/content/docs/core/(Notifications)/gotify.mdx

@@ -0,0 +1,20 @@
+---
+title: Gotify
+description: 'Configure gotify notifications for your applications.'
+---
+
+Gotify notifications are a great way to stay up to date with important events in your Dokploy panel. You can choose to receive notifications for specific events or all events.
+
+## Gotify Notifications
+
+For start receiving gotify notifications, you need to fill the form with the following details:
+
+- **Name**: Enter any name you want.
+- **Server URL**: Enter the gotify server URL. eg. `https://gotify.example.com`
+- **App Token**: Enter the gotify token.
+- **Priority**: Enter the priority of the notification, default is `5` (1-10).
+
+To Setup the Gotify notifications, you can read the [Gotify Documentation](https://gotify.net/docs/install).
+
+
+

apps/docs/content/docs/core/applications/build-type.mdx

@@ -13,22 +13,68 @@ Dokploy offers three distinct build types for deploying applications, each suite
 
 This is the default build type in Dokploy. When you select Nixpacks, Dokploy builds your application as a Nixpack, which is optimized for ease of use and efficiency.
 
+
+
+Nixpacks expose multiples variables to be configured via environment variables. All of these variables are prefixed with `NIXPACKS_`, you can define them in the `Environment Variables` tab.
+
+| Variable                      | Description                                                                                  |
+| :---------------------------- | :------------------------------------------------------------------------------------------- |
+| `NIXPACKS_INSTALL_CMD`        | Override the install command to use                                                          |
+| `NIXPACKS_BUILD_CMD`          | Override the build command to use                                                            |
+| `NIXPACKS_START_CMD`          | Override command to run when starting the container                                          |
+| `NIXPACKS_PKGS`               | Add additional [Nix packages](https://search.nixos.org/packages?channel=unstable) to install |
+| `NIXPACKS_APT_PKGS`           | Add additional Apt packages to install (comma delimited)                                     |
+| `NIXPACKS_LIBS`               | Add additional Nix libraries to make available                                               |
+| `NIXPACKS_INSTALL_CACHE_DIRS` | Add additional directories to cache during the install phase                                 |
+| `NIXPACKS_BUILD_CACHE_DIRS`   | Add additional directories to cache during the build phase                                   |
+| `NIXPACKS_NO_CACHE`           | Disable caching for the build                                                                |
+| `NIXPACKS_CONFIG_FILE`        | Location of the Nixpacks configuration file relative to the root of the app                  |
+| `NIXPACKS_DEBIAN`             | Enable Debian base image, used for supporting OpenSSL 1.1                                    |
+
+If you need more manage about nixpacks process, you can create a `nixpacks.toml` file in the root of your application you can read here [Nixpacks Configuration](https://nixpacks.com/docs/configuration/file).
+
+Nixpacks support monorepo such as NX Monorepo, Turborepo, Moon Repo, you can read more about it [here](https://nixpacks.com/docs/providers/node#build).
+
 You can read more about Nixpacks [here](https://nixpacks.com/).
 
+Since Nixpacks have a [static builder](https://nixpacks.com/docs/providers/staticfile) Dokploy expose a field called `Publish Directory`  where basically you can specify
+the directory that you want to publish after the build process is finished, example:
+
+Astro applications after you build it usually create a `dist` directory, so you can specify the `dist` directory as the publish directory and then Dokploy will
+copy all the files in the `dist` directory to the root of your application, and will use a NGINX Optimized Dockerfile to run your application.
+
+
 ### Dockerfile
 
-If your project includes a Dockerfile, you can specify its path. Dokploy will use this Dockerfile to build your application directly, giving you full control over the build environment and dependencies.
+If your project includes a Dockerfile, you can specify its path. Dokploy will use this Dockerfile to build your application directly, giving you full control over the build environment and dependencies
+
+Dokploy expose 3 Fields to be configured:
+
+- `Dockerfile Path (Required)`: The path to the Dockerfile to use for building the application, eg. If your Dockerfile is in the root of your application you can just specify the `Dockerfile` file.
+- `Docker Context Path`: This is where the Dockerfile is located, eg. If your Dockerfile is in the root of your application you can just specify the `.` (dot) character, is basically to tell docker what context will use to build your application, you can read [Dockerfile Context](https://docs.docker.com/build/concepts/context/) for more information.
+- `Docker Build Stage`: This is the build stage to use for building the application, eg. If you want to use the `builder` stage you can specify the `builder` stage, read more about build stages [here](https://docs.docker.com/build/building/multi-stage/).
+
+
 
 ### Buildpack
 
 Dokploy supports two types of buildpacks:
 
-- **Heroku**: Adapted from Heroku's popular cloud platform, these buildpacks are designed for compatibility and ease of migration.
+- **Heroku**: Adapted from Heroku's popular cloud platform, these buildpacks are designed for compatibility and ease of migration, you can optional specify the Heroku Version to use, by default Dokploy will use the 24.
 - **Paketo**: Provides cloud-native buildpacks that leverage modern standards and practices for building applications.
 
-<Callout>
-  **Tip:** We recommend using the `Nixpacks` build type as it is the most
-  straightforward and commonly used option for most applications.
-</Callout>
-
 By choosing the appropriate build type, you can tailor the deployment process to best fit your application's requirements and your operational preferences.
+
+
+### Static
+
+Static build type is used to server static applications, it will use a NGINX Optimized Dockerfile to run your application.
+
+Dokploy will copy everything from the `Root` directory and will mount it to the `/usr/share/nginx/html` directory, and will use a NGINX Optimized Dockerfile to run your application.
+
+
+## Recomendations 
+
+- For prototyping and development purposes, we recommend using the `Nixpacks` build type.
+- For production purposes, we recommend follow this [Production Guide](/docs/core/applications/going-production) to have a rock solid deployment.
+- For static applications, we recommend using the `Static` build type.