Let a stranded release be re-run without moving the tag

The v0.2.0 release died twice on the runner -- once OOM-killed by six parallel
builds, once with the host going away mid-compile -- and each time the only way
back was to delete the tag and push it again. That is destructive, it rewrites
published history for a version that may already be half-published, and it is
easy to get wrong under pressure.

Add a workflow_dispatch trigger so the same release can simply be re-run.
goreleaser refuses to release from an untagged commit, so a dispatch can only
ever republish a real tag.

The sdks job derived VERSION from the ref name, which is the tag on a push but
the branch on a dispatch. It now asks git which tag the checked-out commit
carries, with --exact-match so an untagged commit fails loudly instead of
publishing under the previous version. That needs the tags, hence fetch-depth.

.gitea/workflows/build.yml

@@ -31,13 +31,16 @@ jobs:
           repository: ${{ env.UPSTREAM_REPO }}
           path: ${{ env.UPSTREAM_DIR }}
           token: ${{ secrets.GITEA_TOKEN }}
+          # Without an explicit ref, checkout asks the API for the default
+          # branch and fails on this Gitea with "not found".
+          ref: main
 
       - uses: actions/setup-go@v5
         with:
           go-version: ${{ env.GO_VERSION }}
-          cache-dependency-path: |
+          # The runner's cache server is unreachable from job containers, so
-            pulumi-dokploy/provider/go.sum
+          # every restore/save hangs until timeout. Re-enable once fixed.
-            pulumi-dokploy/sdk/go.sum
+          cache: false
 
       - uses: actions/setup-node@v4
         with:
@@ -61,9 +64,14 @@ jobs:
         working-directory: pulumi-dokploy
         run: make provider
 
-      # schema.json and bridge-metadata.json are checked in and carry no
+      # schema.json and bridge-metadata.json are checked in, so a diff here
-      # version, so they only change when the mapping does. A diff here means
+      # means someone edited resources.go without re-running `make tfgen`.
-      # someone edited resources.go without re-running `make tfgen`.
+      #
+      # schema.json *does* carry the upstream version, in `packageDescription`,
+      # and this job builds at the Makefile's default VERSION. So the default
+      # has to be bumped in the same commit that regenerates the schema for a
+      # release, or this step fails on a mismatch that has nothing to do with
+      # the mapping. That is exactly how it failed for v0.2.0.
       - name: Fail if the checked-in schema is stale
         working-directory: pulumi-dokploy
         run: git diff --exit-code -- provider/cmd/pulumi-resource-dokploy/schema.json

.gitea/workflows/release.yml

@@ -3,6 +3,12 @@ name: release
 on:
   push:
     tags: ["v*.*.*"]
+  # A release that dies halfway -- the runner OOMs, the host reboots -- leaves
+  # the tag pushed and nothing published, and re-pushing a tag to retry it is
+  # both awkward and destructive. Dispatch re-runs the same release instead.
+  # goreleaser refuses to run unless the checked-out commit is itself tagged,
+  # so this can only ever republish a real tag, never main-in-progress.
+  workflow_dispatch: {}
 
 env:
   GO_VERSION: "1.25.x"
@@ -33,18 +39,31 @@ jobs:
           repository: ${{ env.UPSTREAM_REPO }}
           path: ${{ env.UPSTREAM_DIR }}
           token: ${{ secrets.GITEA_TOKEN }}
+          # checkout's default-branch lookup returns "not found" on this Gitea.
+          ref: main
 
       - uses: actions/setup-go@v5
         with:
           go-version: ${{ env.GO_VERSION }}
+          cache: false
 
+      # A bridged Pulumi provider links the whole Terraform provider plus the
+      # Pulumi SDK into one ~100MB binary, and compiling that is memory-hungry.
+      # goreleaser defaults its parallelism to the CPU count, so several of
+      # those compiles overlap and the runner OOMs -- the v0.2.0 release died
+      # after 31 minutes with `compile: signal: killed` on darwin_amd64.
+      #
+      # Build one target at a time. It is slower in wall-clock but it is the
+      # difference between a release that finishes and one that does not.
+      # GOGC trades some CPU for a lower peak heap in the compiler itself.
       - uses: goreleaser/goreleaser-action@v6
         with:
           version: latest
-          args: release --clean
+          args: release --clean --parallelism 1
           workdir: pulumi-dokploy
         env:
           GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
+          GOGC: "50"
 
   sdks:
     needs: plugin
@@ -53,16 +72,21 @@ jobs:
       - uses: actions/checkout@v4
         with:
           path: pulumi-dokploy
+          # Needed for the tag lookup below.
+          fetch-depth: 0
 
       - uses: actions/checkout@v4
         with:
           repository: ${{ env.UPSTREAM_REPO }}
           path: ${{ env.UPSTREAM_DIR }}
           token: ${{ secrets.GITEA_TOKEN }}
+          # checkout's default-branch lookup returns "not found" on this Gitea.
+          ref: main
 
       - uses: actions/setup-go@v5
         with:
           go-version: ${{ env.GO_VERSION }}
+          cache: false
 
       - uses: actions/setup-node@v4
         with:
@@ -76,8 +100,14 @@ jobs:
         with:
           dotnet-version: ${{ env.DOTNET_VERSION }}
 
+      # On a tag push the ref name is the tag; on a dispatch it is the branch,
+      # so ask git what tag this commit carries. --exact-match keeps a dispatch
+      # from quietly publishing an untagged commit under the previous version.
       - name: Derive version from tag
-        run: echo "VERSION=${GITHUB_REF_NAME#v}" >> "$GITHUB_ENV"
+        working-directory: pulumi-dokploy
+        run: |
+          TAG="$(git describe --tags --exact-match)"
+          echo "VERSION=${TAG#v}" >> "$GITHUB_ENV"
 
       - name: Build SDKs
         working-directory: pulumi-dokploy

.gitignore

@@ -7,6 +7,7 @@
 /sdk/nodejs/node_modules/
 /sdk/dotnet/bin/
 /sdk/dotnet/obj/
+/sdk/dotnet/nupkg/
 /sdk/python/build/
 /sdk/python/dist/
 /sdk/python/*.egg-info/

CHANGELOG.md

@@ -0,0 +1,98 @@
+# Changelog
+
+All notable changes to this provider are documented here.
+
+The format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+This package bridges
+[terraform-provider-dokploy](https://gitea.coolify.vojtkov.dev/usr_unknown/terraform-provider-dokploy);
+its versions track that provider's.
+
+## [0.2.0] — 2026-08-26
+
+Tracks **Dokploy v0.30.x** through terraform-provider-dokploy v0.2.0. Verified
+end-to-end with `pulumi up` against a live v0.30.2 instance.
+
+### Fixed
+
+- **A `Mount` with `type: "volume"` and no `volumeName` is now refused at
+  preview time.** Dokploy accepted such a mount and rendered it for Docker with
+  an empty source, which Docker reads as an *anonymous* volume: every deploy
+  created a new one and orphaned the last, so the data never survived a
+  redeploy while disk usage grew. Nothing errored anywhere along the way.
+
+  `pulumi preview` now fails with an explanation instead:
+
+  ```
+  error: dokploy:index/mount:Mount resource 'data' has a problem:
+  Missing volume_name. `volume_name` must be set to a non-empty value
+  when `type` is `volume`.
+
+  Dokploy passes an unset volume_name to Docker as an empty source, which
+  creates a new anonymous volume on every deploy. …  Examine values at
+  'data.volumeName'.
+  ```
+
+  The same check covers `type: "bind"` without `hostPath` and `type: "file"`
+  without `filePath`. If you already have such a mount, add a `volumeName` and
+  redeploy; the contents of the current anonymous volume are **not** migrated.
+
+- **Resource and property documentation now reaches the generated SDKs.** The
+  bridge was looking for the upstream provider's `docs/` in the Go module
+  cache, where a locally `replace`d dependency never appears, so every resource
+  arrived in TypeScript, Python, Go and .NET with no description at all — the
+  volume warning above included. `UpstreamRepoPath` now points at the upstream
+  checkout, and all 445 resource inputs carry documentation, with property
+  names rendered per language (`volumeName` in TypeScript, `volume_name` in
+  Python).
+
+### Added
+
+New resources, mirroring Dokploy v0.30.0:
+
+- **`Network`** — Docker networks as first-class objects (`bridge` or
+  `overlay`, with `internal`, `attachable`, IPv4/IPv6, `mtu`, custom `ipam`).
+  Attach services with `networkIds`. Docker networks are immutable, so every
+  property forces replacement.
+- **`DnsProvider`** — a Cloudflare or AWS Route53 connection, so adding a
+  domain creates its DNS record.
+- **`VaultProvider`** — environment values resolved at deploy time from
+  HashiCorp Vault/OpenBao, Infisical, AWS Secrets Manager, Doppler, Azure Key
+  Vault or Scaleway, referenced as `${{vault.<scope>.<key>}}`. The secret never
+  reaches Dokploy or your Pulumi state.
+- **`Schedule`** — cron jobs in an application container, a Compose service, a
+  remote server, or on the Dokploy host.
+- **`VolumeBackup`** — scheduled backups of a Docker volume to a `Destination`.
+- **`Libsql`** — the sixth managed database engine.
+
+New properties on existing resources:
+
+- `Domain` gains **`enabled`**, the v0.30.0 toggle that pulls a route out of
+  Traefik while keeping certificates, paths and middleware intact.
+- `Compose` gains `createEnvFile`, `icon` and **`serviceNetworks`**, which
+  attaches individual services in a stack to specific networks.
+- `Application` gains `icon` and `previewRequireCollaboratorPermissions`.
+- `Mount` and `VolumeBackup` accept `libsql` as a `serviceType`.
+
+### Changed
+
+- `networkIds` and `detachDokployNetwork` are the supported way to control
+  service networking. Compose's `isolatedDeployment` is **deprecated upstream**
+  in v0.30.0 — per-service network attachment covers the same ground and
+  survives restarts. The property still works; prefer `networkIds` for new
+  programs.
+
+### Notes
+
+- `config` on `DnsProvider` and `VaultProvider` is masked by Dokploy on read,
+  so Pulumi keeps the value your program supplied and does **not** detect drift
+  in those credentials. Both are marked secret.
+
+## [0.1.0] — 2026-08-09
+
+Initial release: 18 resources and 5 data sources across TypeScript, Python, Go
+and .NET, bridged from terraform-provider-dokploy v0.1.0.
+
+[0.2.0]: https://gitea.coolify.vojtkov.dev/usr_unknown/pulumi-dokploy/releases/tag/v0.2.0
+[0.1.0]: https://gitea.coolify.vojtkov.dev/usr_unknown/pulumi-dokploy/releases/tag/v0.1.0

Makefile

@@ -10,8 +10,12 @@ PROVIDER        := pulumi-resource-$(PACK)
 WORKING_DIR     := $(shell pwd)
 SCHEMA_DIR      := $(WORKING_DIR)/provider/cmd/$(PROVIDER)
 
-# Override on the command line for a release build, e.g. `make build VERSION=0.2.0`.
+# The checked-in schema.json embeds this version in `packageDescription`, and
-VERSION         ?= 0.1.0
+# CI diffs the regenerated schema against it on every push to main. So this
+# default is not cosmetic: it has to match the version the committed schema was
+# generated at, which means bumping it in the same commit as a release.
+# Release builds override it from the tag.
+VERSION         ?= 0.2.0
 LDFLAGS         := -X $(PROJECT)/$(VERSION_PATH)=$(VERSION)
 
 JAVASCRIPT_PKG  := @$(ORG)/pulumi-$(PACK)

README.md

@@ -106,7 +106,7 @@ an `_authToken` in `.npmrc`, `--extra-index-url` with basic auth for pip, and
 Before the first release, build and install it locally instead:
 
 ```bash
-make install VERSION=0.1.0
+make install VERSION=0.2.0
 ```
 
 That drops `pulumi-resource-dokploy` into the local plugin cache, so
@@ -146,13 +146,42 @@ pulumi config set --secret dokploy:apiKey "$DOKPLOY_API_KEY"
 | ------------ | ------------------------------------------------------------------------- |
 | Structure    | `Project`, `Environment`                                                   |
 | Services     | `Application`, `Compose`                                                   |
-| Databases    | `Postgres`, `MySql`, `MariaDb`, `Mongo`, `Redis`                           |
+| Databases    | `Postgres`, `MySql`, `MariaDb`, `Mongo`, `Redis`, `Libsql`                 |
-| Networking   | `Domain`, `Mount`, `Port`, `Redirect`, `Security`                          |
+| Networking   | `Domain`, `Mount`, `Port`, `Redirect`, `Security`, `Network`               |
+| Scheduling   | `Schedule`, `VolumeBackup`                                                 |
+| Integrations | `DnsProvider`, `VaultProvider`                                             |
 | Account      | `Registry`, `SshKey`, `Certificate`, `Destination`                         |
 
 Data sources: `getProject`, `getProjects`, `getEnvironment`, `getApplication`,
 `getServers`.
 
+### Volumes that actually persist
+
+A `Mount` with `type: "volume"` **must** set `volumeName`:
+
+```typescript
+new dokploy.Mount("uploads", {
+    type: "volume",
+    volumeName: "shop-uploads",   // required — see below
+    mountPath: "/app/uploads",
+    serviceType: "application",
+    serviceId: api.id,
+});
+```
+
+Dokploy turns a mount into a Docker mount with
+`{Source: volumeName || "", Target: mountPath}`. With no `volumeName` the
+source is the empty string, which Docker reads as an *anonymous* volume: a new
+one on every deploy, with the previous one orphaned on disk. Nothing errors —
+the service starts and the path is writable — but the data is gone again after
+the next deployment.
+
+Dokploy's API accepts that mount, so this provider rejects it during
+`pulumi preview` instead, along with `type: "bind"` without `hostPath` and
+`type: "file"` without `filePath`.
+
+Pair a named volume with `VolumeBackup` to get it off the host on a schedule.
+
 ## Deploying from CI
 
 Like the Terraform provider, this one manages *configuration*, not *rollouts*.
@@ -240,7 +269,7 @@ Gitea's Go registry, at which point the module resolves through `GOPROXY`:
 export GOPROXY=https://gitea.coolify.vojtkov.dev/api/packages/usr_unknown/go,direct
 export GONOSUMDB='github.com/maxvojtkov/*'
 cd provider && go mod edit -dropreplace github.com/maxvojtkov/terraform-provider-dokploy \
-  && go get github.com/maxvojtkov/terraform-provider-dokploy@v0.1.0
+  && go get github.com/maxvojtkov/terraform-provider-dokploy@v0.2.0
 ```
 
 The upstream provider exposes itself through its `shim` package
@@ -252,7 +281,7 @@ from outside that module.
 Tag the repository and the `release` workflow does the rest:
 
 ```bash
-git tag v0.1.0 && git push origin v0.1.0
+git tag v0.2.0 && git push origin v0.2.0
 ```
 
 GoReleaser publishes the plugin binaries to a Gitea release first — Pulumi

provider/cmd/pulumi-resource-dokploy/bridge-metadata.json

@@ -37,6 +37,9 @@
                     }
                 }
             },
+            "dokploy_dns_provider": {
+                "current": "dokploy:index/dnsProvider:DnsProvider"
+            },
             "dokploy_domain": {
                 "current": "dokploy:index/domain:Domain",
                 "fields": {
@@ -48,6 +51,14 @@
             "dokploy_environment": {
                 "current": "dokploy:index/environment:Environment"
             },
+            "dokploy_libsql": {
+                "current": "dokploy:index/libsql:Libsql",
+                "fields": {
+                    "network_ids": {
+                        "maxItemsOne": false
+                    }
+                }
+            },
             "dokploy_mariadb": {
                 "current": "dokploy:index/mariaDb:MariaDb",
                 "fields": {
@@ -84,6 +95,9 @@
                     }
                 }
             },
+            "dokploy_network": {
+                "current": "dokploy:index/network:Network"
+            },
             "dokploy_port": {
                 "current": "dokploy:index/port:Port"
             },
@@ -118,11 +132,20 @@
             "dokploy_registry": {
                 "current": "dokploy:index/registry:Registry"
             },
+            "dokploy_schedule": {
+                "current": "dokploy:index/schedule:Schedule"
+            },
             "dokploy_security": {
                 "current": "dokploy:index/security:Security"
             },
             "dokploy_ssh_key": {
                 "current": "dokploy:index/sshKey:SshKey"
+            },
+            "dokploy_vault_provider": {
+                "current": "dokploy:index/vaultProvider:VaultProvider"
+            },
+            "dokploy_volume_backup": {
+                "current": "dokploy:index/volumeBackup:VolumeBackup"
             }
         },
         "datasources": {

provider/resources.go

@@ -7,6 +7,7 @@ package dokploy
 
 import (
 	_ "embed"
+	"os"
 
 	pfbridge "github.com/pulumi/pulumi-terraform-bridge/v3/pkg/pf/tfbridge"
 	"github.com/pulumi/pulumi-terraform-bridge/v3/pkg/tfbridge"
@@ -67,6 +68,16 @@ func Provider(version string) tfbridge.ProviderInfo {
 		TFProviderVersion: version,
 		MetadataInfo:      tfbridge.NewProviderMetadata(bridgeMetadata),
 
+		// Where tfgen reads the upstream `docs/` from when generating schema
+		// descriptions. Without it the bridge looks in the Go module cache,
+		// finds nothing for a `replace`d local dependency, and every resource
+		// reaches Pulumi users undocumented -- including the warnings that
+		// matter, such as a volume mount needing a name to persist anything.
+		//
+		// Only read at tfgen time, and the result is baked into the
+		// checked-in schema.json, so a consumer never needs this path.
+		UpstreamRepoPath: upstreamRepoPath(),
+
 		// The upstream provider is plugin-framework based, so opt in to the
 		// bridge's accurate preview and raw state handling.
 		EnableAccurateBridgePreview:   true,
@@ -99,6 +110,7 @@ func Provider(version string) tfbridge.ProviderInfo {
 			"dokploy_mariadb":  res("MariaDb"),
 			"dokploy_mongo":    res("Mongo"),
 			"dokploy_redis":    res("Redis"),
+			"dokploy_libsql":   res("Libsql"),
 
 			// Networking and service attachments.
 			"dokploy_domain":   res("Domain"),
@@ -112,6 +124,18 @@ func Provider(version string) tfbridge.ProviderInfo {
 			"dokploy_ssh_key":     res("SshKey"),
 			"dokploy_certificate": res("Certificate"),
 			"dokploy_destination": res("Destination"),
+
+			// Docker networks, added in Dokploy v0.30.0. Services attach to
+			// them through `networkIds`.
+			"dokploy_network": res("Network"),
+
+			// Scheduling, added in Dokploy v0.30.0.
+			"dokploy_schedule":      res("Schedule"),
+			"dokploy_volume_backup": res("VolumeBackup"),
+
+			// External integrations, added in Dokploy v0.30.0.
+			"dokploy_dns_provider":   res("DnsProvider"),
+			"dokploy_vault_provider": res("VaultProvider"),
 		},
 
 		DataSources: map[string]*tfbridge.DataSourceInfo{
@@ -156,6 +180,16 @@ func Provider(version string) tfbridge.ProviderInfo {
 	return prov
 }
 
+// upstreamRepoPath locates the terraform-provider-dokploy checkout that
+// `go.mod` replaces in. It is overridable so a CI job that lays the two repos
+// out differently can still generate documented schemas.
+func upstreamRepoPath() string {
+	if override := os.Getenv("DOKPLOY_TF_PROVIDER_PATH"); override != "" {
+		return override
+	}
+	return "../dokploy-teraform"
+}
+
 // pythonInfo exists because PyProject is an anonymous struct field and cannot
 // be set inside a composite literal.
 func pythonInfo() *tfbridge.PythonInfo {

sdk/dotnet/Application.cs

@@ -10,6 +10,13 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// A Dokploy application: a single service built from a Git repository, a Docker image, or an uploaded artifact.
+    /// 
+    /// Dokploy's `application.create` endpoint accepts only a handful of fields, so this resource creates the application and then applies the rest of the configuration through `application.update`.
+    /// 
+    /// &gt; Creating this resource does **not** deploy the application. Trigger a deployment from the Dokploy UI, the CLI, or a `TerraformData` provisioner calling `application.deploy`.
+    /// </summary>
     [DokployResourceType("dokploy:index/application:Application")]
     public partial class Application : global::Pulumi.CustomResource
     {
@@ -331,6 +338,12 @@ namespace Maxvojtkov.Dokploy
         [Output("herokuVersion")]
         public Output<string> HerokuVersion { get; private set; } = null!;
 
+        /// <summary>
+        /// Icon shown next to the service in the Dokploy UI.
+        /// </summary>
+        [Output("icon")]
+        public Output<string?> Icon { get; private set; } = null!;
+
         /// <summary>
         /// Build a preview deployment for each pull request.
         /// </summary>
@@ -463,6 +476,12 @@ namespace Maxvojtkov.Dokploy
         [Output("previewPort")]
         public Output<int> PreviewPort { get; private set; } = null!;
 
+        /// <summary>
+        /// Only build previews for pull requests opened by users with repository collaborator permissions.
+        /// </summary>
+        [Output("previewRequireCollaboratorPermissions")]
+        public Output<bool> PreviewRequireCollaboratorPermissions { get; private set; } = null!;
+
         /// <summary>
         /// Wildcard domain used to expose preview deployments.
         /// </summary>
@@ -964,6 +983,12 @@ namespace Maxvojtkov.Dokploy
         [Input("herokuVersion")]
         public Input<string>? HerokuVersion { get; set; }
 
+        /// <summary>
+        /// Icon shown next to the service in the Dokploy UI.
+        /// </summary>
+        [Input("icon")]
+        public Input<string>? Icon { get; set; }
+
         /// <summary>
         /// Build a preview deployment for each pull request.
         /// </summary>
@@ -1128,6 +1153,12 @@ namespace Maxvojtkov.Dokploy
         [Input("previewPort")]
         public Input<int>? PreviewPort { get; set; }
 
+        /// <summary>
+        /// Only build previews for pull requests opened by users with repository collaborator permissions.
+        /// </summary>
+        [Input("previewRequireCollaboratorPermissions")]
+        public Input<bool>? PreviewRequireCollaboratorPermissions { get; set; }
+
         /// <summary>
         /// Wildcard domain used to expose preview deployments.
         /// </summary>
@@ -1602,6 +1633,12 @@ namespace Maxvojtkov.Dokploy
         [Input("herokuVersion")]
         public Input<string>? HerokuVersion { get; set; }
 
+        /// <summary>
+        /// Icon shown next to the service in the Dokploy UI.
+        /// </summary>
+        [Input("icon")]
+        public Input<string>? Icon { get; set; }
+
         /// <summary>
         /// Build a preview deployment for each pull request.
         /// </summary>
@@ -1766,6 +1803,12 @@ namespace Maxvojtkov.Dokploy
         [Input("previewPort")]
         public Input<int>? PreviewPort { get; set; }
 
+        /// <summary>
+        /// Only build previews for pull requests opened by users with repository collaborator permissions.
+        /// </summary>
+        [Input("previewRequireCollaboratorPermissions")]
+        public Input<bool>? PreviewRequireCollaboratorPermissions { get; set; }
+
         /// <summary>
         /// Wildcard domain used to expose preview deployments.
         /// </summary>

sdk/dotnet/Certificate.cs

@@ -10,6 +10,11 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// A TLS certificate uploaded to Dokploy, for domains that use `CertificateType = "custom"`.
+    /// 
+    /// &gt; The private key is stored in Terraform state. Use a state backend with encryption at rest.
+    /// </summary>
     [DokployResourceType("dokploy:index/certificate:Certificate")]
     public partial class Certificate : global::Pulumi.CustomResource
     {

sdk/dotnet/Compose.cs

@@ -10,6 +10,13 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// A Docker Compose or Docker Swarm stack managed by Dokploy.
+    /// 
+    /// Set `ComposeFile` to manage the stack definition inline (with `SourceType = "raw"`), or point the stack at a Git repository and set `ComposePath`.
+    /// 
+    /// &gt; Creating this resource does **not** deploy the stack.
+    /// </summary>
     [DokployResourceType("dokploy:index/compose:Compose")]
     public partial class Compose : global::Pulumi.CustomResource
     {
@@ -91,6 +98,12 @@ namespace Maxvojtkov.Dokploy
         [Output("composeType")]
         public Output<string> ComposeType { get; private set; } = null!;
 
+        /// <summary>
+        /// Write the environment variables to a `.env` file next to the Compose file.
+        /// </summary>
+        [Output("createEnvFile")]
+        public Output<bool> CreateEnvFile { get; private set; } = null!;
+
         /// <summary>
         /// RFC 3339 timestamp of when the stack was created.
         /// </summary>
@@ -211,6 +224,12 @@ namespace Maxvojtkov.Dokploy
         [Output("gitlabRepository")]
         public Output<string?> GitlabRepository { get; private set; } = null!;
 
+        /// <summary>
+        /// Icon shown next to the stack in the Dokploy UI.
+        /// </summary>
+        [Output("icon")]
+        public Output<string?> Icon { get; private set; } = null!;
+
         /// <summary>
         /// Run the stack on its own isolated Docker network.
         /// </summary>
@@ -253,6 +272,12 @@ namespace Maxvojtkov.Dokploy
         [Output("serverId")]
         public Output<string?> ServerId { get; private set; } = null!;
 
+        /// <summary>
+        /// Per-service Docker network attachments, as a JSON object mapping each service name in the stack to an array of network IDs.
+        /// </summary>
+        [Output("serviceNetworks")]
+        public Output<string?> ServiceNetworks { get; private set; } = null!;
+
         /// <summary>
         /// Where the Compose file comes from. Valid values: `Git`, `Github`, `Gitlab`, `Bitbucket`, `Gitea`, `Raw`.
         /// </summary>
@@ -396,6 +421,12 @@ namespace Maxvojtkov.Dokploy
         [Input("composeType")]
         public Input<string>? ComposeType { get; set; }
 
+        /// <summary>
+        /// Write the environment variables to a `.env` file next to the Compose file.
+        /// </summary>
+        [Input("createEnvFile")]
+        public Input<bool>? CreateEnvFile { get; set; }
+
         /// <summary>
         /// Branch to deploy for a custom Git remote.
         /// </summary>
@@ -510,6 +541,12 @@ namespace Maxvojtkov.Dokploy
         [Input("gitlabRepository")]
         public Input<string>? GitlabRepository { get; set; }
 
+        /// <summary>
+        /// Icon shown next to the stack in the Dokploy UI.
+        /// </summary>
+        [Input("icon")]
+        public Input<string>? Icon { get; set; }
+
         /// <summary>
         /// Run the stack on its own isolated Docker network.
         /// </summary>
@@ -552,6 +589,12 @@ namespace Maxvojtkov.Dokploy
         [Input("serverId")]
         public Input<string>? ServerId { get; set; }
 
+        /// <summary>
+        /// Per-service Docker network attachments, as a JSON object mapping each service name in the stack to an array of network IDs.
+        /// </summary>
+        [Input("serviceNetworks")]
+        public Input<string>? ServiceNetworks { get; set; }
+
         /// <summary>
         /// Where the Compose file comes from. Valid values: `Git`, `Github`, `Gitlab`, `Bitbucket`, `Gitea`, `Raw`.
         /// </summary>
@@ -668,6 +711,12 @@ namespace Maxvojtkov.Dokploy
         [Input("composeType")]
         public Input<string>? ComposeType { get; set; }
 
+        /// <summary>
+        /// Write the environment variables to a `.env` file next to the Compose file.
+        /// </summary>
+        [Input("createEnvFile")]
+        public Input<bool>? CreateEnvFile { get; set; }
+
         /// <summary>
         /// RFC 3339 timestamp of when the stack was created.
         /// </summary>
@@ -788,6 +837,12 @@ namespace Maxvojtkov.Dokploy
         [Input("gitlabRepository")]
         public Input<string>? GitlabRepository { get; set; }
 
+        /// <summary>
+        /// Icon shown next to the stack in the Dokploy UI.
+        /// </summary>
+        [Input("icon")]
+        public Input<string>? Icon { get; set; }
+
         /// <summary>
         /// Run the stack on its own isolated Docker network.
         /// </summary>
@@ -830,6 +885,12 @@ namespace Maxvojtkov.Dokploy
         [Input("serverId")]
         public Input<string>? ServerId { get; set; }
 
+        /// <summary>
+        /// Per-service Docker network attachments, as a JSON object mapping each service name in the stack to an array of network IDs.
+        /// </summary>
+        [Input("serviceNetworks")]
+        public Input<string>? ServiceNetworks { get; set; }
+
         /// <summary>
         /// Where the Compose file comes from. Valid values: `Git`, `Github`, `Gitlab`, `Bitbucket`, `Gitea`, `Raw`.
         /// </summary>

sdk/dotnet/Destination.cs

@@ -10,6 +10,11 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// An S3-compatible bucket that Dokploy writes database and volume backups to.
+    /// 
+    /// &gt; The secret access key is stored in Terraform state. Use a state backend with encryption at rest.
+    /// </summary>
     [DokployResourceType("dokploy:index/destination:Destination")]
     public partial class Destination : global::Pulumi.CustomResource
     {

sdk/dotnet/DnsProvider.cs

@@ -0,0 +1,177 @@
+// *** WARNING: this file was generated by pulumi-language-dotnet. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading.Tasks;
+using Pulumi.Serialization;
+using Pulumi;
+
+namespace Maxvojtkov.Dokploy
+{
+    /// <summary>
+    /// A DNS provider connection Dokploy uses to create records for domains automatically.
+    /// 
+    /// `Config` is a JSON object whose shape depends on `providerType`:
+    /// </summary>
+    [DokployResourceType("dokploy:index/dnsProvider:DnsProvider")]
+    public partial class DnsProvider : global::Pulumi.CustomResource
+    {
+        /// <summary>
+        /// Provider credentials as a JSON object, including the `providerType` discriminator.
+        /// </summary>
+        [Output("config")]
+        public Output<string> Config { get; private set; } = null!;
+
+        /// <summary>
+        /// RFC 3339 timestamp of when the connection was created.
+        /// </summary>
+        [Output("createdAt")]
+        public Output<string> CreatedAt { get; private set; } = null!;
+
+        /// <summary>
+        /// Name of the connection. Must be unique within the organization and may contain only letters, digits, `-` and `_`.
+        /// </summary>
+        [Output("name")]
+        public Output<string> Name { get; private set; } = null!;
+
+        /// <summary>
+        /// Organization that owns the connection.
+        /// </summary>
+        [Output("organizationId")]
+        public Output<string> OrganizationId { get; private set; } = null!;
+
+        /// <summary>
+        /// Provider kind derived from `Config`: `Cloudflare` or `Route53`.
+        /// </summary>
+        [Output("providerType")]
+        public Output<string> ProviderType { get; private set; } = null!;
+
+
+        /// <summary>
+        /// Create a DnsProvider resource with the given unique name, arguments, and options.
+        /// </summary>
+        ///
+        /// <param name="name">The unique name of the resource</param>
+        /// <param name="args">The arguments used to populate this resource's properties</param>
+        /// <param name="options">A bag of options that control this resource's behavior</param>
+        public DnsProvider(string name, DnsProviderArgs args, CustomResourceOptions? options = null)
+            : base("dokploy:index/dnsProvider:DnsProvider", name, args ?? new DnsProviderArgs(), MakeResourceOptions(options, ""))
+        {
+        }
+
+        private DnsProvider(string name, Input<string> id, DnsProviderState? state = null, CustomResourceOptions? options = null)
+            : base("dokploy:index/dnsProvider:DnsProvider", name, state, MakeResourceOptions(options, id))
+        {
+        }
+
+        private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input<string>? id)
+        {
+            var defaultOptions = new CustomResourceOptions
+            {
+                Version = Utilities.Version,
+                PluginDownloadURL = "https://gitea.coolify.vojtkov.dev/usr_unknown/pulumi-dokploy/releases/download/v${VERSION}",
+                AdditionalSecretOutputs =
+                {
+                    "config",
+                },
+            };
+            var merged = CustomResourceOptions.Merge(defaultOptions, options);
+            // Override the ID if one was specified for consistency with other language SDKs.
+            merged.Id = id ?? merged.Id;
+            return merged;
+        }
+        /// <summary>
+        /// Get an existing DnsProvider resource's state with the given name, ID, and optional extra
+        /// properties used to qualify the lookup.
+        /// </summary>
+        ///
+        /// <param name="name">The unique name of the resulting resource.</param>
+        /// <param name="id">The unique provider ID of the resource to lookup.</param>
+        /// <param name="state">Any extra arguments used during the lookup.</param>
+        /// <param name="options">A bag of options that control this resource's behavior</param>
+        public static DnsProvider Get(string name, Input<string> id, DnsProviderState? state = null, CustomResourceOptions? options = null)
+        {
+            return new DnsProvider(name, id, state, options);
+        }
+    }
+
+    public sealed class DnsProviderArgs : global::Pulumi.ResourceArgs
+    {
+        [Input("config", required: true)]
+        private Input<string>? _config;
+
+        /// <summary>
+        /// Provider credentials as a JSON object, including the `providerType` discriminator.
+        /// </summary>
+        public Input<string>? Config
+        {
+            get => _config;
+            set
+            {
+                var emptySecret = Output.CreateSecret(0);
+                _config = Output.Tuple<Input<string>?, int>(value, emptySecret).Apply(t => t.Item1);
+            }
+        }
+
+        /// <summary>
+        /// Name of the connection. Must be unique within the organization and may contain only letters, digits, `-` and `_`.
+        /// </summary>
+        [Input("name")]
+        public Input<string>? Name { get; set; }
+
+        public DnsProviderArgs()
+        {
+        }
+        public static new DnsProviderArgs Empty => new DnsProviderArgs();
+    }
+
+    public sealed class DnsProviderState : global::Pulumi.ResourceArgs
+    {
+        [Input("config")]
+        private Input<string>? _config;
+
+        /// <summary>
+        /// Provider credentials as a JSON object, including the `providerType` discriminator.
+        /// </summary>
+        public Input<string>? Config
+        {
+            get => _config;
+            set
+            {
+                var emptySecret = Output.CreateSecret(0);
+                _config = Output.Tuple<Input<string>?, int>(value, emptySecret).Apply(t => t.Item1);
+            }
+        }
+
+        /// <summary>
+        /// RFC 3339 timestamp of when the connection was created.
+        /// </summary>
+        [Input("createdAt")]
+        public Input<string>? CreatedAt { get; set; }
+
+        /// <summary>
+        /// Name of the connection. Must be unique within the organization and may contain only letters, digits, `-` and `_`.
+        /// </summary>
+        [Input("name")]
+        public Input<string>? Name { get; set; }
+
+        /// <summary>
+        /// Organization that owns the connection.
+        /// </summary>
+        [Input("organizationId")]
+        public Input<string>? OrganizationId { get; set; }
+
+        /// <summary>
+        /// Provider kind derived from `Config`: `Cloudflare` or `Route53`.
+        /// </summary>
+        [Input("providerType")]
+        public Input<string>? ProviderType { get; set; }
+
+        public DnsProviderState()
+        {
+        }
+        public static new DnsProviderState Empty => new DnsProviderState();
+    }
+}

sdk/dotnet/Domain.cs

@@ -10,6 +10,11 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// A domain routed to an application or a Compose service through Dokploy's Traefik instance.
+    /// 
+    /// Set exactly one of `ApplicationId` or `ComposeId`. When targeting a Compose stack, `ServiceName` selects which service in the stack receives the traffic.
+    /// </summary>
     [DokployResourceType("dokploy:index/domain:Domain")]
     public partial class Domain : global::Pulumi.CustomResource
     {
@@ -55,6 +60,12 @@ namespace Maxvojtkov.Dokploy
         [Output("domainType")]
         public Output<string> DomainType { get; private set; } = null!;
 
+        /// <summary>
+        /// Whether the domain is served. Setting this to `False` removes the route from Traefik but keeps the certificate, path and middleware configuration intact, so the domain can be brought back without reconfiguring it.
+        /// </summary>
+        [Output("enabled")]
+        public Output<bool> Enabled { get; private set; } = null!;
+
         /// <summary>
         /// Protect this domain with Dokploy's forward auth.
         /// </summary>
@@ -198,6 +209,12 @@ namespace Maxvojtkov.Dokploy
         [Input("domainType")]
         public Input<string>? DomainType { get; set; }
 
+        /// <summary>
+        /// Whether the domain is served. Setting this to `False` removes the route from Traefik but keeps the certificate, path and middleware configuration intact, so the domain can be brought back without reconfiguring it.
+        /// </summary>
+        [Input("enabled")]
+        public Input<bool>? Enabled { get; set; }
+
         /// <summary>
         /// Protect this domain with Dokploy's forward auth.
         /// </summary>
@@ -314,6 +331,12 @@ namespace Maxvojtkov.Dokploy
         [Input("domainType")]
         public Input<string>? DomainType { get; set; }
 
+        /// <summary>
+        /// Whether the domain is served. Setting this to `False` removes the route from Traefik but keeps the certificate, path and middleware configuration intact, so the domain can be brought back without reconfiguring it.
+        /// </summary>
+        [Input("enabled")]
+        public Input<bool>? Enabled { get; set; }
+
         /// <summary>
         /// Protect this domain with Dokploy's forward auth.
         /// </summary>

sdk/dotnet/Environment.cs

@@ -10,6 +10,11 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// An environment inside a Dokploy project, such as `Staging` or `Production`. Services belong to an environment rather than directly to a project.
+    /// 
+    /// Dokploy creates a default `Production` environment with every project; reference it via `dokploy_project.&lt;name&gt;.default_environment_id` instead of declaring it here.
+    /// </summary>
     [DokployResourceType("dokploy:index/environment:Environment")]
     public partial class Environment : global::Pulumi.CustomResource
     {

sdk/dotnet/GetApplication.cs

@@ -12,12 +12,21 @@ namespace Maxvojtkov.Dokploy
 {
     public static class GetApplication
     {
+        /// <summary>
+        /// Look up an existing application by ID.
+        /// </summary>
         public static Task<GetApplicationResult> InvokeAsync(GetApplicationArgs args, InvokeOptions? options = null)
             => global::Pulumi.Deployment.Instance.InvokeAsync<GetApplicationResult>("dokploy:index/getApplication:getApplication", args ?? new GetApplicationArgs(), options.WithDefaults());
 
+        /// <summary>
+        /// Look up an existing application by ID.
+        /// </summary>
         public static Output<GetApplicationResult> Invoke(GetApplicationInvokeArgs args, InvokeOptions? options = null)
             => global::Pulumi.Deployment.Instance.Invoke<GetApplicationResult>("dokploy:index/getApplication:getApplication", args ?? new GetApplicationInvokeArgs(), options.WithDefaults());
 
+        /// <summary>
+        /// Look up an existing application by ID.
+        /// </summary>
         public static Output<GetApplicationResult> Invoke(GetApplicationInvokeArgs args, InvokeOutputOptions options)
             => global::Pulumi.Deployment.Instance.Invoke<GetApplicationResult>("dokploy:index/getApplication:getApplication", args ?? new GetApplicationInvokeArgs(), options.WithDefaults());
     }
@@ -25,6 +34,9 @@ namespace Maxvojtkov.Dokploy
 
     public sealed class GetApplicationArgs : global::Pulumi.InvokeArgs
     {
+        /// <summary>
+        /// Application identifier.
+        /// </summary>
         [Input("id", required: true)]
         public string Id { get; set; } = null!;
 
@@ -36,6 +48,9 @@ namespace Maxvojtkov.Dokploy
 
     public sealed class GetApplicationInvokeArgs : global::Pulumi.InvokeArgs
     {
+        /// <summary>
+        /// Application identifier.
+        /// </summary>
         [Input("id", required: true)]
         public Input<string> Id { get; set; } = null!;
 
@@ -49,14 +64,41 @@ namespace Maxvojtkov.Dokploy
     [OutputType]
     public sealed class GetApplicationResult
     {
+        /// <summary>
+        /// Docker service name.
+        /// </summary>
         public readonly string AppName;
+        /// <summary>
+        /// Current status.
+        /// </summary>
         public readonly string ApplicationStatus;
+        /// <summary>
+        /// Build strategy.
+        /// </summary>
         public readonly string BuildType;
+        /// <summary>
+        /// Creation timestamp.
+        /// </summary>
         public readonly string CreatedAt;
+        /// <summary>
+        /// Application description.
+        /// </summary>
         public readonly string Description;
+        /// <summary>
+        /// Owning environment.
+        /// </summary>
         public readonly string EnvironmentId;
+        /// <summary>
+        /// Application identifier.
+        /// </summary>
         public readonly string Id;
+        /// <summary>
+        /// Application name.
+        /// </summary>
         public readonly string Name;
+        /// <summary>
+        /// Source of the code or image.
+        /// </summary>
         public readonly string SourceType;
 
         [OutputConstructor]

sdk/dotnet/GetEnvironment.cs

@@ -12,12 +12,21 @@ namespace Maxvojtkov.Dokploy
 {
     public static class GetEnvironment
     {
+        /// <summary>
+        /// Look up an existing environment by ID.
+        /// </summary>
         public static Task<GetEnvironmentResult> InvokeAsync(GetEnvironmentArgs args, InvokeOptions? options = null)
             => global::Pulumi.Deployment.Instance.InvokeAsync<GetEnvironmentResult>("dokploy:index/getEnvironment:getEnvironment", args ?? new GetEnvironmentArgs(), options.WithDefaults());
 
+        /// <summary>
+        /// Look up an existing environment by ID.
+        /// </summary>
         public static Output<GetEnvironmentResult> Invoke(GetEnvironmentInvokeArgs args, InvokeOptions? options = null)
             => global::Pulumi.Deployment.Instance.Invoke<GetEnvironmentResult>("dokploy:index/getEnvironment:getEnvironment", args ?? new GetEnvironmentInvokeArgs(), options.WithDefaults());
 
+        /// <summary>
+        /// Look up an existing environment by ID.
+        /// </summary>
         public static Output<GetEnvironmentResult> Invoke(GetEnvironmentInvokeArgs args, InvokeOutputOptions options)
             => global::Pulumi.Deployment.Instance.Invoke<GetEnvironmentResult>("dokploy:index/getEnvironment:getEnvironment", args ?? new GetEnvironmentInvokeArgs(), options.WithDefaults());
     }
@@ -25,6 +34,9 @@ namespace Maxvojtkov.Dokploy
 
     public sealed class GetEnvironmentArgs : global::Pulumi.InvokeArgs
     {
+        /// <summary>
+        /// Environment identifier.
+        /// </summary>
         [Input("id", required: true)]
         public string Id { get; set; } = null!;
 
@@ -36,6 +48,9 @@ namespace Maxvojtkov.Dokploy
 
     public sealed class GetEnvironmentInvokeArgs : global::Pulumi.InvokeArgs
     {
+        /// <summary>
+        /// Environment identifier.
+        /// </summary>
         [Input("id", required: true)]
         public Input<string> Id { get; set; } = null!;
 
@@ -49,12 +64,33 @@ namespace Maxvojtkov.Dokploy
     [OutputType]
     public sealed class GetEnvironmentResult
     {
+        /// <summary>
+        /// Creation timestamp.
+        /// </summary>
         public readonly string CreatedAt;
+        /// <summary>
+        /// Environment description.
+        /// </summary>
         public readonly string Description;
+        /// <summary>
+        /// Environment-wide variables.
+        /// </summary>
         public readonly string Env;
+        /// <summary>
+        /// Environment identifier.
+        /// </summary>
         public readonly string Id;
+        /// <summary>
+        /// Whether this is the project's default environment.
+        /// </summary>
         public readonly bool IsDefault;
+        /// <summary>
+        /// Environment name.
+        /// </summary>
         public readonly string Name;
+        /// <summary>
+        /// Owning project.
+        /// </summary>
         public readonly string ProjectId;
 
         [OutputConstructor]

sdk/dotnet/GetProject.cs

@@ -12,12 +12,21 @@ namespace Maxvojtkov.Dokploy
 {
     public static class GetProject
     {
+        /// <summary>
+        /// Look up an existing Dokploy project by ID, including its environments.
+        /// </summary>
         public static Task<GetProjectResult> InvokeAsync(GetProjectArgs args, InvokeOptions? options = null)
             => global::Pulumi.Deployment.Instance.InvokeAsync<GetProjectResult>("dokploy:index/getProject:getProject", args ?? new GetProjectArgs(), options.WithDefaults());
 
+        /// <summary>
+        /// Look up an existing Dokploy project by ID, including its environments.
+        /// </summary>
         public static Output<GetProjectResult> Invoke(GetProjectInvokeArgs args, InvokeOptions? options = null)
             => global::Pulumi.Deployment.Instance.Invoke<GetProjectResult>("dokploy:index/getProject:getProject", args ?? new GetProjectInvokeArgs(), options.WithDefaults());
 
+        /// <summary>
+        /// Look up an existing Dokploy project by ID, including its environments.
+        /// </summary>
         public static Output<GetProjectResult> Invoke(GetProjectInvokeArgs args, InvokeOutputOptions options)
             => global::Pulumi.Deployment.Instance.Invoke<GetProjectResult>("dokploy:index/getProject:getProject", args ?? new GetProjectInvokeArgs(), options.WithDefaults());
     }
@@ -25,6 +34,9 @@ namespace Maxvojtkov.Dokploy
 
     public sealed class GetProjectArgs : global::Pulumi.InvokeArgs
     {
+        /// <summary>
+        /// Project identifier.
+        /// </summary>
         [Input("id", required: true)]
         public string Id { get; set; } = null!;
 
@@ -36,6 +48,9 @@ namespace Maxvojtkov.Dokploy
 
     public sealed class GetProjectInvokeArgs : global::Pulumi.InvokeArgs
     {
+        /// <summary>
+        /// Project identifier.
+        /// </summary>
         [Input("id", required: true)]
         public Input<string> Id { get; set; } = null!;
 
@@ -49,13 +64,37 @@ namespace Maxvojtkov.Dokploy
     [OutputType]
     public sealed class GetProjectResult
     {
+        /// <summary>
+        /// Creation timestamp.
+        /// </summary>
         public readonly string CreatedAt;
+        /// <summary>
+        /// ID of the project's default environment.
+        /// </summary>
         public readonly string DefaultEnvironmentId;
+        /// <summary>
+        /// Project description.
+        /// </summary>
         public readonly string Description;
+        /// <summary>
+        /// Project-wide environment variables.
+        /// </summary>
         public readonly string Env;
+        /// <summary>
+        /// Every environment in the project.
+        /// </summary>
         public readonly ImmutableArray<Outputs.GetProjectEnvironmentResult> Environments;
+        /// <summary>
+        /// Project identifier.
+        /// </summary>
         public readonly string Id;
+        /// <summary>
+        /// Project name.
+        /// </summary>
         public readonly string Name;
+        /// <summary>
+        /// Owning organization.
+        /// </summary>
         public readonly string OrganizationId;
 
         [OutputConstructor]

sdk/dotnet/GetProjects.cs

@@ -12,12 +12,21 @@ namespace Maxvojtkov.Dokploy
 {
     public static class GetProjects
     {
+        /// <summary>
+        /// List every Dokploy project the API token can see.
+        /// </summary>
         public static Task<GetProjectsResult> InvokeAsync(InvokeOptions? options = null)
             => global::Pulumi.Deployment.Instance.InvokeAsync<GetProjectsResult>("dokploy:index/getProjects:getProjects", InvokeArgs.Empty, options.WithDefaults());
 
+        /// <summary>
+        /// List every Dokploy project the API token can see.
+        /// </summary>
         public static Output<GetProjectsResult> Invoke(InvokeOptions? options = null)
             => global::Pulumi.Deployment.Instance.Invoke<GetProjectsResult>("dokploy:index/getProjects:getProjects", InvokeArgs.Empty, options.WithDefaults());
 
+        /// <summary>
+        /// List every Dokploy project the API token can see.
+        /// </summary>
         public static Output<GetProjectsResult> Invoke(InvokeOutputOptions options)
             => global::Pulumi.Deployment.Instance.Invoke<GetProjectsResult>("dokploy:index/getProjects:getProjects", InvokeArgs.Empty, options.WithDefaults());
     }
@@ -26,6 +35,9 @@ namespace Maxvojtkov.Dokploy
     [OutputType]
     public sealed class GetProjectsResult
     {
+        /// <summary>
+        /// All visible projects.
+        /// </summary>
         public readonly ImmutableArray<Outputs.GetProjectsProjectResult> Projects;
 
         [OutputConstructor]

sdk/dotnet/GetServers.cs

@@ -12,12 +12,21 @@ namespace Maxvojtkov.Dokploy
 {
     public static class GetServers
     {
+        /// <summary>
+        /// List the remote servers registered with Dokploy. Use a server's `Id` as the `ServerId` of an application, stack, or database to deploy it away from the Dokploy host.
+        /// </summary>
         public static Task<GetServersResult> InvokeAsync(InvokeOptions? options = null)
             => global::Pulumi.Deployment.Instance.InvokeAsync<GetServersResult>("dokploy:index/getServers:getServers", InvokeArgs.Empty, options.WithDefaults());
 
+        /// <summary>
+        /// List the remote servers registered with Dokploy. Use a server's `Id` as the `ServerId` of an application, stack, or database to deploy it away from the Dokploy host.
+        /// </summary>
         public static Output<GetServersResult> Invoke(InvokeOptions? options = null)
             => global::Pulumi.Deployment.Instance.Invoke<GetServersResult>("dokploy:index/getServers:getServers", InvokeArgs.Empty, options.WithDefaults());
 
+        /// <summary>
+        /// List the remote servers registered with Dokploy. Use a server's `Id` as the `ServerId` of an application, stack, or database to deploy it away from the Dokploy host.
+        /// </summary>
         public static Output<GetServersResult> Invoke(InvokeOutputOptions options)
             => global::Pulumi.Deployment.Instance.Invoke<GetServersResult>("dokploy:index/getServers:getServers", InvokeArgs.Empty, options.WithDefaults());
     }
@@ -26,6 +35,9 @@ namespace Maxvojtkov.Dokploy
     [OutputType]
     public sealed class GetServersResult
     {
+        /// <summary>
+        /// All registered servers.
+        /// </summary>
         public readonly ImmutableArray<Outputs.GetServersServerResult> Servers;
 
         [OutputConstructor]

sdk/dotnet/Libsql.cs

@@ -0,0 +1,739 @@
+// *** WARNING: this file was generated by pulumi-language-dotnet. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading.Tasks;
+using Pulumi.Serialization;
+using Pulumi;
+
+namespace Maxvojtkov.Dokploy
+{
+    /// <summary>
+    /// A managed libSQL instance running on Dokploy.
+    /// 
+    /// &gt; Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+    /// 
+    /// &gt; Credentials are stored in Terraform state. Use a state backend with encryption at rest.
+    /// 
+    /// libSQL runs as a `Sqld` server. A `Primary` node owns the data; a `Replica` node follows a primary named by `SqldPrimaryUrl`.
+    /// </summary>
+    [DokployResourceType("dokploy:index/libsql:Libsql")]
+    public partial class Libsql : global::Pulumi.CustomResource
+    {
+        /// <summary>
+        /// Unique Docker service name. Generated from `Name` when omitted, because Dokploy's libSQL endpoint does not generate one. Changing it forces a new database.
+        /// </summary>
+        [Output("appName")]
+        public Output<string> AppName { get; private set; } = null!;
+
+        /// <summary>
+        /// Current status reported by Dokploy: `Idle`, `Running`, `Done` or `Error`.
+        /// </summary>
+        [Output("applicationStatus")]
+        public Output<string> ApplicationStatus { get; private set; } = null!;
+
+        /// <summary>
+        /// Override the container entrypoint command.
+        /// </summary>
+        [Output("command")]
+        public Output<string?> Command { get; private set; } = null!;
+
+        /// <summary>
+        /// Hard CPU limit, for example `1`.
+        /// </summary>
+        [Output("cpuLimit")]
+        public Output<string?> CpuLimit { get; private set; } = null!;
+
+        /// <summary>
+        /// Soft CPU reservation, for example `0.5`.
+        /// </summary>
+        [Output("cpuReservation")]
+        public Output<string?> CpuReservation { get; private set; } = null!;
+
+        /// <summary>
+        /// RFC 3339 timestamp of when the database was created.
+        /// </summary>
+        [Output("createdAt")]
+        public Output<string> CreatedAt { get; private set; } = null!;
+
+        /// <summary>
+        /// Password for the database user.
+        /// </summary>
+        [Output("databasePassword")]
+        public Output<string> DatabasePassword { get; private set; } = null!;
+
+        /// <summary>
+        /// Database user to create.
+        /// </summary>
+        [Output("databaseUser")]
+        public Output<string> DatabaseUser { get; private set; } = null!;
+
+        /// <summary>
+        /// Free-form description.
+        /// </summary>
+        [Output("description")]
+        public Output<string?> Description { get; private set; } = null!;
+
+        /// <summary>
+        /// Detach the service from the shared `dokploy-network`.
+        /// </summary>
+        [Output("detachDokployNetwork")]
+        public Output<bool> DetachDokployNetwork { get; private set; } = null!;
+
+        /// <summary>
+        /// libSQL server image to run, for example `ghcr.io/tursodatabase/libsql-server:latest`.
+        /// </summary>
+        [Output("dockerImage")]
+        public Output<string> DockerImage { get; private set; } = null!;
+
+        /// <summary>
+        /// Serve multiple logical databases from one instance through libSQL namespaces.
+        /// </summary>
+        [Output("enableNamespaces")]
+        public Output<bool> EnableNamespaces { get; private set; } = null!;
+
+        /// <summary>
+        /// Docker Swarm endpoint specification, as a JSON object.
+        /// </summary>
+        [Output("endpointSpecSwarm")]
+        public Output<string?> EndpointSpecSwarm { get; private set; } = null!;
+
+        /// <summary>
+        /// Environment variables in `KEY=value` format, one per line.
+        /// </summary>
+        [Output("env")]
+        public Output<string?> Env { get; private set; } = null!;
+
+        /// <summary>
+        /// Environment this database belongs to.
+        /// </summary>
+        [Output("environmentId")]
+        public Output<string> EnvironmentId { get; private set; } = null!;
+
+        /// <summary>
+        /// Host port exposing the admin API.
+        /// </summary>
+        [Output("externalAdminPort")]
+        public Output<int?> ExternalAdminPort { get; private set; } = null!;
+
+        /// <summary>
+        /// Host port exposing the gRPC replication endpoint.
+        /// </summary>
+        [Output("externalGrpcPort")]
+        public Output<int?> ExternalGrpcPort { get; private set; } = null!;
+
+        /// <summary>
+        /// Host port exposing the HTTP API.
+        /// </summary>
+        [Output("externalPort")]
+        public Output<int?> ExternalPort { get; private set; } = null!;
+
+        /// <summary>
+        /// Docker Swarm health check configuration, as a JSON object.
+        /// </summary>
+        [Output("healthCheckSwarm")]
+        public Output<string?> HealthCheckSwarm { get; private set; } = null!;
+
+        /// <summary>
+        /// Docker Swarm service labels, as a JSON object.
+        /// </summary>
+        [Output("labelsSwarm")]
+        public Output<string?> LabelsSwarm { get; private set; } = null!;
+
+        /// <summary>
+        /// Hard memory limit, for example `512m`.
+        /// </summary>
+        [Output("memoryLimit")]
+        public Output<string?> MemoryLimit { get; private set; } = null!;
+
+        /// <summary>
+        /// Soft memory reservation, for example `256m`.
+        /// </summary>
+        [Output("memoryReservation")]
+        public Output<string?> MemoryReservation { get; private set; } = null!;
+
+        /// <summary>
+        /// Docker Swarm service mode, as a JSON object.
+        /// </summary>
+        [Output("modeSwarm")]
+        public Output<string?> ModeSwarm { get; private set; } = null!;
+
+        /// <summary>
+        /// Display name of the database.
+        /// </summary>
+        [Output("name")]
+        public Output<string> Name { get; private set; } = null!;
+
+        /// <summary>
+        /// IDs of additional Docker networks to attach.
+        /// </summary>
+        [Output("networkIds")]
+        public Output<ImmutableArray<string>> NetworkIds { get; private set; } = null!;
+
+        /// <summary>
+        /// Docker Swarm network attachments, as a JSON array.
+        /// </summary>
+        [Output("networkSwarm")]
+        public Output<string?> NetworkSwarm { get; private set; } = null!;
+
+        /// <summary>
+        /// Docker Swarm placement constraints, as a JSON object.
+        /// </summary>
+        [Output("placementSwarm")]
+        public Output<string?> PlacementSwarm { get; private set; } = null!;
+
+        /// <summary>
+        /// Number of replicas to run.
+        /// </summary>
+        [Output("replicas")]
+        public Output<int> Replicas { get; private set; } = null!;
+
+        /// <summary>
+        /// Docker Swarm restart policy, as a JSON object.
+        /// </summary>
+        [Output("restartPolicySwarm")]
+        public Output<string?> RestartPolicySwarm { get; private set; } = null!;
+
+        /// <summary>
+        /// Docker Swarm rollback configuration, as a JSON object.
+        /// </summary>
+        [Output("rollbackConfigSwarm")]
+        public Output<string?> RollbackConfigSwarm { get; private set; } = null!;
+
+        /// <summary>
+        /// Remote server to deploy on. Omit to use the Dokploy host itself.
+        /// </summary>
+        [Output("serverId")]
+        public Output<string?> ServerId { get; private set; } = null!;
+
+        /// <summary>
+        /// Role this node plays in a libSQL cluster. Valid values: `Primary`, `Replica`. Defaults to `Primary`.
+        /// </summary>
+        [Output("sqldNode")]
+        public Output<string> SqldNode { get; private set; } = null!;
+
+        /// <summary>
+        /// URL of the primary node, when `SqldNode` is `Replica`.
+        /// </summary>
+        [Output("sqldPrimaryUrl")]
+        public Output<string?> SqldPrimaryUrl { get; private set; } = null!;
+
+        /// <summary>
+        /// Grace period in nanoseconds before a container is killed.
+        /// </summary>
+        [Output("stopGracePeriodSwarm")]
+        public Output<int?> StopGracePeriodSwarm { get; private set; } = null!;
+
+        /// <summary>
+        /// Docker Swarm rolling update configuration, as a JSON object.
+        /// </summary>
+        [Output("updateConfigSwarm")]
+        public Output<string?> UpdateConfigSwarm { get; private set; } = null!;
+
+
+        /// <summary>
+        /// Create a Libsql resource with the given unique name, arguments, and options.
+        /// </summary>
+        ///
+        /// <param name="name">The unique name of the resource</param>
+        /// <param name="args">The arguments used to populate this resource's properties</param>
+        /// <param name="options">A bag of options that control this resource's behavior</param>
+        public Libsql(string name, LibsqlArgs args, CustomResourceOptions? options = null)
+            : base("dokploy:index/libsql:Libsql", name, args ?? new LibsqlArgs(), MakeResourceOptions(options, ""))
+        {
+        }
+
+        private Libsql(string name, Input<string> id, LibsqlState? state = null, CustomResourceOptions? options = null)
+            : base("dokploy:index/libsql:Libsql", name, state, MakeResourceOptions(options, id))
+        {
+        }
+
+        private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input<string>? id)
+        {
+            var defaultOptions = new CustomResourceOptions
+            {
+                Version = Utilities.Version,
+                PluginDownloadURL = "https://gitea.coolify.vojtkov.dev/usr_unknown/pulumi-dokploy/releases/download/v${VERSION}",
+                AdditionalSecretOutputs =
+                {
+                    "databasePassword",
+                },
+            };
+            var merged = CustomResourceOptions.Merge(defaultOptions, options);
+            // Override the ID if one was specified for consistency with other language SDKs.
+            merged.Id = id ?? merged.Id;
+            return merged;
+        }
+        /// <summary>
+        /// Get an existing Libsql resource's state with the given name, ID, and optional extra
+        /// properties used to qualify the lookup.
+        /// </summary>
+        ///
+        /// <param name="name">The unique name of the resulting resource.</param>
+        /// <param name="id">The unique provider ID of the resource to lookup.</param>
+        /// <param name="state">Any extra arguments used during the lookup.</param>
+        /// <param name="options">A bag of options that control this resource's behavior</param>
+        public static Libsql Get(string name, Input<string> id, LibsqlState? state = null, CustomResourceOptions? options = null)
+        {
+            return new Libsql(name, id, state, options);
+        }
+    }
+
+    public sealed class LibsqlArgs : global::Pulumi.ResourceArgs
+    {
+        /// <summary>
+        /// Unique Docker service name. Generated from `Name` when omitted, because Dokploy's libSQL endpoint does not generate one. Changing it forces a new database.
+        /// </summary>
+        [Input("appName")]
+        public Input<string>? AppName { get; set; }
+
+        /// <summary>
+        /// Override the container entrypoint command.
+        /// </summary>
+        [Input("command")]
+        public Input<string>? Command { get; set; }
+
+        /// <summary>
+        /// Hard CPU limit, for example `1`.
+        /// </summary>
+        [Input("cpuLimit")]
+        public Input<string>? CpuLimit { get; set; }
+
+        /// <summary>
+        /// Soft CPU reservation, for example `0.5`.
+        /// </summary>
+        [Input("cpuReservation")]
+        public Input<string>? CpuReservation { get; set; }
+
+        [Input("databasePassword", required: true)]
+        private Input<string>? _databasePassword;
+
+        /// <summary>
+        /// Password for the database user.
+        /// </summary>
+        public Input<string>? DatabasePassword
+        {
+            get => _databasePassword;
+            set
+            {
+                var emptySecret = Output.CreateSecret(0);
+                _databasePassword = Output.Tuple<Input<string>?, int>(value, emptySecret).Apply(t => t.Item1);
+            }
+        }
+
+        /// <summary>
+        /// Database user to create.
+        /// </summary>
+        [Input("databaseUser", required: true)]
+        public Input<string> DatabaseUser { get; set; } = null!;
+
+        /// <summary>
+        /// Free-form description.
+        /// </summary>
+        [Input("description")]
+        public Input<string>? Description { get; set; }
+
+        /// <summary>
+        /// Detach the service from the shared `dokploy-network`.
+        /// </summary>
+        [Input("detachDokployNetwork")]
+        public Input<bool>? DetachDokployNetwork { get; set; }
+
+        /// <summary>
+        /// libSQL server image to run, for example `ghcr.io/tursodatabase/libsql-server:latest`.
+        /// </summary>
+        [Input("dockerImage", required: true)]
+        public Input<string> DockerImage { get; set; } = null!;
+
+        /// <summary>
+        /// Serve multiple logical databases from one instance through libSQL namespaces.
+        /// </summary>
+        [Input("enableNamespaces")]
+        public Input<bool>? EnableNamespaces { get; set; }
+
+        /// <summary>
+        /// Docker Swarm endpoint specification, as a JSON object.
+        /// </summary>
+        [Input("endpointSpecSwarm")]
+        public Input<string>? EndpointSpecSwarm { get; set; }
+
+        /// <summary>
+        /// Environment variables in `KEY=value` format, one per line.
+        /// </summary>
+        [Input("env")]
+        public Input<string>? Env { get; set; }
+
+        /// <summary>
+        /// Environment this database belongs to.
+        /// </summary>
+        [Input("environmentId", required: true)]
+        public Input<string> EnvironmentId { get; set; } = null!;
+
+        /// <summary>
+        /// Host port exposing the admin API.
+        /// </summary>
+        [Input("externalAdminPort")]
+        public Input<int>? ExternalAdminPort { get; set; }
+
+        /// <summary>
+        /// Host port exposing the gRPC replication endpoint.
+        /// </summary>
+        [Input("externalGrpcPort")]
+        public Input<int>? ExternalGrpcPort { get; set; }
+
+        /// <summary>
+        /// Host port exposing the HTTP API.
+        /// </summary>
+        [Input("externalPort")]
+        public Input<int>? ExternalPort { get; set; }
+
+        /// <summary>
+        /// Docker Swarm health check configuration, as a JSON object.
+        /// </summary>
+        [Input("healthCheckSwarm")]
+        public Input<string>? HealthCheckSwarm { get; set; }
+
+        /// <summary>
+        /// Docker Swarm service labels, as a JSON object.
+        /// </summary>
+        [Input("labelsSwarm")]
+        public Input<string>? LabelsSwarm { get; set; }
+
+        /// <summary>
+        /// Hard memory limit, for example `512m`.
+        /// </summary>
+        [Input("memoryLimit")]
+        public Input<string>? MemoryLimit { get; set; }
+
+        /// <summary>
+        /// Soft memory reservation, for example `256m`.
+        /// </summary>
+        [Input("memoryReservation")]
+        public Input<string>? MemoryReservation { get; set; }
+
+        /// <summary>
+        /// Docker Swarm service mode, as a JSON object.
+        /// </summary>
+        [Input("modeSwarm")]
+        public Input<string>? ModeSwarm { get; set; }
+
+        /// <summary>
+        /// Display name of the database.
+        /// </summary>
+        [Input("name")]
+        public Input<string>? Name { get; set; }
+
+        [Input("networkIds")]
+        private InputList<string>? _networkIds;
+
+        /// <summary>
+        /// IDs of additional Docker networks to attach.
+        /// </summary>
+        public InputList<string> NetworkIds
+        {
+            get => _networkIds ?? (_networkIds = new InputList<string>());
+            set => _networkIds = value;
+        }
+
+        /// <summary>
+        /// Docker Swarm network attachments, as a JSON array.
+        /// </summary>
+        [Input("networkSwarm")]
+        public Input<string>? NetworkSwarm { get; set; }
+
+        /// <summary>
+        /// Docker Swarm placement constraints, as a JSON object.
+        /// </summary>
+        [Input("placementSwarm")]
+        public Input<string>? PlacementSwarm { get; set; }
+
+        /// <summary>
+        /// Number of replicas to run.
+        /// </summary>
+        [Input("replicas")]
+        public Input<int>? Replicas { get; set; }
+
+        /// <summary>
+        /// Docker Swarm restart policy, as a JSON object.
+        /// </summary>
+        [Input("restartPolicySwarm")]
+        public Input<string>? RestartPolicySwarm { get; set; }
+
+        /// <summary>
+        /// Docker Swarm rollback configuration, as a JSON object.
+        /// </summary>
+        [Input("rollbackConfigSwarm")]
+        public Input<string>? RollbackConfigSwarm { get; set; }
+
+        /// <summary>
+        /// Remote server to deploy on. Omit to use the Dokploy host itself.
+        /// </summary>
+        [Input("serverId")]
+        public Input<string>? ServerId { get; set; }
+
+        /// <summary>
+        /// Role this node plays in a libSQL cluster. Valid values: `Primary`, `Replica`. Defaults to `Primary`.
+        /// </summary>
+        [Input("sqldNode")]
+        public Input<string>? SqldNode { get; set; }
+
+        /// <summary>
+        /// URL of the primary node, when `SqldNode` is `Replica`.
+        /// </summary>
+        [Input("sqldPrimaryUrl")]
+        public Input<string>? SqldPrimaryUrl { get; set; }
+
+        /// <summary>
+        /// Grace period in nanoseconds before a container is killed.
+        /// </summary>
+        [Input("stopGracePeriodSwarm")]
+        public Input<int>? StopGracePeriodSwarm { get; set; }
+
+        /// <summary>
+        /// Docker Swarm rolling update configuration, as a JSON object.
+        /// </summary>
+        [Input("updateConfigSwarm")]
+        public Input<string>? UpdateConfigSwarm { get; set; }
+
+        public LibsqlArgs()
+        {
+        }
+        public static new LibsqlArgs Empty => new LibsqlArgs();
+    }
+
+    public sealed class LibsqlState : global::Pulumi.ResourceArgs
+    {
+        /// <summary>
+        /// Unique Docker service name. Generated from `Name` when omitted, because Dokploy's libSQL endpoint does not generate one. Changing it forces a new database.
+        /// </summary>
+        [Input("appName")]
+        public Input<string>? AppName { get; set; }
+
+        /// <summary>
+        /// Current status reported by Dokploy: `Idle`, `Running`, `Done` or `Error`.
+        /// </summary>
+        [Input("applicationStatus")]
+        public Input<string>? ApplicationStatus { get; set; }
+
+        /// <summary>
+        /// Override the container entrypoint command.
+        /// </summary>
+        [Input("command")]
+        public Input<string>? Command { get; set; }
+
+        /// <summary>
+        /// Hard CPU limit, for example `1`.
+        /// </summary>
+        [Input("cpuLimit")]
+        public Input<string>? CpuLimit { get; set; }
+
+        /// <summary>
+        /// Soft CPU reservation, for example `0.5`.
+        /// </summary>
+        [Input("cpuReservation")]
+        public Input<string>? CpuReservation { get; set; }
+
+        /// <summary>
+        /// RFC 3339 timestamp of when the database was created.
+        /// </summary>
+        [Input("createdAt")]
+        public Input<string>? CreatedAt { get; set; }
+
+        [Input("databasePassword")]
+        private Input<string>? _databasePassword;
+
+        /// <summary>
+        /// Password for the database user.
+        /// </summary>
+        public Input<string>? DatabasePassword
+        {
+            get => _databasePassword;
+            set
+            {
+                var emptySecret = Output.CreateSecret(0);
+                _databasePassword = Output.Tuple<Input<string>?, int>(value, emptySecret).Apply(t => t.Item1);
+            }
+        }
+
+        /// <summary>
+        /// Database user to create.
+        /// </summary>
+        [Input("databaseUser")]
+        public Input<string>? DatabaseUser { get; set; }
+
+        /// <summary>
+        /// Free-form description.
+        /// </summary>
+        [Input("description")]
+        public Input<string>? Description { get; set; }
+
+        /// <summary>
+        /// Detach the service from the shared `dokploy-network`.
+        /// </summary>
+        [Input("detachDokployNetwork")]
+        public Input<bool>? DetachDokployNetwork { get; set; }
+
+        /// <summary>
+        /// libSQL server image to run, for example `ghcr.io/tursodatabase/libsql-server:latest`.
+        /// </summary>
+        [Input("dockerImage")]
+        public Input<string>? DockerImage { get; set; }
+
+        /// <summary>
+        /// Serve multiple logical databases from one instance through libSQL namespaces.
+        /// </summary>
+        [Input("enableNamespaces")]
+        public Input<bool>? EnableNamespaces { get; set; }
+
+        /// <summary>
+        /// Docker Swarm endpoint specification, as a JSON object.
+        /// </summary>
+        [Input("endpointSpecSwarm")]
+        public Input<string>? EndpointSpecSwarm { get; set; }
+
+        /// <summary>
+        /// Environment variables in `KEY=value` format, one per line.
+        /// </summary>
+        [Input("env")]
+        public Input<string>? Env { get; set; }
+
+        /// <summary>
+        /// Environment this database belongs to.
+        /// </summary>
+        [Input("environmentId")]
+        public Input<string>? EnvironmentId { get; set; }
+
+        /// <summary>
+        /// Host port exposing the admin API.
+        /// </summary>
+        [Input("externalAdminPort")]
+        public Input<int>? ExternalAdminPort { get; set; }
+
+        /// <summary>
+        /// Host port exposing the gRPC replication endpoint.
+        /// </summary>
+        [Input("externalGrpcPort")]
+        public Input<int>? ExternalGrpcPort { get; set; }
+
+        /// <summary>
+        /// Host port exposing the HTTP API.
+        /// </summary>
+        [Input("externalPort")]
+        public Input<int>? ExternalPort { get; set; }
+
+        /// <summary>
+        /// Docker Swarm health check configuration, as a JSON object.
+        /// </summary>
+        [Input("healthCheckSwarm")]
+        public Input<string>? HealthCheckSwarm { get; set; }
+
+        /// <summary>
+        /// Docker Swarm service labels, as a JSON object.
+        /// </summary>
+        [Input("labelsSwarm")]
+        public Input<string>? LabelsSwarm { get; set; }
+
+        /// <summary>
+        /// Hard memory limit, for example `512m`.
+        /// </summary>
+        [Input("memoryLimit")]
+        public Input<string>? MemoryLimit { get; set; }
+
+        /// <summary>
+        /// Soft memory reservation, for example `256m`.
+        /// </summary>
+        [Input("memoryReservation")]
+        public Input<string>? MemoryReservation { get; set; }
+
+        /// <summary>
+        /// Docker Swarm service mode, as a JSON object.
+        /// </summary>
+        [Input("modeSwarm")]
+        public Input<string>? ModeSwarm { get; set; }
+
+        /// <summary>
+        /// Display name of the database.
+        /// </summary>
+        [Input("name")]
+        public Input<string>? Name { get; set; }
+
+        [Input("networkIds")]
+        private InputList<string>? _networkIds;
+
+        /// <summary>
+        /// IDs of additional Docker networks to attach.
+        /// </summary>
+        public InputList<string> NetworkIds
+        {
+            get => _networkIds ?? (_networkIds = new InputList<string>());
+            set => _networkIds = value;
+        }
+
+        /// <summary>
+        /// Docker Swarm network attachments, as a JSON array.
+        /// </summary>
+        [Input("networkSwarm")]
+        public Input<string>? NetworkSwarm { get; set; }
+
+        /// <summary>
+        /// Docker Swarm placement constraints, as a JSON object.
+        /// </summary>
+        [Input("placementSwarm")]
+        public Input<string>? PlacementSwarm { get; set; }
+
+        /// <summary>
+        /// Number of replicas to run.
+        /// </summary>
+        [Input("replicas")]
+        public Input<int>? Replicas { get; set; }
+
+        /// <summary>
+        /// Docker Swarm restart policy, as a JSON object.
+        /// </summary>
+        [Input("restartPolicySwarm")]
+        public Input<string>? RestartPolicySwarm { get; set; }
+
+        /// <summary>
+        /// Docker Swarm rollback configuration, as a JSON object.
+        /// </summary>
+        [Input("rollbackConfigSwarm")]
+        public Input<string>? RollbackConfigSwarm { get; set; }
+
+        /// <summary>
+        /// Remote server to deploy on. Omit to use the Dokploy host itself.
+        /// </summary>
+        [Input("serverId")]
+        public Input<string>? ServerId { get; set; }
+
+        /// <summary>
+        /// Role this node plays in a libSQL cluster. Valid values: `Primary`, `Replica`. Defaults to `Primary`.
+        /// </summary>
+        [Input("sqldNode")]
+        public Input<string>? SqldNode { get; set; }
+
+        /// <summary>
+        /// URL of the primary node, when `SqldNode` is `Replica`.
+        /// </summary>
+        [Input("sqldPrimaryUrl")]
+        public Input<string>? SqldPrimaryUrl { get; set; }
+
+        /// <summary>
+        /// Grace period in nanoseconds before a container is killed.
+        /// </summary>
+        [Input("stopGracePeriodSwarm")]
+        public Input<int>? StopGracePeriodSwarm { get; set; }
+
+        /// <summary>
+        /// Docker Swarm rolling update configuration, as a JSON object.
+        /// </summary>
+        [Input("updateConfigSwarm")]
+        public Input<string>? UpdateConfigSwarm { get; set; }
+
+        public LibsqlState()
+        {
+        }
+        public static new LibsqlState Empty => new LibsqlState();
+    }
+}

sdk/dotnet/MariaDb.cs

@@ -10,6 +10,13 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// A managed MariaDB instance running on Dokploy.
+    /// 
+    /// &gt; Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+    /// 
+    /// &gt; Credentials are stored in Terraform state. Use a state backend with encryption at rest.
+    /// </summary>
     [DokployResourceType("dokploy:index/mariaDb:MariaDb")]
     public partial class MariaDb : global::Pulumi.CustomResource
     {

sdk/dotnet/Maxvojtkov.Dokploy.csproj

@@ -9,7 +9,7 @@
     <PackageProjectUrl>https://gitea.coolify.vojtkov.dev/usr_unknown/pulumi-dokploy</PackageProjectUrl>
     <RepositoryUrl>https://gitea.coolify.vojtkov.dev/usr_unknown/pulumi-dokploy</RepositoryUrl>
     <PackageIcon>logo.png</PackageIcon>
-    <Version>0.1.0</Version>
+    <Version>0.2.0</Version>
 
     <TargetFramework>net6.0</TargetFramework>
     <Nullable>enable</Nullable>

sdk/dotnet/Mongo.cs

@@ -10,6 +10,13 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// A managed MongoDB instance running on Dokploy.
+    /// 
+    /// &gt; Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+    /// 
+    /// &gt; Credentials are stored in Terraform state. Use a state backend with encryption at rest.
+    /// </summary>
     [DokployResourceType("dokploy:index/mongo:Mongo")]
     public partial class Mongo : global::Pulumi.CustomResource
     {

sdk/dotnet/Mount.cs

@@ -10,6 +10,15 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// A volume, bind mount, or config file attached to a Dokploy service.
+    /// 
+    /// * `type = "volume"` — a named Docker volume; set `VolumeName`.
+    /// * `type = "bind"` — a path on the host; set `HostPath`.
+    /// * `type = "file"` — a file rendered from `Content`; set `FilePath`.
+    /// 
+    /// &gt; **A `Volume` mount must set `VolumeName`.** Dokploy hands an unset name to Docker as an empty source, which creates a fresh anonymous volume on every deploy and orphans the previous one — the data never survives a redeploy. The provider rejects that combination at plan time.
+    /// </summary>
     [DokployResourceType("dokploy:index/mount:Mount")]
     public partial class Mount : global::Pulumi.CustomResource
     {
@@ -44,7 +53,7 @@ namespace Maxvojtkov.Dokploy
         public Output<string> ServiceId { get; private set; } = null!;
 
         /// <summary>
-        /// The kind of service this mount attaches to. Valid values: `Application`, `Postgres`, `Mysql`, `Mariadb`, `Mongo`, `Redis`, `Compose`.
+        /// The kind of service this mount attaches to. Valid values: `Application`, `Postgres`, `Mysql`, `Mariadb`, `Mongo`, `Redis`, `Compose`, `Libsql`.
         /// </summary>
         [Output("serviceType")]
         public Output<string> ServiceType { get; private set; } = null!;
@@ -139,7 +148,7 @@ namespace Maxvojtkov.Dokploy
         public Input<string> ServiceId { get; set; } = null!;
 
         /// <summary>
-        /// The kind of service this mount attaches to. Valid values: `Application`, `Postgres`, `Mysql`, `Mariadb`, `Mongo`, `Redis`, `Compose`.
+        /// The kind of service this mount attaches to. Valid values: `Application`, `Postgres`, `Mysql`, `Mariadb`, `Mongo`, `Redis`, `Compose`, `Libsql`.
         /// </summary>
         [Input("serviceType", required: true)]
         public Input<string> ServiceType { get; set; } = null!;
@@ -195,7 +204,7 @@ namespace Maxvojtkov.Dokploy
         public Input<string>? ServiceId { get; set; }
 
         /// <summary>
-        /// The kind of service this mount attaches to. Valid values: `Application`, `Postgres`, `Mysql`, `Mariadb`, `Mongo`, `Redis`, `Compose`.
+        /// The kind of service this mount attaches to. Valid values: `Application`, `Postgres`, `Mysql`, `Mariadb`, `Mongo`, `Redis`, `Compose`, `Libsql`.
         /// </summary>
         [Input("serviceType")]
         public Input<string>? ServiceType { get; set; }

sdk/dotnet/MySql.cs

@@ -10,6 +10,13 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// A managed MySQL instance running on Dokploy.
+    /// 
+    /// &gt; Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+    /// 
+    /// &gt; Credentials are stored in Terraform state. Use a state backend with encryption at rest.
+    /// </summary>
     [DokployResourceType("dokploy:index/mySql:MySql")]
     public partial class MySql : global::Pulumi.CustomResource
     {

sdk/dotnet/Network.cs

@@ -0,0 +1,269 @@
+// *** WARNING: this file was generated by pulumi-language-dotnet. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading.Tasks;
+using Pulumi.Serialization;
+using Pulumi;
+
+namespace Maxvojtkov.Dokploy
+{
+    /// <summary>
+    /// A Docker network managed by Dokploy.
+    /// 
+    /// Attach services to it with `NetworkIds` on `dokploy.Application`, `dokploy.Compose` and the database resources. Every service also joins the shared `dokploy-network` unless `DetachDokployNetwork` is set.
+    /// 
+    /// &gt; Docker networks are immutable. Dokploy has no update endpoint, so changing any attribute replaces the network — which detaches the services currently using it until they redeploy.
+    /// </summary>
+    [DokployResourceType("dokploy:index/network:Network")]
+    public partial class Network : global::Pulumi.CustomResource
+    {
+        /// <summary>
+        /// Allow standalone containers to attach to an overlay network.
+        /// </summary>
+        [Output("attachable")]
+        public Output<bool> Attachable { get; private set; } = null!;
+
+        /// <summary>
+        /// RFC 3339 timestamp of when the network was created.
+        /// </summary>
+        [Output("createdAt")]
+        public Output<string> CreatedAt { get; private set; } = null!;
+
+        /// <summary>
+        /// Network driver. Use `Overlay` for multi-node Swarm clusters and `Bridge` for a single host. Valid values: `Bridge`, `Overlay`.
+        /// </summary>
+        [Output("driver")]
+        public Output<string> Driver { get; private set; } = null!;
+
+        /// <summary>
+        /// Enable IPv4 address allocation.
+        /// </summary>
+        [Output("enableIpv4")]
+        public Output<bool> EnableIpv4 { get; private set; } = null!;
+
+        /// <summary>
+        /// Enable IPv6 address allocation.
+        /// </summary>
+        [Output("enableIpv6")]
+        public Output<bool> EnableIpv6 { get; private set; } = null!;
+
+        /// <summary>
+        /// Isolate the network from external access.
+        /// </summary>
+        [Output("internal")]
+        public Output<bool> Internal { get; private set; } = null!;
+
+        /// <summary>
+        /// Custom IP address management, as a JSON object with `Subnet`, `Gateway` and `ipRange` keys. Leave unset to let Docker choose a subnet.
+        /// </summary>
+        [Output("ipam")]
+        public Output<string?> Ipam { get; private set; } = null!;
+
+        /// <summary>
+        /// Maximum transmission unit for the network. Leave unset to use Docker's default.
+        /// </summary>
+        [Output("mtu")]
+        public Output<int?> Mtu { get; private set; } = null!;
+
+        /// <summary>
+        /// Name of the Docker network.
+        /// </summary>
+        [Output("name")]
+        public Output<string> Name { get; private set; } = null!;
+
+        /// <summary>
+        /// Organization that owns the network.
+        /// </summary>
+        [Output("organizationId")]
+        public Output<string> OrganizationId { get; private set; } = null!;
+
+        /// <summary>
+        /// Remote server to create the network on. Omit to use the Dokploy host itself.
+        /// </summary>
+        [Output("serverId")]
+        public Output<string?> ServerId { get; private set; } = null!;
+
+
+        /// <summary>
+        /// Create a Network resource with the given unique name, arguments, and options.
+        /// </summary>
+        ///
+        /// <param name="name">The unique name of the resource</param>
+        /// <param name="args">The arguments used to populate this resource's properties</param>
+        /// <param name="options">A bag of options that control this resource's behavior</param>
+        public Network(string name, NetworkArgs? args = null, CustomResourceOptions? options = null)
+            : base("dokploy:index/network:Network", name, args ?? new NetworkArgs(), MakeResourceOptions(options, ""))
+        {
+        }
+
+        private Network(string name, Input<string> id, NetworkState? state = null, CustomResourceOptions? options = null)
+            : base("dokploy:index/network:Network", name, state, MakeResourceOptions(options, id))
+        {
+        }
+
+        private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input<string>? id)
+        {
+            var defaultOptions = new CustomResourceOptions
+            {
+                Version = Utilities.Version,
+                PluginDownloadURL = "https://gitea.coolify.vojtkov.dev/usr_unknown/pulumi-dokploy/releases/download/v${VERSION}",
+            };
+            var merged = CustomResourceOptions.Merge(defaultOptions, options);
+            // Override the ID if one was specified for consistency with other language SDKs.
+            merged.Id = id ?? merged.Id;
+            return merged;
+        }
+        /// <summary>
+        /// Get an existing Network resource's state with the given name, ID, and optional extra
+        /// properties used to qualify the lookup.
+        /// </summary>
+        ///
+        /// <param name="name">The unique name of the resulting resource.</param>
+        /// <param name="id">The unique provider ID of the resource to lookup.</param>
+        /// <param name="state">Any extra arguments used during the lookup.</param>
+        /// <param name="options">A bag of options that control this resource's behavior</param>
+        public static Network Get(string name, Input<string> id, NetworkState? state = null, CustomResourceOptions? options = null)
+        {
+            return new Network(name, id, state, options);
+        }
+    }
+
+    public sealed class NetworkArgs : global::Pulumi.ResourceArgs
+    {
+        /// <summary>
+        /// Allow standalone containers to attach to an overlay network.
+        /// </summary>
+        [Input("attachable")]
+        public Input<bool>? Attachable { get; set; }
+
+        /// <summary>
+        /// Network driver. Use `Overlay` for multi-node Swarm clusters and `Bridge` for a single host. Valid values: `Bridge`, `Overlay`.
+        /// </summary>
+        [Input("driver")]
+        public Input<string>? Driver { get; set; }
+
+        /// <summary>
+        /// Enable IPv4 address allocation.
+        /// </summary>
+        [Input("enableIpv4")]
+        public Input<bool>? EnableIpv4 { get; set; }
+
+        /// <summary>
+        /// Enable IPv6 address allocation.
+        /// </summary>
+        [Input("enableIpv6")]
+        public Input<bool>? EnableIpv6 { get; set; }
+
+        /// <summary>
+        /// Isolate the network from external access.
+        /// </summary>
+        [Input("internal")]
+        public Input<bool>? Internal { get; set; }
+
+        /// <summary>
+        /// Custom IP address management, as a JSON object with `Subnet`, `Gateway` and `ipRange` keys. Leave unset to let Docker choose a subnet.
+        /// </summary>
+        [Input("ipam")]
+        public Input<string>? Ipam { get; set; }
+
+        /// <summary>
+        /// Maximum transmission unit for the network. Leave unset to use Docker's default.
+        /// </summary>
+        [Input("mtu")]
+        public Input<int>? Mtu { get; set; }
+
+        /// <summary>
+        /// Name of the Docker network.
+        /// </summary>
+        [Input("name")]
+        public Input<string>? Name { get; set; }
+
+        /// <summary>
+        /// Remote server to create the network on. Omit to use the Dokploy host itself.
+        /// </summary>
+        [Input("serverId")]
+        public Input<string>? ServerId { get; set; }
+
+        public NetworkArgs()
+        {
+        }
+        public static new NetworkArgs Empty => new NetworkArgs();
+    }
+
+    public sealed class NetworkState : global::Pulumi.ResourceArgs
+    {
+        /// <summary>
+        /// Allow standalone containers to attach to an overlay network.
+        /// </summary>
+        [Input("attachable")]
+        public Input<bool>? Attachable { get; set; }
+
+        /// <summary>
+        /// RFC 3339 timestamp of when the network was created.
+        /// </summary>
+        [Input("createdAt")]
+        public Input<string>? CreatedAt { get; set; }
+
+        /// <summary>
+        /// Network driver. Use `Overlay` for multi-node Swarm clusters and `Bridge` for a single host. Valid values: `Bridge`, `Overlay`.
+        /// </summary>
+        [Input("driver")]
+        public Input<string>? Driver { get; set; }
+
+        /// <summary>
+        /// Enable IPv4 address allocation.
+        /// </summary>
+        [Input("enableIpv4")]
+        public Input<bool>? EnableIpv4 { get; set; }
+
+        /// <summary>
+        /// Enable IPv6 address allocation.
+        /// </summary>
+        [Input("enableIpv6")]
+        public Input<bool>? EnableIpv6 { get; set; }
+
+        /// <summary>
+        /// Isolate the network from external access.
+        /// </summary>
+        [Input("internal")]
+        public Input<bool>? Internal { get; set; }
+
+        /// <summary>
+        /// Custom IP address management, as a JSON object with `Subnet`, `Gateway` and `ipRange` keys. Leave unset to let Docker choose a subnet.
+        /// </summary>
+        [Input("ipam")]
+        public Input<string>? Ipam { get; set; }
+
+        /// <summary>
+        /// Maximum transmission unit for the network. Leave unset to use Docker's default.
+        /// </summary>
+        [Input("mtu")]
+        public Input<int>? Mtu { get; set; }
+
+        /// <summary>
+        /// Name of the Docker network.
+        /// </summary>
+        [Input("name")]
+        public Input<string>? Name { get; set; }
+
+        /// <summary>
+        /// Organization that owns the network.
+        /// </summary>
+        [Input("organizationId")]
+        public Input<string>? OrganizationId { get; set; }
+
+        /// <summary>
+        /// Remote server to create the network on. Omit to use the Dokploy host itself.
+        /// </summary>
+        [Input("serverId")]
+        public Input<string>? ServerId { get; set; }
+
+        public NetworkState()
+        {
+        }
+        public static new NetworkState Empty => new NetworkState();
+    }
+}

sdk/dotnet/Port.cs

@@ -10,6 +10,9 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// A published port that exposes an application directly on the host, bypassing Traefik.
+    /// </summary>
     [DokployResourceType("dokploy:index/port:Port")]
     public partial class Port : global::Pulumi.CustomResource
     {

sdk/dotnet/Postgres.cs

@@ -10,6 +10,13 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// A managed PostgreSQL instance running on Dokploy.
+    /// 
+    /// &gt; Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+    /// 
+    /// &gt; Credentials are stored in Terraform state. Use a state backend with encryption at rest.
+    /// </summary>
     [DokployResourceType("dokploy:index/postgres:Postgres")]
     public partial class Postgres : global::Pulumi.CustomResource
     {

sdk/dotnet/Project.cs

@@ -10,6 +10,11 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// A Dokploy project: the top-level container for environments and services.
+    /// 
+    /// Creating a project automatically creates a default `Production` environment. Its ID is exposed as `DefaultEnvironmentId`, so services can be attached without declaring a separate `dokploy.Environment` resource.
+    /// </summary>
     [DokployResourceType("dokploy:index/project:Project")]
     public partial class Project : global::Pulumi.CustomResource
     {

sdk/dotnet/Redirect.cs

@@ -10,6 +10,9 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// A Traefik redirect rule attached to an application.
+    /// </summary>
     [DokployResourceType("dokploy:index/redirect:Redirect")]
     public partial class Redirect : global::Pulumi.CustomResource
     {

sdk/dotnet/Redis.cs

@@ -10,6 +10,13 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// A managed Redis instance running on Dokploy.
+    /// 
+    /// &gt; Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+    /// 
+    /// &gt; Credentials are stored in Terraform state. Use a state backend with encryption at rest.
+    /// </summary>
     [DokployResourceType("dokploy:index/redis:Redis")]
     public partial class Redis : global::Pulumi.CustomResource
     {

sdk/dotnet/Registry.cs

@@ -10,6 +10,9 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// A container registry that Dokploy pushes built images to and pulls them from.
+    /// </summary>
     [DokployResourceType("dokploy:index/registry:Registry")]
     public partial class Registry : global::Pulumi.CustomResource
     {

sdk/dotnet/Schedule.cs

@@ -0,0 +1,352 @@
+// *** WARNING: this file was generated by pulumi-language-dotnet. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading.Tasks;
+using Pulumi.Serialization;
+using Pulumi;
+
+namespace Maxvojtkov.Dokploy
+{
+    /// <summary>
+    /// A cron job Dokploy runs on a schedule.
+    /// 
+    /// `ScheduleType` selects where the command runs:
+    /// 
+    /// * `Application` — inside a running application container; set `ApplicationId`.
+    /// * `Compose` — inside one service of a Compose stack; set `ComposeId` and `ServiceName`.
+    /// * `Server` — on a remote server; set `ServerId`.
+    /// * `dokploy-server` — on the Dokploy host itself.
+    /// 
+    /// &gt; A schedule targeting an application runs inside its container, so the container has to be running when the cron fires.
+    /// </summary>
+    [DokployResourceType("dokploy:index/schedule:Schedule")]
+    public partial class Schedule : global::Pulumi.CustomResource
+    {
+        /// <summary>
+        /// Docker service name the schedule targets. Derived by Dokploy when omitted.
+        /// </summary>
+        [Output("appName")]
+        public Output<string> AppName { get; private set; } = null!;
+
+        /// <summary>
+        /// Application this schedule belongs to.
+        /// </summary>
+        [Output("applicationId")]
+        public Output<string?> ApplicationId { get; private set; } = null!;
+
+        /// <summary>
+        /// Command to run.
+        /// </summary>
+        [Output("command")]
+        public Output<string> Command { get; private set; } = null!;
+
+        /// <summary>
+        /// Compose stack this schedule belongs to.
+        /// </summary>
+        [Output("composeId")]
+        public Output<string?> ComposeId { get; private set; } = null!;
+
+        /// <summary>
+        /// RFC 3339 timestamp of when the schedule was created.
+        /// </summary>
+        [Output("createdAt")]
+        public Output<string> CreatedAt { get; private set; } = null!;
+
+        /// <summary>
+        /// Standard five-field cron expression, for example `0 3 * * *`.
+        /// </summary>
+        [Output("cronExpression")]
+        public Output<string> CronExpression { get; private set; } = null!;
+
+        /// <summary>
+        /// Free-form description.
+        /// </summary>
+        [Output("description")]
+        public Output<string?> Description { get; private set; } = null!;
+
+        /// <summary>
+        /// Whether the schedule is active.
+        /// </summary>
+        [Output("enabled")]
+        public Output<bool> Enabled { get; private set; } = null!;
+
+        /// <summary>
+        /// Display name of the schedule.
+        /// </summary>
+        [Output("name")]
+        public Output<string> Name { get; private set; } = null!;
+
+        /// <summary>
+        /// Where the command runs. Valid values: `Application`, `Compose`, `Server`, `dokploy-server`. Defaults to `Application`.
+        /// </summary>
+        [Output("scheduleType")]
+        public Output<string> ScheduleType { get; private set; } = null!;
+
+        /// <summary>
+        /// Multi-line script to run instead of a single command.
+        /// </summary>
+        [Output("script")]
+        public Output<string?> Script { get; private set; } = null!;
+
+        /// <summary>
+        /// Server this schedule runs on.
+        /// </summary>
+        [Output("serverId")]
+        public Output<string?> ServerId { get; private set; } = null!;
+
+        /// <summary>
+        /// Service inside a Compose stack to run the command in.
+        /// </summary>
+        [Output("serviceName")]
+        public Output<string?> ServiceName { get; private set; } = null!;
+
+        /// <summary>
+        /// Shell used to interpret the command. Valid values: `Bash`, `Sh`. Defaults to `Bash`.
+        /// </summary>
+        [Output("shellType")]
+        public Output<string> ShellType { get; private set; } = null!;
+
+        /// <summary>
+        /// IANA timezone the cron expression is evaluated in, for example `Europe/Berlin`.
+        /// </summary>
+        [Output("timezone")]
+        public Output<string?> Timezone { get; private set; } = null!;
+
+
+        /// <summary>
+        /// Create a Schedule resource with the given unique name, arguments, and options.
+        /// </summary>
+        ///
+        /// <param name="name">The unique name of the resource</param>
+        /// <param name="args">The arguments used to populate this resource's properties</param>
+        /// <param name="options">A bag of options that control this resource's behavior</param>
+        public Schedule(string name, ScheduleArgs args, CustomResourceOptions? options = null)
+            : base("dokploy:index/schedule:Schedule", name, args ?? new ScheduleArgs(), MakeResourceOptions(options, ""))
+        {
+        }
+
+        private Schedule(string name, Input<string> id, ScheduleState? state = null, CustomResourceOptions? options = null)
+            : base("dokploy:index/schedule:Schedule", name, state, MakeResourceOptions(options, id))
+        {
+        }
+
+        private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input<string>? id)
+        {
+            var defaultOptions = new CustomResourceOptions
+            {
+                Version = Utilities.Version,
+                PluginDownloadURL = "https://gitea.coolify.vojtkov.dev/usr_unknown/pulumi-dokploy/releases/download/v${VERSION}",
+            };
+            var merged = CustomResourceOptions.Merge(defaultOptions, options);
+            // Override the ID if one was specified for consistency with other language SDKs.
+            merged.Id = id ?? merged.Id;
+            return merged;
+        }
+        /// <summary>
+        /// Get an existing Schedule resource's state with the given name, ID, and optional extra
+        /// properties used to qualify the lookup.
+        /// </summary>
+        ///
+        /// <param name="name">The unique name of the resulting resource.</param>
+        /// <param name="id">The unique provider ID of the resource to lookup.</param>
+        /// <param name="state">Any extra arguments used during the lookup.</param>
+        /// <param name="options">A bag of options that control this resource's behavior</param>
+        public static Schedule Get(string name, Input<string> id, ScheduleState? state = null, CustomResourceOptions? options = null)
+        {
+            return new Schedule(name, id, state, options);
+        }
+    }
+
+    public sealed class ScheduleArgs : global::Pulumi.ResourceArgs
+    {
+        /// <summary>
+        /// Docker service name the schedule targets. Derived by Dokploy when omitted.
+        /// </summary>
+        [Input("appName")]
+        public Input<string>? AppName { get; set; }
+
+        /// <summary>
+        /// Application this schedule belongs to.
+        /// </summary>
+        [Input("applicationId")]
+        public Input<string>? ApplicationId { get; set; }
+
+        /// <summary>
+        /// Command to run.
+        /// </summary>
+        [Input("command", required: true)]
+        public Input<string> Command { get; set; } = null!;
+
+        /// <summary>
+        /// Compose stack this schedule belongs to.
+        /// </summary>
+        [Input("composeId")]
+        public Input<string>? ComposeId { get; set; }
+
+        /// <summary>
+        /// Standard five-field cron expression, for example `0 3 * * *`.
+        /// </summary>
+        [Input("cronExpression", required: true)]
+        public Input<string> CronExpression { get; set; } = null!;
+
+        /// <summary>
+        /// Free-form description.
+        /// </summary>
+        [Input("description")]
+        public Input<string>? Description { get; set; }
+
+        /// <summary>
+        /// Whether the schedule is active.
+        /// </summary>
+        [Input("enabled")]
+        public Input<bool>? Enabled { get; set; }
+
+        /// <summary>
+        /// Display name of the schedule.
+        /// </summary>
+        [Input("name")]
+        public Input<string>? Name { get; set; }
+
+        /// <summary>
+        /// Where the command runs. Valid values: `Application`, `Compose`, `Server`, `dokploy-server`. Defaults to `Application`.
+        /// </summary>
+        [Input("scheduleType")]
+        public Input<string>? ScheduleType { get; set; }
+
+        /// <summary>
+        /// Multi-line script to run instead of a single command.
+        /// </summary>
+        [Input("script")]
+        public Input<string>? Script { get; set; }
+
+        /// <summary>
+        /// Server this schedule runs on.
+        /// </summary>
+        [Input("serverId")]
+        public Input<string>? ServerId { get; set; }
+
+        /// <summary>
+        /// Service inside a Compose stack to run the command in.
+        /// </summary>
+        [Input("serviceName")]
+        public Input<string>? ServiceName { get; set; }
+
+        /// <summary>
+        /// Shell used to interpret the command. Valid values: `Bash`, `Sh`. Defaults to `Bash`.
+        /// </summary>
+        [Input("shellType")]
+        public Input<string>? ShellType { get; set; }
+
+        /// <summary>
+        /// IANA timezone the cron expression is evaluated in, for example `Europe/Berlin`.
+        /// </summary>
+        [Input("timezone")]
+        public Input<string>? Timezone { get; set; }
+
+        public ScheduleArgs()
+        {
+        }
+        public static new ScheduleArgs Empty => new ScheduleArgs();
+    }
+
+    public sealed class ScheduleState : global::Pulumi.ResourceArgs
+    {
+        /// <summary>
+        /// Docker service name the schedule targets. Derived by Dokploy when omitted.
+        /// </summary>
+        [Input("appName")]
+        public Input<string>? AppName { get; set; }
+
+        /// <summary>
+        /// Application this schedule belongs to.
+        /// </summary>
+        [Input("applicationId")]
+        public Input<string>? ApplicationId { get; set; }
+
+        /// <summary>
+        /// Command to run.
+        /// </summary>
+        [Input("command")]
+        public Input<string>? Command { get; set; }
+
+        /// <summary>
+        /// Compose stack this schedule belongs to.
+        /// </summary>
+        [Input("composeId")]
+        public Input<string>? ComposeId { get; set; }
+
+        /// <summary>
+        /// RFC 3339 timestamp of when the schedule was created.
+        /// </summary>
+        [Input("createdAt")]
+        public Input<string>? CreatedAt { get; set; }
+
+        /// <summary>
+        /// Standard five-field cron expression, for example `0 3 * * *`.
+        /// </summary>
+        [Input("cronExpression")]
+        public Input<string>? CronExpression { get; set; }
+
+        /// <summary>
+        /// Free-form description.
+        /// </summary>
+        [Input("description")]
+        public Input<string>? Description { get; set; }
+
+        /// <summary>
+        /// Whether the schedule is active.
+        /// </summary>
+        [Input("enabled")]
+        public Input<bool>? Enabled { get; set; }
+
+        /// <summary>
+        /// Display name of the schedule.
+        /// </summary>
+        [Input("name")]
+        public Input<string>? Name { get; set; }
+
+        /// <summary>
+        /// Where the command runs. Valid values: `Application`, `Compose`, `Server`, `dokploy-server`. Defaults to `Application`.
+        /// </summary>
+        [Input("scheduleType")]
+        public Input<string>? ScheduleType { get; set; }
+
+        /// <summary>
+        /// Multi-line script to run instead of a single command.
+        /// </summary>
+        [Input("script")]
+        public Input<string>? Script { get; set; }
+
+        /// <summary>
+        /// Server this schedule runs on.
+        /// </summary>
+        [Input("serverId")]
+        public Input<string>? ServerId { get; set; }
+
+        /// <summary>
+        /// Service inside a Compose stack to run the command in.
+        /// </summary>
+        [Input("serviceName")]
+        public Input<string>? ServiceName { get; set; }
+
+        /// <summary>
+        /// Shell used to interpret the command. Valid values: `Bash`, `Sh`. Defaults to `Bash`.
+        /// </summary>
+        [Input("shellType")]
+        public Input<string>? ShellType { get; set; }
+
+        /// <summary>
+        /// IANA timezone the cron expression is evaluated in, for example `Europe/Berlin`.
+        /// </summary>
+        [Input("timezone")]
+        public Input<string>? Timezone { get; set; }
+
+        public ScheduleState()
+        {
+        }
+        public static new ScheduleState Empty => new ScheduleState();
+    }
+}

sdk/dotnet/Security.cs

@@ -10,6 +10,11 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// HTTP basic authentication credentials protecting an application's domains.
+    /// 
+    /// &gt; Dokploy stores the password hashed and does not return it. The value in Terraform state is the one you configured.
+    /// </summary>
     [DokployResourceType("dokploy:index/security:Security")]
     public partial class Security : global::Pulumi.CustomResource
     {

sdk/dotnet/SshKey.cs

@@ -10,6 +10,13 @@ using Pulumi;
 
 namespace Maxvojtkov.Dokploy
 {
+    /// <summary>
+    /// An SSH key pair Dokploy uses to clone private Git repositories and to reach remote servers.
+    /// 
+    /// &gt; The private key is stored in Terraform state. Use a state backend with encryption at rest.
+    /// 
+    /// &gt; Dokploy's update endpoint only accepts `Name` and `Description`. Changing either key forces a new resource.
+    /// </summary>
     [DokployResourceType("dokploy:index/sshKey:SshKey")]
     public partial class SshKey : global::Pulumi.CustomResource
     {

sdk/dotnet/VaultProvider.cs

@@ -0,0 +1,197 @@
+// *** WARNING: this file was generated by pulumi-language-dotnet. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading.Tasks;
+using Pulumi.Serialization;
+using Pulumi;
+
+namespace Maxvojtkov.Dokploy
+{
+    /// <summary>
+    /// An external secret manager Dokploy resolves environment variables from at deploy time.
+    /// 
+    /// Reference a secret from any `Env` value with `${{vault.&lt;scope&gt;.&lt;key&gt;}}`. The value is fetched when the deployment runs and is never stored in Dokploy — so rotating it in the vault takes effect on the next deploy with no Terraform change.
+    /// 
+    /// Supported `providerType` values: `Hashicorp` (Vault/OpenBao), `Infisical`, `Aws` (Secrets Manager), `Doppler`, `Azure` (Key Vault) and `Scaleway`.
+    /// </summary>
+    [DokployResourceType("dokploy:index/vaultProvider:VaultProvider")]
+    public partial class VaultProvider : global::Pulumi.CustomResource
+    {
+        /// <summary>
+        /// JSON array scoping which projects or environments may resolve secrets from this provider. Pass `jsonencode([])` to leave it unscoped.
+        /// </summary>
+        [Output("assignments")]
+        public Output<string> Assignments { get; private set; } = null!;
+
+        /// <summary>
+        /// Provider credentials as a JSON object, including the `providerType` discriminator.
+        /// </summary>
+        [Output("config")]
+        public Output<string> Config { get; private set; } = null!;
+
+        /// <summary>
+        /// RFC 3339 timestamp of when the connection was created.
+        /// </summary>
+        [Output("createdAt")]
+        public Output<string> CreatedAt { get; private set; } = null!;
+
+        /// <summary>
+        /// Name of the connection, unique within the organization.
+        /// </summary>
+        [Output("name")]
+        public Output<string> Name { get; private set; } = null!;
+
+        /// <summary>
+        /// Organization that owns the connection.
+        /// </summary>
+        [Output("organizationId")]
+        public Output<string> OrganizationId { get; private set; } = null!;
+
+        /// <summary>
+        /// Provider kind derived from `Config`.
+        /// </summary>
+        [Output("providerType")]
+        public Output<string> ProviderType { get; private set; } = null!;
+
+
+        /// <summary>
+        /// Create a VaultProvider resource with the given unique name, arguments, and options.
+        /// </summary>
+        ///
+        /// <param name="name">The unique name of the resource</param>
+        /// <param name="args">The arguments used to populate this resource's properties</param>
+        /// <param name="options">A bag of options that control this resource's behavior</param>
+        public VaultProvider(string name, VaultProviderArgs args, CustomResourceOptions? options = null)
+            : base("dokploy:index/vaultProvider:VaultProvider", name, args ?? new VaultProviderArgs(), MakeResourceOptions(options, ""))
+        {
+        }
+
+        private VaultProvider(string name, Input<string> id, VaultProviderState? state = null, CustomResourceOptions? options = null)
+            : base("dokploy:index/vaultProvider:VaultProvider", name, state, MakeResourceOptions(options, id))
+        {
+        }
+
+        private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input<string>? id)
+        {
+            var defaultOptions = new CustomResourceOptions
+            {
+                Version = Utilities.Version,
+                PluginDownloadURL = "https://gitea.coolify.vojtkov.dev/usr_unknown/pulumi-dokploy/releases/download/v${VERSION}",
+                AdditionalSecretOutputs =
+                {
+                    "config",
+                },
+            };
+            var merged = CustomResourceOptions.Merge(defaultOptions, options);
+            // Override the ID if one was specified for consistency with other language SDKs.
+            merged.Id = id ?? merged.Id;
+            return merged;
+        }
+        /// <summary>
+        /// Get an existing VaultProvider resource's state with the given name, ID, and optional extra
+        /// properties used to qualify the lookup.
+        /// </summary>
+        ///
+        /// <param name="name">The unique name of the resulting resource.</param>
+        /// <param name="id">The unique provider ID of the resource to lookup.</param>
+        /// <param name="state">Any extra arguments used during the lookup.</param>
+        /// <param name="options">A bag of options that control this resource's behavior</param>
+        public static VaultProvider Get(string name, Input<string> id, VaultProviderState? state = null, CustomResourceOptions? options = null)
+        {
+            return new VaultProvider(name, id, state, options);
+        }
+    }
+
+    public sealed class VaultProviderArgs : global::Pulumi.ResourceArgs
+    {
+        /// <summary>
+        /// JSON array scoping which projects or environments may resolve secrets from this provider. Pass `jsonencode([])` to leave it unscoped.
+        /// </summary>
+        [Input("assignments", required: true)]
+        public Input<string> Assignments { get; set; } = null!;
+
+        [Input("config", required: true)]
+        private Input<string>? _config;
+
+        /// <summary>
+        /// Provider credentials as a JSON object, including the `providerType` discriminator.
+        /// </summary>
+        public Input<string>? Config
+        {
+            get => _config;
+            set
+            {
+                var emptySecret = Output.CreateSecret(0);
+                _config = Output.Tuple<Input<string>?, int>(value, emptySecret).Apply(t => t.Item1);
+            }
+        }
+
+        /// <summary>
+        /// Name of the connection, unique within the organization.
+        /// </summary>
+        [Input("name")]
+        public Input<string>? Name { get; set; }
+
+        public VaultProviderArgs()
+        {
+        }
+        public static new VaultProviderArgs Empty => new VaultProviderArgs();
+    }
+
+    public sealed class VaultProviderState : global::Pulumi.ResourceArgs
+    {
+        /// <summary>
+        /// JSON array scoping which projects or environments may resolve secrets from this provider. Pass `jsonencode([])` to leave it unscoped.
+        /// </summary>
+        [Input("assignments")]
+        public Input<string>? Assignments { get; set; }
+
+        [Input("config")]
+        private Input<string>? _config;
+
+        /// <summary>
+        /// Provider credentials as a JSON object, including the `providerType` discriminator.
+        /// </summary>
+        public Input<string>? Config
+        {
+            get => _config;
+            set
+            {
+                var emptySecret = Output.CreateSecret(0);
+                _config = Output.Tuple<Input<string>?, int>(value, emptySecret).Apply(t => t.Item1);
+            }
+        }
+
+        /// <summary>
+        /// RFC 3339 timestamp of when the connection was created.
+        /// </summary>
+        [Input("createdAt")]
+        public Input<string>? CreatedAt { get; set; }
+
+        /// <summary>
+        /// Name of the connection, unique within the organization.
+        /// </summary>
+        [Input("name")]
+        public Input<string>? Name { get; set; }
+
+        /// <summary>
+        /// Organization that owns the connection.
+        /// </summary>
+        [Input("organizationId")]
+        public Input<string>? OrganizationId { get; set; }
+
+        /// <summary>
+        /// Provider kind derived from `Config`.
+        /// </summary>
+        [Input("providerType")]
+        public Input<string>? ProviderType { get; set; }
+
+        public VaultProviderState()
+        {
+        }
+        public static new VaultProviderState Empty => new VaultProviderState();
+    }
+}

sdk/dotnet/VolumeBackup.cs

@@ -0,0 +1,437 @@
+// *** WARNING: this file was generated by pulumi-language-dotnet. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+using System;
+using System.Collections.Generic;
+using System.Collections.Immutable;
+using System.Threading.Tasks;
+using Pulumi.Serialization;
+using Pulumi;
+
+namespace Maxvojtkov.Dokploy
+{
+    /// <summary>
+    /// A scheduled backup of a Docker volume to a configured `dokploy.Destination`.
+    /// 
+    /// This is the counterpart to a `dokploy.Mount` with `type = "volume"`: the mount gives the volume a stable name, and this resource copies its contents off the host on a schedule.
+    /// 
+    /// Set exactly one of the `*_id` attributes to say which service owns the volume.
+    /// </summary>
+    [DokployResourceType("dokploy:index/volumeBackup:VolumeBackup")]
+    public partial class VolumeBackup : global::Pulumi.CustomResource
+    {
+        /// <summary>
+        /// Docker service name that owns the volume. Derived by Dokploy when omitted.
+        /// </summary>
+        [Output("appName")]
+        public Output<string> AppName { get; private set; } = null!;
+
+        /// <summary>
+        /// Application that owns the volume.
+        /// </summary>
+        [Output("applicationId")]
+        public Output<string?> ApplicationId { get; private set; } = null!;
+
+        /// <summary>
+        /// Compose stack that owns the volume.
+        /// </summary>
+        [Output("composeId")]
+        public Output<string?> ComposeId { get; private set; } = null!;
+
+        /// <summary>
+        /// RFC 3339 timestamp of when the backup job was created.
+        /// </summary>
+        [Output("createdAt")]
+        public Output<string> CreatedAt { get; private set; } = null!;
+
+        /// <summary>
+        /// Standard five-field cron expression, for example `0 4 * * *`.
+        /// </summary>
+        [Output("cronExpression")]
+        public Output<string> CronExpression { get; private set; } = null!;
+
+        /// <summary>
+        /// Backup destination (S3-compatible bucket) to upload to.
+        /// </summary>
+        [Output("destinationId")]
+        public Output<string> DestinationId { get; private set; } = null!;
+
+        /// <summary>
+        /// Whether the backup schedule is active.
+        /// </summary>
+        [Output("enabled")]
+        public Output<bool> Enabled { get; private set; } = null!;
+
+        /// <summary>
+        /// Number of backups to retain. Older ones are pruned.
+        /// </summary>
+        [Output("keepLatestCount")]
+        public Output<int> KeepLatestCount { get; private set; } = null!;
+
+        /// <summary>
+        /// libSQL instance that owns the volume.
+        /// </summary>
+        [Output("libsqlId")]
+        public Output<string?> LibsqlId { get; private set; } = null!;
+
+        /// <summary>
+        /// MariaDB instance that owns the volume.
+        /// </summary>
+        [Output("mariadbId")]
+        public Output<string?> MariadbId { get; private set; } = null!;
+
+        /// <summary>
+        /// MongoDB instance that owns the volume.
+        /// </summary>
+        [Output("mongoId")]
+        public Output<string?> MongoId { get; private set; } = null!;
+
+        /// <summary>
+        /// MySQL instance that owns the volume.
+        /// </summary>
+        [Output("mysqlId")]
+        public Output<string?> MysqlId { get; private set; } = null!;
+
+        /// <summary>
+        /// Display name of the backup job.
+        /// </summary>
+        [Output("name")]
+        public Output<string> Name { get; private set; } = null!;
+
+        /// <summary>
+        /// PostgreSQL instance that owns the volume.
+        /// </summary>
+        [Output("postgresId")]
+        public Output<string?> PostgresId { get; private set; } = null!;
+
+        /// <summary>
+        /// Path prefix inside the destination bucket, for example `backups/shop/`.
+        /// </summary>
+        [Output("prefix")]
+        public Output<string> Prefix { get; private set; } = null!;
+
+        /// <summary>
+        /// Redis instance that owns the volume.
+        /// </summary>
+        [Output("redisId")]
+        public Output<string?> RedisId { get; private set; } = null!;
+
+        /// <summary>
+        /// Service inside a Compose stack that owns the volume.
+        /// </summary>
+        [Output("serviceName")]
+        public Output<string?> ServiceName { get; private set; } = null!;
+
+        /// <summary>
+        /// The kind of service that owns the volume. Valid values: `Application`, `Postgres`, `Mysql`, `Mariadb`, `Mongo`, `Redis`, `Compose`, `Libsql`. Defaults to `Application`.
+        /// </summary>
+        [Output("serviceType")]
+        public Output<string> ServiceType { get; private set; } = null!;
+
+        /// <summary>
+        /// Stop the service while the backup runs. Slower, but guarantees a consistent copy of data that is being written to.
+        /// </summary>
+        [Output("turnOff")]
+        public Output<bool> TurnOff { get; private set; } = null!;
+
+        /// <summary>
+        /// Name of the Docker volume to back up.
+        /// </summary>
+        [Output("volumeName")]
+        public Output<string> VolumeName { get; private set; } = null!;
+
+
+        /// <summary>
+        /// Create a VolumeBackup resource with the given unique name, arguments, and options.
+        /// </summary>
+        ///
+        /// <param name="name">The unique name of the resource</param>
+        /// <param name="args">The arguments used to populate this resource's properties</param>
+        /// <param name="options">A bag of options that control this resource's behavior</param>
+        public VolumeBackup(string name, VolumeBackupArgs args, CustomResourceOptions? options = null)
+            : base("dokploy:index/volumeBackup:VolumeBackup", name, args ?? new VolumeBackupArgs(), MakeResourceOptions(options, ""))
+        {
+        }
+
+        private VolumeBackup(string name, Input<string> id, VolumeBackupState? state = null, CustomResourceOptions? options = null)
+            : base("dokploy:index/volumeBackup:VolumeBackup", name, state, MakeResourceOptions(options, id))
+        {
+        }
+
+        private static CustomResourceOptions MakeResourceOptions(CustomResourceOptions? options, Input<string>? id)
+        {
+            var defaultOptions = new CustomResourceOptions
+            {
+                Version = Utilities.Version,
+                PluginDownloadURL = "https://gitea.coolify.vojtkov.dev/usr_unknown/pulumi-dokploy/releases/download/v${VERSION}",
+            };
+            var merged = CustomResourceOptions.Merge(defaultOptions, options);
+            // Override the ID if one was specified for consistency with other language SDKs.
+            merged.Id = id ?? merged.Id;
+            return merged;
+        }
+        /// <summary>
+        /// Get an existing VolumeBackup resource's state with the given name, ID, and optional extra
+        /// properties used to qualify the lookup.
+        /// </summary>
+        ///
+        /// <param name="name">The unique name of the resulting resource.</param>
+        /// <param name="id">The unique provider ID of the resource to lookup.</param>
+        /// <param name="state">Any extra arguments used during the lookup.</param>
+        /// <param name="options">A bag of options that control this resource's behavior</param>
+        public static VolumeBackup Get(string name, Input<string> id, VolumeBackupState? state = null, CustomResourceOptions? options = null)
+        {
+            return new VolumeBackup(name, id, state, options);
+        }
+    }
+
+    public sealed class VolumeBackupArgs : global::Pulumi.ResourceArgs
+    {
+        /// <summary>
+        /// Docker service name that owns the volume. Derived by Dokploy when omitted.
+        /// </summary>
+        [Input("appName")]
+        public Input<string>? AppName { get; set; }
+
+        /// <summary>
+        /// Application that owns the volume.
+        /// </summary>
+        [Input("applicationId")]
+        public Input<string>? ApplicationId { get; set; }
+
+        /// <summary>
+        /// Compose stack that owns the volume.
+        /// </summary>
+        [Input("composeId")]
+        public Input<string>? ComposeId { get; set; }
+
+        /// <summary>
+        /// Standard five-field cron expression, for example `0 4 * * *`.
+        /// </summary>
+        [Input("cronExpression", required: true)]
+        public Input<string> CronExpression { get; set; } = null!;
+
+        /// <summary>
+        /// Backup destination (S3-compatible bucket) to upload to.
+        /// </summary>
+        [Input("destinationId", required: true)]
+        public Input<string> DestinationId { get; set; } = null!;
+
+        /// <summary>
+        /// Whether the backup schedule is active.
+        /// </summary>
+        [Input("enabled")]
+        public Input<bool>? Enabled { get; set; }
+
+        /// <summary>
+        /// Number of backups to retain. Older ones are pruned.
+        /// </summary>
+        [Input("keepLatestCount")]
+        public Input<int>? KeepLatestCount { get; set; }
+
+        /// <summary>
+        /// libSQL instance that owns the volume.
+        /// </summary>
+        [Input("libsqlId")]
+        public Input<string>? LibsqlId { get; set; }
+
+        /// <summary>
+        /// MariaDB instance that owns the volume.
+        /// </summary>
+        [Input("mariadbId")]
+        public Input<string>? MariadbId { get; set; }
+
+        /// <summary>
+        /// MongoDB instance that owns the volume.
+        /// </summary>
+        [Input("mongoId")]
+        public Input<string>? MongoId { get; set; }
+
+        /// <summary>
+        /// MySQL instance that owns the volume.
+        /// </summary>
+        [Input("mysqlId")]
+        public Input<string>? MysqlId { get; set; }
+
+        /// <summary>
+        /// Display name of the backup job.
+        /// </summary>
+        [Input("name")]
+        public Input<string>? Name { get; set; }
+
+        /// <summary>
+        /// PostgreSQL instance that owns the volume.
+        /// </summary>
+        [Input("postgresId")]
+        public Input<string>? PostgresId { get; set; }
+
+        /// <summary>
+        /// Path prefix inside the destination bucket, for example `backups/shop/`.
+        /// </summary>
+        [Input("prefix", required: true)]
+        public Input<string> Prefix { get; set; } = null!;
+
+        /// <summary>
+        /// Redis instance that owns the volume.
+        /// </summary>
+        [Input("redisId")]
+        public Input<string>? RedisId { get; set; }
+
+        /// <summary>
+        /// Service inside a Compose stack that owns the volume.
+        /// </summary>
+        [Input("serviceName")]
+        public Input<string>? ServiceName { get; set; }
+
+        /// <summary>
+        /// The kind of service that owns the volume. Valid values: `Application`, `Postgres`, `Mysql`, `Mariadb`, `Mongo`, `Redis`, `Compose`, `Libsql`. Defaults to `Application`.
+        /// </summary>
+        [Input("serviceType")]
+        public Input<string>? ServiceType { get; set; }
+
+        /// <summary>
+        /// Stop the service while the backup runs. Slower, but guarantees a consistent copy of data that is being written to.
+        /// </summary>
+        [Input("turnOff")]
+        public Input<bool>? TurnOff { get; set; }
+
+        /// <summary>
+        /// Name of the Docker volume to back up.
+        /// </summary>
+        [Input("volumeName", required: true)]
+        public Input<string> VolumeName { get; set; } = null!;
+
+        public VolumeBackupArgs()
+        {
+        }
+        public static new VolumeBackupArgs Empty => new VolumeBackupArgs();
+    }
+
+    public sealed class VolumeBackupState : global::Pulumi.ResourceArgs
+    {
+        /// <summary>
+        /// Docker service name that owns the volume. Derived by Dokploy when omitted.
+        /// </summary>
+        [Input("appName")]
+        public Input<string>? AppName { get; set; }
+
+        /// <summary>
+        /// Application that owns the volume.
+        /// </summary>
+        [Input("applicationId")]
+        public Input<string>? ApplicationId { get; set; }
+
+        /// <summary>
+        /// Compose stack that owns the volume.
+        /// </summary>
+        [Input("composeId")]
+        public Input<string>? ComposeId { get; set; }
+
+        /// <summary>
+        /// RFC 3339 timestamp of when the backup job was created.
+        /// </summary>
+        [Input("createdAt")]
+        public Input<string>? CreatedAt { get; set; }
+
+        /// <summary>
+        /// Standard five-field cron expression, for example `0 4 * * *`.
+        /// </summary>
+        [Input("cronExpression")]
+        public Input<string>? CronExpression { get; set; }
+
+        /// <summary>
+        /// Backup destination (S3-compatible bucket) to upload to.
+        /// </summary>
+        [Input("destinationId")]
+        public Input<string>? DestinationId { get; set; }
+
+        /// <summary>
+        /// Whether the backup schedule is active.
+        /// </summary>
+        [Input("enabled")]
+        public Input<bool>? Enabled { get; set; }
+
+        /// <summary>
+        /// Number of backups to retain. Older ones are pruned.
+        /// </summary>
+        [Input("keepLatestCount")]
+        public Input<int>? KeepLatestCount { get; set; }
+
+        /// <summary>
+        /// libSQL instance that owns the volume.
+        /// </summary>
+        [Input("libsqlId")]
+        public Input<string>? LibsqlId { get; set; }
+
+        /// <summary>
+        /// MariaDB instance that owns the volume.
+        /// </summary>
+        [Input("mariadbId")]
+        public Input<string>? MariadbId { get; set; }
+
+        /// <summary>
+        /// MongoDB instance that owns the volume.
+        /// </summary>
+        [Input("mongoId")]
+        public Input<string>? MongoId { get; set; }
+
+        /// <summary>
+        /// MySQL instance that owns the volume.
+        /// </summary>
+        [Input("mysqlId")]
+        public Input<string>? MysqlId { get; set; }
+
+        /// <summary>
+        /// Display name of the backup job.
+        /// </summary>
+        [Input("name")]
+        public Input<string>? Name { get; set; }
+
+        /// <summary>
+        /// PostgreSQL instance that owns the volume.
+        /// </summary>
+        [Input("postgresId")]
+        public Input<string>? PostgresId { get; set; }
+
+        /// <summary>
+        /// Path prefix inside the destination bucket, for example `backups/shop/`.
+        /// </summary>
+        [Input("prefix")]
+        public Input<string>? Prefix { get; set; }
+
+        /// <summary>
+        /// Redis instance that owns the volume.
+        /// </summary>
+        [Input("redisId")]
+        public Input<string>? RedisId { get; set; }
+
+        /// <summary>
+        /// Service inside a Compose stack that owns the volume.
+        /// </summary>
+        [Input("serviceName")]
+        public Input<string>? ServiceName { get; set; }
+
+        /// <summary>
+        /// The kind of service that owns the volume. Valid values: `Application`, `Postgres`, `Mysql`, `Mariadb`, `Mongo`, `Redis`, `Compose`, `Libsql`. Defaults to `Application`.
+        /// </summary>
+        [Input("serviceType")]
+        public Input<string>? ServiceType { get; set; }
+
+        /// <summary>
+        /// Stop the service while the backup runs. Slower, but guarantees a consistent copy of data that is being written to.
+        /// </summary>
+        [Input("turnOff")]
+        public Input<bool>? TurnOff { get; set; }
+
+        /// <summary>
+        /// Name of the Docker volume to back up.
+        /// </summary>
+        [Input("volumeName")]
+        public Input<string>? VolumeName { get; set; }
+
+        public VolumeBackupState()
+        {
+        }
+        public static new VolumeBackupState Empty => new VolumeBackupState();
+    }
+}

sdk/dotnet/pulumi-plugin.json

@@ -1,6 +1,6 @@
 {
   "resource": true,
   "name": "dokploy",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "server": "https://gitea.coolify.vojtkov.dev/usr_unknown/pulumi-dokploy/releases/download/v${VERSION}"
 }

sdk/dotnet/version.txt

@@ -1 +1 @@
-0.1.0
+0.2.0

sdk/go/dokploy/application.go

@@ -12,6 +12,11 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// A Dokploy application: a single service built from a Git repository, a Docker image, or an uploaded artifact.
+//
+// Dokploy's `application.create` endpoint accepts only a handful of fields, so this resource creates the application and then applies the rest of the configuration through `application.update`.
+//
+// > Creating this resource does **not** deploy the application. Trigger a deployment from the Dokploy UI, the CLI, or a `terraformData` provisioner calling `application.deploy`.
 type Application struct {
 	pulumi.CustomResourceState
 
@@ -121,6 +126,8 @@ type Application struct {
 	HealthCheckSwarm pulumi.StringPtrOutput `pulumi:"healthCheckSwarm"`
 	// Heroku buildpack stack version.
 	HerokuVersion pulumi.StringOutput `pulumi:"herokuVersion"`
+	// Icon shown next to the service in the Dokploy UI.
+	Icon pulumi.StringPtrOutput `pulumi:"icon"`
 	// Build a preview deployment for each pull request.
 	IsPreviewDeploymentsActive pulumi.BoolOutput `pulumi:"isPreviewDeploymentsActive"`
 	// Serve a static build as a single-page application.
@@ -165,6 +172,8 @@ type Application struct {
 	PreviewPath pulumi.StringOutput `pulumi:"previewPath"`
 	// Container port exposed by preview deployments.
 	PreviewPort pulumi.IntOutput `pulumi:"previewPort"`
+	// Only build previews for pull requests opened by users with repository collaborator permissions.
+	PreviewRequireCollaboratorPermissions pulumi.BoolOutput `pulumi:"previewRequireCollaboratorPermissions"`
 	// Wildcard domain used to expose preview deployments.
 	PreviewWildcard pulumi.StringPtrOutput `pulumi:"previewWildcard"`
 	// Directory served when `buildType` is `static`.
@@ -363,6 +372,8 @@ type applicationState struct {
 	HealthCheckSwarm *string `pulumi:"healthCheckSwarm"`
 	// Heroku buildpack stack version.
 	HerokuVersion *string `pulumi:"herokuVersion"`
+	// Icon shown next to the service in the Dokploy UI.
+	Icon *string `pulumi:"icon"`
 	// Build a preview deployment for each pull request.
 	IsPreviewDeploymentsActive *bool `pulumi:"isPreviewDeploymentsActive"`
 	// Serve a static build as a single-page application.
@@ -407,6 +418,8 @@ type applicationState struct {
 	PreviewPath *string `pulumi:"previewPath"`
 	// Container port exposed by preview deployments.
 	PreviewPort *int `pulumi:"previewPort"`
+	// Only build previews for pull requests opened by users with repository collaborator permissions.
+	PreviewRequireCollaboratorPermissions *bool `pulumi:"previewRequireCollaboratorPermissions"`
 	// Wildcard domain used to expose preview deployments.
 	PreviewWildcard *string `pulumi:"previewWildcard"`
 	// Directory served when `buildType` is `static`.
@@ -558,6 +571,8 @@ type ApplicationState struct {
 	HealthCheckSwarm pulumi.StringPtrInput
 	// Heroku buildpack stack version.
 	HerokuVersion pulumi.StringPtrInput
+	// Icon shown next to the service in the Dokploy UI.
+	Icon pulumi.StringPtrInput
 	// Build a preview deployment for each pull request.
 	IsPreviewDeploymentsActive pulumi.BoolPtrInput
 	// Serve a static build as a single-page application.
@@ -602,6 +617,8 @@ type ApplicationState struct {
 	PreviewPath pulumi.StringPtrInput
 	// Container port exposed by preview deployments.
 	PreviewPort pulumi.IntPtrInput
+	// Only build previews for pull requests opened by users with repository collaborator permissions.
+	PreviewRequireCollaboratorPermissions pulumi.BoolPtrInput
 	// Wildcard domain used to expose preview deployments.
 	PreviewWildcard pulumi.StringPtrInput
 	// Directory served when `buildType` is `static`.
@@ -753,6 +770,8 @@ type applicationArgs struct {
 	HealthCheckSwarm *string `pulumi:"healthCheckSwarm"`
 	// Heroku buildpack stack version.
 	HerokuVersion *string `pulumi:"herokuVersion"`
+	// Icon shown next to the service in the Dokploy UI.
+	Icon *string `pulumi:"icon"`
 	// Build a preview deployment for each pull request.
 	IsPreviewDeploymentsActive *bool `pulumi:"isPreviewDeploymentsActive"`
 	// Serve a static build as a single-page application.
@@ -797,6 +816,8 @@ type applicationArgs struct {
 	PreviewPath *string `pulumi:"previewPath"`
 	// Container port exposed by preview deployments.
 	PreviewPort *int `pulumi:"previewPort"`
+	// Only build previews for pull requests opened by users with repository collaborator permissions.
+	PreviewRequireCollaboratorPermissions *bool `pulumi:"previewRequireCollaboratorPermissions"`
 	// Wildcard domain used to expose preview deployments.
 	PreviewWildcard *string `pulumi:"previewWildcard"`
 	// Directory served when `buildType` is `static`.
@@ -945,6 +966,8 @@ type ApplicationArgs struct {
 	HealthCheckSwarm pulumi.StringPtrInput
 	// Heroku buildpack stack version.
 	HerokuVersion pulumi.StringPtrInput
+	// Icon shown next to the service in the Dokploy UI.
+	Icon pulumi.StringPtrInput
 	// Build a preview deployment for each pull request.
 	IsPreviewDeploymentsActive pulumi.BoolPtrInput
 	// Serve a static build as a single-page application.
@@ -989,6 +1012,8 @@ type ApplicationArgs struct {
 	PreviewPath pulumi.StringPtrInput
 	// Container port exposed by preview deployments.
 	PreviewPort pulumi.IntPtrInput
+	// Only build previews for pull requests opened by users with repository collaborator permissions.
+	PreviewRequireCollaboratorPermissions pulumi.BoolPtrInput
 	// Wildcard domain used to expose preview deployments.
 	PreviewWildcard pulumi.StringPtrInput
 	// Directory served when `buildType` is `static`.
@@ -1385,6 +1410,11 @@ func (o ApplicationOutput) HerokuVersion() pulumi.StringOutput {
 	return o.ApplyT(func(v *Application) pulumi.StringOutput { return v.HerokuVersion }).(pulumi.StringOutput)
 }
 
+// Icon shown next to the service in the Dokploy UI.
+func (o ApplicationOutput) Icon() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Application) pulumi.StringPtrOutput { return v.Icon }).(pulumi.StringPtrOutput)
+}
+
 // Build a preview deployment for each pull request.
 func (o ApplicationOutput) IsPreviewDeploymentsActive() pulumi.BoolOutput {
 	return o.ApplyT(func(v *Application) pulumi.BoolOutput { return v.IsPreviewDeploymentsActive }).(pulumi.BoolOutput)
@@ -1495,6 +1525,11 @@ func (o ApplicationOutput) PreviewPort() pulumi.IntOutput {
 	return o.ApplyT(func(v *Application) pulumi.IntOutput { return v.PreviewPort }).(pulumi.IntOutput)
 }
 
+// Only build previews for pull requests opened by users with repository collaborator permissions.
+func (o ApplicationOutput) PreviewRequireCollaboratorPermissions() pulumi.BoolOutput {
+	return o.ApplyT(func(v *Application) pulumi.BoolOutput { return v.PreviewRequireCollaboratorPermissions }).(pulumi.BoolOutput)
+}
+
 // Wildcard domain used to expose preview deployments.
 func (o ApplicationOutput) PreviewWildcard() pulumi.StringPtrOutput {
 	return o.ApplyT(func(v *Application) pulumi.StringPtrOutput { return v.PreviewWildcard }).(pulumi.StringPtrOutput)

sdk/go/dokploy/certificate.go

@@ -12,6 +12,9 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// A TLS certificate uploaded to Dokploy, for domains that use `certificateType = "custom"`.
+//
+// > The private key is stored in Terraform state. Use a state backend with encryption at rest.
 type Certificate struct {
 	pulumi.CustomResourceState
 

sdk/go/dokploy/compose.go

@@ -12,6 +12,11 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// A Docker Compose or Docker Swarm stack managed by Dokploy.
+//
+// Set `composeFile` to manage the stack definition inline (with `sourceType = "raw"`), or point the stack at a Git repository and set `composePath`.
+//
+// > Creating this resource does **not** deploy the stack.
 type Compose struct {
 	pulumi.CustomResourceState
 
@@ -41,6 +46,8 @@ type Compose struct {
 	ComposeStatus pulumi.StringOutput `pulumi:"composeStatus"`
 	// Whether to run the stack with Docker Compose or Docker Swarm. Valid values: `docker-compose`, `stack`.
 	ComposeType pulumi.StringOutput `pulumi:"composeType"`
+	// Write the environment variables to a `.env` file next to the Compose file.
+	CreateEnvFile pulumi.BoolOutput `pulumi:"createEnvFile"`
 	// RFC 3339 timestamp of when the stack was created.
 	CreatedAt pulumi.StringOutput `pulumi:"createdAt"`
 	// Branch to deploy for a custom Git remote.
@@ -81,6 +88,8 @@ type Compose struct {
 	GitlabProjectId pulumi.IntPtrOutput `pulumi:"gitlabProjectId"`
 	// GitLab repository name.
 	GitlabRepository pulumi.StringPtrOutput `pulumi:"gitlabRepository"`
+	// Icon shown next to the stack in the Dokploy UI.
+	Icon pulumi.StringPtrOutput `pulumi:"icon"`
 	// Run the stack on its own isolated Docker network.
 	IsolatedDeployment pulumi.BoolOutput `pulumi:"isolatedDeployment"`
 	// Prefix volume names for isolated deployments. Retained for backwards compatibility.
@@ -95,6 +104,8 @@ type Compose struct {
 	Repository pulumi.StringPtrOutput `pulumi:"repository"`
 	// Remote server to deploy on. Omit to use the Dokploy host itself.
 	ServerId pulumi.StringPtrOutput `pulumi:"serverId"`
+	// Per-service Docker network attachments, as a JSON object mapping each service name in the stack to an array of network IDs.
+	ServiceNetworks pulumi.StringPtrOutput `pulumi:"serviceNetworks"`
 	// Where the Compose file comes from. Valid values: `git`, `github`, `gitlab`, `bitbucket`, `gitea`, `raw`.
 	SourceType pulumi.StringOutput `pulumi:"sourceType"`
 	// Suffix appended to generated resource names.
@@ -164,6 +175,8 @@ type composeState struct {
 	ComposeStatus *string `pulumi:"composeStatus"`
 	// Whether to run the stack with Docker Compose or Docker Swarm. Valid values: `docker-compose`, `stack`.
 	ComposeType *string `pulumi:"composeType"`
+	// Write the environment variables to a `.env` file next to the Compose file.
+	CreateEnvFile *bool `pulumi:"createEnvFile"`
 	// RFC 3339 timestamp of when the stack was created.
 	CreatedAt *string `pulumi:"createdAt"`
 	// Branch to deploy for a custom Git remote.
@@ -204,6 +217,8 @@ type composeState struct {
 	GitlabProjectId *int `pulumi:"gitlabProjectId"`
 	// GitLab repository name.
 	GitlabRepository *string `pulumi:"gitlabRepository"`
+	// Icon shown next to the stack in the Dokploy UI.
+	Icon *string `pulumi:"icon"`
 	// Run the stack on its own isolated Docker network.
 	IsolatedDeployment *bool `pulumi:"isolatedDeployment"`
 	// Prefix volume names for isolated deployments. Retained for backwards compatibility.
@@ -218,6 +233,8 @@ type composeState struct {
 	Repository *string `pulumi:"repository"`
 	// Remote server to deploy on. Omit to use the Dokploy host itself.
 	ServerId *string `pulumi:"serverId"`
+	// Per-service Docker network attachments, as a JSON object mapping each service name in the stack to an array of network IDs.
+	ServiceNetworks *string `pulumi:"serviceNetworks"`
 	// Where the Compose file comes from. Valid values: `git`, `github`, `gitlab`, `bitbucket`, `gitea`, `raw`.
 	SourceType *string `pulumi:"sourceType"`
 	// Suffix appended to generated resource names.
@@ -255,6 +272,8 @@ type ComposeState struct {
 	ComposeStatus pulumi.StringPtrInput
 	// Whether to run the stack with Docker Compose or Docker Swarm. Valid values: `docker-compose`, `stack`.
 	ComposeType pulumi.StringPtrInput
+	// Write the environment variables to a `.env` file next to the Compose file.
+	CreateEnvFile pulumi.BoolPtrInput
 	// RFC 3339 timestamp of when the stack was created.
 	CreatedAt pulumi.StringPtrInput
 	// Branch to deploy for a custom Git remote.
@@ -295,6 +314,8 @@ type ComposeState struct {
 	GitlabProjectId pulumi.IntPtrInput
 	// GitLab repository name.
 	GitlabRepository pulumi.StringPtrInput
+	// Icon shown next to the stack in the Dokploy UI.
+	Icon pulumi.StringPtrInput
 	// Run the stack on its own isolated Docker network.
 	IsolatedDeployment pulumi.BoolPtrInput
 	// Prefix volume names for isolated deployments. Retained for backwards compatibility.
@@ -309,6 +330,8 @@ type ComposeState struct {
 	Repository pulumi.StringPtrInput
 	// Remote server to deploy on. Omit to use the Dokploy host itself.
 	ServerId pulumi.StringPtrInput
+	// Per-service Docker network attachments, as a JSON object mapping each service name in the stack to an array of network IDs.
+	ServiceNetworks pulumi.StringPtrInput
 	// Where the Compose file comes from. Valid values: `git`, `github`, `gitlab`, `bitbucket`, `gitea`, `raw`.
 	SourceType pulumi.StringPtrInput
 	// Suffix appended to generated resource names.
@@ -348,6 +371,8 @@ type composeArgs struct {
 	ComposePath *string `pulumi:"composePath"`
 	// Whether to run the stack with Docker Compose or Docker Swarm. Valid values: `docker-compose`, `stack`.
 	ComposeType *string `pulumi:"composeType"`
+	// Write the environment variables to a `.env` file next to the Compose file.
+	CreateEnvFile *bool `pulumi:"createEnvFile"`
 	// Branch to deploy for a custom Git remote.
 	CustomGitBranch *string `pulumi:"customGitBranch"`
 	// SSH key used to clone a private custom Git remote.
@@ -386,6 +411,8 @@ type composeArgs struct {
 	GitlabProjectId *int `pulumi:"gitlabProjectId"`
 	// GitLab repository name.
 	GitlabRepository *string `pulumi:"gitlabRepository"`
+	// Icon shown next to the stack in the Dokploy UI.
+	Icon *string `pulumi:"icon"`
 	// Run the stack on its own isolated Docker network.
 	IsolatedDeployment *bool `pulumi:"isolatedDeployment"`
 	// Prefix volume names for isolated deployments. Retained for backwards compatibility.
@@ -400,6 +427,8 @@ type composeArgs struct {
 	Repository *string `pulumi:"repository"`
 	// Remote server to deploy on. Omit to use the Dokploy host itself.
 	ServerId *string `pulumi:"serverId"`
+	// Per-service Docker network attachments, as a JSON object mapping each service name in the stack to an array of network IDs.
+	ServiceNetworks *string `pulumi:"serviceNetworks"`
 	// Where the Compose file comes from. Valid values: `git`, `github`, `gitlab`, `bitbucket`, `gitea`, `raw`.
 	SourceType *string `pulumi:"sourceType"`
 	// Suffix appended to generated resource names.
@@ -436,6 +465,8 @@ type ComposeArgs struct {
 	ComposePath pulumi.StringPtrInput
 	// Whether to run the stack with Docker Compose or Docker Swarm. Valid values: `docker-compose`, `stack`.
 	ComposeType pulumi.StringPtrInput
+	// Write the environment variables to a `.env` file next to the Compose file.
+	CreateEnvFile pulumi.BoolPtrInput
 	// Branch to deploy for a custom Git remote.
 	CustomGitBranch pulumi.StringPtrInput
 	// SSH key used to clone a private custom Git remote.
@@ -474,6 +505,8 @@ type ComposeArgs struct {
 	GitlabProjectId pulumi.IntPtrInput
 	// GitLab repository name.
 	GitlabRepository pulumi.StringPtrInput
+	// Icon shown next to the stack in the Dokploy UI.
+	Icon pulumi.StringPtrInput
 	// Run the stack on its own isolated Docker network.
 	IsolatedDeployment pulumi.BoolPtrInput
 	// Prefix volume names for isolated deployments. Retained for backwards compatibility.
@@ -488,6 +521,8 @@ type ComposeArgs struct {
 	Repository pulumi.StringPtrInput
 	// Remote server to deploy on. Omit to use the Dokploy host itself.
 	ServerId pulumi.StringPtrInput
+	// Per-service Docker network attachments, as a JSON object mapping each service name in the stack to an array of network IDs.
+	ServiceNetworks pulumi.StringPtrInput
 	// Where the Compose file comes from. Valid values: `git`, `github`, `gitlab`, `bitbucket`, `gitea`, `raw`.
 	SourceType pulumi.StringPtrInput
 	// Suffix appended to generated resource names.
@@ -650,6 +685,11 @@ func (o ComposeOutput) ComposeType() pulumi.StringOutput {
 	return o.ApplyT(func(v *Compose) pulumi.StringOutput { return v.ComposeType }).(pulumi.StringOutput)
 }
 
+// Write the environment variables to a `.env` file next to the Compose file.
+func (o ComposeOutput) CreateEnvFile() pulumi.BoolOutput {
+	return o.ApplyT(func(v *Compose) pulumi.BoolOutput { return v.CreateEnvFile }).(pulumi.BoolOutput)
+}
+
 // RFC 3339 timestamp of when the stack was created.
 func (o ComposeOutput) CreatedAt() pulumi.StringOutput {
 	return o.ApplyT(func(v *Compose) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput)
@@ -750,6 +790,11 @@ func (o ComposeOutput) GitlabRepository() pulumi.StringPtrOutput {
 	return o.ApplyT(func(v *Compose) pulumi.StringPtrOutput { return v.GitlabRepository }).(pulumi.StringPtrOutput)
 }
 
+// Icon shown next to the stack in the Dokploy UI.
+func (o ComposeOutput) Icon() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Compose) pulumi.StringPtrOutput { return v.Icon }).(pulumi.StringPtrOutput)
+}
+
 // Run the stack on its own isolated Docker network.
 func (o ComposeOutput) IsolatedDeployment() pulumi.BoolOutput {
 	return o.ApplyT(func(v *Compose) pulumi.BoolOutput { return v.IsolatedDeployment }).(pulumi.BoolOutput)
@@ -785,6 +830,11 @@ func (o ComposeOutput) ServerId() pulumi.StringPtrOutput {
 	return o.ApplyT(func(v *Compose) pulumi.StringPtrOutput { return v.ServerId }).(pulumi.StringPtrOutput)
 }
 
+// Per-service Docker network attachments, as a JSON object mapping each service name in the stack to an array of network IDs.
+func (o ComposeOutput) ServiceNetworks() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Compose) pulumi.StringPtrOutput { return v.ServiceNetworks }).(pulumi.StringPtrOutput)
+}
+
 // Where the Compose file comes from. Valid values: `git`, `github`, `gitlab`, `bitbucket`, `gitea`, `raw`.
 func (o ComposeOutput) SourceType() pulumi.StringOutput {
 	return o.ApplyT(func(v *Compose) pulumi.StringOutput { return v.SourceType }).(pulumi.StringOutput)

sdk/go/dokploy/destination.go

@@ -12,6 +12,9 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// An S3-compatible bucket that Dokploy writes database and volume backups to.
+//
+// > The secret access key is stored in Terraform state. Use a state backend with encryption at rest.
 type Destination struct {
 	pulumi.CustomResourceState
 

sdk/go/dokploy/dnsProvider.go

@@ -0,0 +1,276 @@
+// Code generated by pulumi-language-go DO NOT EDIT.
+// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***
+
+package dokploy
+
+import (
+	"context"
+	"reflect"
+
+	"errors"
+	"github.com/maxvojtkov/pulumi-dokploy/sdk/go/dokploy/internal"
+	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+)
+
+// A DNS provider connection Dokploy uses to create records for domains automatically.
+//
+// `config` is a JSON object whose shape depends on `providerType`:
+type DnsProvider struct {
+	pulumi.CustomResourceState
+
+	// Provider credentials as a JSON object, including the `providerType` discriminator.
+	Config pulumi.StringOutput `pulumi:"config"`
+	// RFC 3339 timestamp of when the connection was created.
+	CreatedAt pulumi.StringOutput `pulumi:"createdAt"`
+	// Name of the connection. Must be unique within the organization and may contain only letters, digits, `-` and `_`.
+	Name pulumi.StringOutput `pulumi:"name"`
+	// Organization that owns the connection.
+	OrganizationId pulumi.StringOutput `pulumi:"organizationId"`
+	// Provider kind derived from `config`: `cloudflare` or `route53`.
+	ProviderType pulumi.StringOutput `pulumi:"providerType"`
+}
+
+// NewDnsProvider registers a new resource with the given unique name, arguments, and options.
+func NewDnsProvider(ctx *pulumi.Context,
+	name string, args *DnsProviderArgs, opts ...pulumi.ResourceOption) (*DnsProvider, error) {
+	if args == nil {
+		return nil, errors.New("missing one or more required arguments")
+	}
+
+	if args.Config == nil {
+		return nil, errors.New("invalid value for required argument 'Config'")
+	}
+	if args.Config != nil {
+		args.Config = pulumi.ToSecret(args.Config).(pulumi.StringInput)
+	}
+	secrets := pulumi.AdditionalSecretOutputs([]string{
+		"config",
+	})
+	opts = append(opts, secrets)
+	opts = internal.PkgResourceDefaultOpts(opts)
+	var resource DnsProvider
+	err := ctx.RegisterResource("dokploy:index/dnsProvider:DnsProvider", name, args, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// GetDnsProvider gets an existing DnsProvider resource's state with the given name, ID, and optional
+// state properties that are used to uniquely qualify the lookup (nil if not required).
+func GetDnsProvider(ctx *pulumi.Context,
+	name string, id pulumi.IDInput, state *DnsProviderState, opts ...pulumi.ResourceOption) (*DnsProvider, error) {
+	var resource DnsProvider
+	err := ctx.ReadResource("dokploy:index/dnsProvider:DnsProvider", name, id, state, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// Input properties used for looking up and filtering DnsProvider resources.
+type dnsProviderState struct {
+	// Provider credentials as a JSON object, including the `providerType` discriminator.
+	Config *string `pulumi:"config"`
+	// RFC 3339 timestamp of when the connection was created.
+	CreatedAt *string `pulumi:"createdAt"`
+	// Name of the connection. Must be unique within the organization and may contain only letters, digits, `-` and `_`.
+	Name *string `pulumi:"name"`
+	// Organization that owns the connection.
+	OrganizationId *string `pulumi:"organizationId"`
+	// Provider kind derived from `config`: `cloudflare` or `route53`.
+	ProviderType *string `pulumi:"providerType"`
+}
+
+type DnsProviderState struct {
+	// Provider credentials as a JSON object, including the `providerType` discriminator.
+	Config pulumi.StringPtrInput
+	// RFC 3339 timestamp of when the connection was created.
+	CreatedAt pulumi.StringPtrInput
+	// Name of the connection. Must be unique within the organization and may contain only letters, digits, `-` and `_`.
+	Name pulumi.StringPtrInput
+	// Organization that owns the connection.
+	OrganizationId pulumi.StringPtrInput
+	// Provider kind derived from `config`: `cloudflare` or `route53`.
+	ProviderType pulumi.StringPtrInput
+}
+
+func (DnsProviderState) ElementType() reflect.Type {
+	return reflect.TypeOf((*dnsProviderState)(nil)).Elem()
+}
+
+type dnsProviderArgs struct {
+	// Provider credentials as a JSON object, including the `providerType` discriminator.
+	Config string `pulumi:"config"`
+	// Name of the connection. Must be unique within the organization and may contain only letters, digits, `-` and `_`.
+	Name *string `pulumi:"name"`
+}
+
+// The set of arguments for constructing a DnsProvider resource.
+type DnsProviderArgs struct {
+	// Provider credentials as a JSON object, including the `providerType` discriminator.
+	Config pulumi.StringInput
+	// Name of the connection. Must be unique within the organization and may contain only letters, digits, `-` and `_`.
+	Name pulumi.StringPtrInput
+}
+
+func (DnsProviderArgs) ElementType() reflect.Type {
+	return reflect.TypeOf((*dnsProviderArgs)(nil)).Elem()
+}
+
+type DnsProviderInput interface {
+	pulumi.Input
+
+	ToDnsProviderOutput() DnsProviderOutput
+	ToDnsProviderOutputWithContext(ctx context.Context) DnsProviderOutput
+}
+
+func (*DnsProvider) ElementType() reflect.Type {
+	return reflect.TypeOf((**DnsProvider)(nil)).Elem()
+}
+
+func (i *DnsProvider) ToDnsProviderOutput() DnsProviderOutput {
+	return i.ToDnsProviderOutputWithContext(context.Background())
+}
+
+func (i *DnsProvider) ToDnsProviderOutputWithContext(ctx context.Context) DnsProviderOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(DnsProviderOutput)
+}
+
+// DnsProviderArrayInput is an input type that accepts DnsProviderArray and DnsProviderArrayOutput values.
+// You can construct a concrete instance of `DnsProviderArrayInput` via:
+//
+//	DnsProviderArray{ DnsProviderArgs{...} }
+type DnsProviderArrayInput interface {
+	pulumi.Input
+
+	ToDnsProviderArrayOutput() DnsProviderArrayOutput
+	ToDnsProviderArrayOutputWithContext(context.Context) DnsProviderArrayOutput
+}
+
+type DnsProviderArray []DnsProviderInput
+
+func (DnsProviderArray) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]*DnsProvider)(nil)).Elem()
+}
+
+func (i DnsProviderArray) ToDnsProviderArrayOutput() DnsProviderArrayOutput {
+	return i.ToDnsProviderArrayOutputWithContext(context.Background())
+}
+
+func (i DnsProviderArray) ToDnsProviderArrayOutputWithContext(ctx context.Context) DnsProviderArrayOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(DnsProviderArrayOutput)
+}
+
+// DnsProviderMapInput is an input type that accepts DnsProviderMap and DnsProviderMapOutput values.
+// You can construct a concrete instance of `DnsProviderMapInput` via:
+//
+//	DnsProviderMap{ "key": DnsProviderArgs{...} }
+type DnsProviderMapInput interface {
+	pulumi.Input
+
+	ToDnsProviderMapOutput() DnsProviderMapOutput
+	ToDnsProviderMapOutputWithContext(context.Context) DnsProviderMapOutput
+}
+
+type DnsProviderMap map[string]DnsProviderInput
+
+func (DnsProviderMap) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]*DnsProvider)(nil)).Elem()
+}
+
+func (i DnsProviderMap) ToDnsProviderMapOutput() DnsProviderMapOutput {
+	return i.ToDnsProviderMapOutputWithContext(context.Background())
+}
+
+func (i DnsProviderMap) ToDnsProviderMapOutputWithContext(ctx context.Context) DnsProviderMapOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(DnsProviderMapOutput)
+}
+
+type DnsProviderOutput struct{ *pulumi.OutputState }
+
+func (DnsProviderOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((**DnsProvider)(nil)).Elem()
+}
+
+func (o DnsProviderOutput) ToDnsProviderOutput() DnsProviderOutput {
+	return o
+}
+
+func (o DnsProviderOutput) ToDnsProviderOutputWithContext(ctx context.Context) DnsProviderOutput {
+	return o
+}
+
+// Provider credentials as a JSON object, including the `providerType` discriminator.
+func (o DnsProviderOutput) Config() pulumi.StringOutput {
+	return o.ApplyT(func(v *DnsProvider) pulumi.StringOutput { return v.Config }).(pulumi.StringOutput)
+}
+
+// RFC 3339 timestamp of when the connection was created.
+func (o DnsProviderOutput) CreatedAt() pulumi.StringOutput {
+	return o.ApplyT(func(v *DnsProvider) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput)
+}
+
+// Name of the connection. Must be unique within the organization and may contain only letters, digits, `-` and `_`.
+func (o DnsProviderOutput) Name() pulumi.StringOutput {
+	return o.ApplyT(func(v *DnsProvider) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput)
+}
+
+// Organization that owns the connection.
+func (o DnsProviderOutput) OrganizationId() pulumi.StringOutput {
+	return o.ApplyT(func(v *DnsProvider) pulumi.StringOutput { return v.OrganizationId }).(pulumi.StringOutput)
+}
+
+// Provider kind derived from `config`: `cloudflare` or `route53`.
+func (o DnsProviderOutput) ProviderType() pulumi.StringOutput {
+	return o.ApplyT(func(v *DnsProvider) pulumi.StringOutput { return v.ProviderType }).(pulumi.StringOutput)
+}
+
+type DnsProviderArrayOutput struct{ *pulumi.OutputState }
+
+func (DnsProviderArrayOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]*DnsProvider)(nil)).Elem()
+}
+
+func (o DnsProviderArrayOutput) ToDnsProviderArrayOutput() DnsProviderArrayOutput {
+	return o
+}
+
+func (o DnsProviderArrayOutput) ToDnsProviderArrayOutputWithContext(ctx context.Context) DnsProviderArrayOutput {
+	return o
+}
+
+func (o DnsProviderArrayOutput) Index(i pulumi.IntInput) DnsProviderOutput {
+	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *DnsProvider {
+		return vs[0].([]*DnsProvider)[vs[1].(int)]
+	}).(DnsProviderOutput)
+}
+
+type DnsProviderMapOutput struct{ *pulumi.OutputState }
+
+func (DnsProviderMapOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]*DnsProvider)(nil)).Elem()
+}
+
+func (o DnsProviderMapOutput) ToDnsProviderMapOutput() DnsProviderMapOutput {
+	return o
+}
+
+func (o DnsProviderMapOutput) ToDnsProviderMapOutputWithContext(ctx context.Context) DnsProviderMapOutput {
+	return o
+}
+
+func (o DnsProviderMapOutput) MapIndex(k pulumi.StringInput) DnsProviderOutput {
+	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *DnsProvider {
+		return vs[0].(map[string]*DnsProvider)[vs[1].(string)]
+	}).(DnsProviderOutput)
+}
+
+func init() {
+	pulumi.RegisterInputType(reflect.TypeOf((*DnsProviderInput)(nil)).Elem(), &DnsProvider{})
+	pulumi.RegisterInputType(reflect.TypeOf((*DnsProviderArrayInput)(nil)).Elem(), DnsProviderArray{})
+	pulumi.RegisterInputType(reflect.TypeOf((*DnsProviderMapInput)(nil)).Elem(), DnsProviderMap{})
+	pulumi.RegisterOutputType(DnsProviderOutput{})
+	pulumi.RegisterOutputType(DnsProviderArrayOutput{})
+	pulumi.RegisterOutputType(DnsProviderMapOutput{})
+}

sdk/go/dokploy/domain.go

@@ -12,6 +12,9 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// A domain routed to an application or a Compose service through Dokploy's Traefik instance.
+//
+// Set exactly one of `applicationId` or `composeId`. When targeting a Compose stack, `serviceName` selects which service in the stack receives the traffic.
 type Domain struct {
 	pulumi.CustomResourceState
 
@@ -29,6 +32,8 @@ type Domain struct {
 	CustomEntrypoint pulumi.StringPtrOutput `pulumi:"customEntrypoint"`
 	// What kind of target this domain points at. Valid values: `compose`, `application`, `preview`.
 	DomainType pulumi.StringOutput `pulumi:"domainType"`
+	// Whether the domain is served. Setting this to `false` removes the route from Traefik but keeps the certificate, path and middleware configuration intact, so the domain can be brought back without reconfiguring it.
+	Enabled pulumi.BoolOutput `pulumi:"enabled"`
 	// Protect this domain with Dokploy's forward auth.
 	ForwardAuthEnabled pulumi.BoolOutput `pulumi:"forwardAuthEnabled"`
 	// Fully-qualified hostname, for example `api.example.com`.
@@ -98,6 +103,8 @@ type domainState struct {
 	CustomEntrypoint *string `pulumi:"customEntrypoint"`
 	// What kind of target this domain points at. Valid values: `compose`, `application`, `preview`.
 	DomainType *string `pulumi:"domainType"`
+	// Whether the domain is served. Setting this to `false` removes the route from Traefik but keeps the certificate, path and middleware configuration intact, so the domain can be brought back without reconfiguring it.
+	Enabled *bool `pulumi:"enabled"`
 	// Protect this domain with Dokploy's forward auth.
 	ForwardAuthEnabled *bool `pulumi:"forwardAuthEnabled"`
 	// Fully-qualified hostname, for example `api.example.com`.
@@ -135,6 +142,8 @@ type DomainState struct {
 	CustomEntrypoint pulumi.StringPtrInput
 	// What kind of target this domain points at. Valid values: `compose`, `application`, `preview`.
 	DomainType pulumi.StringPtrInput
+	// Whether the domain is served. Setting this to `false` removes the route from Traefik but keeps the certificate, path and middleware configuration intact, so the domain can be brought back without reconfiguring it.
+	Enabled pulumi.BoolPtrInput
 	// Protect this domain with Dokploy's forward auth.
 	ForwardAuthEnabled pulumi.BoolPtrInput
 	// Fully-qualified hostname, for example `api.example.com`.
@@ -174,6 +183,8 @@ type domainArgs struct {
 	CustomEntrypoint *string `pulumi:"customEntrypoint"`
 	// What kind of target this domain points at. Valid values: `compose`, `application`, `preview`.
 	DomainType *string `pulumi:"domainType"`
+	// Whether the domain is served. Setting this to `false` removes the route from Traefik but keeps the certificate, path and middleware configuration intact, so the domain can be brought back without reconfiguring it.
+	Enabled *bool `pulumi:"enabled"`
 	// Protect this domain with Dokploy's forward auth.
 	ForwardAuthEnabled *bool `pulumi:"forwardAuthEnabled"`
 	// Fully-qualified hostname, for example `api.example.com`.
@@ -210,6 +221,8 @@ type DomainArgs struct {
 	CustomEntrypoint pulumi.StringPtrInput
 	// What kind of target this domain points at. Valid values: `compose`, `application`, `preview`.
 	DomainType pulumi.StringPtrInput
+	// Whether the domain is served. Setting this to `false` removes the route from Traefik but keeps the certificate, path and middleware configuration intact, so the domain can be brought back without reconfiguring it.
+	Enabled pulumi.BoolPtrInput
 	// Protect this domain with Dokploy's forward auth.
 	ForwardAuthEnabled pulumi.BoolPtrInput
 	// Fully-qualified hostname, for example `api.example.com`.
@@ -354,6 +367,11 @@ func (o DomainOutput) DomainType() pulumi.StringOutput {
 	return o.ApplyT(func(v *Domain) pulumi.StringOutput { return v.DomainType }).(pulumi.StringOutput)
 }
 
+// Whether the domain is served. Setting this to `false` removes the route from Traefik but keeps the certificate, path and middleware configuration intact, so the domain can be brought back without reconfiguring it.
+func (o DomainOutput) Enabled() pulumi.BoolOutput {
+	return o.ApplyT(func(v *Domain) pulumi.BoolOutput { return v.Enabled }).(pulumi.BoolOutput)
+}
+
 // Protect this domain with Dokploy's forward auth.
 func (o DomainOutput) ForwardAuthEnabled() pulumi.BoolOutput {
 	return o.ApplyT(func(v *Domain) pulumi.BoolOutput { return v.ForwardAuthEnabled }).(pulumi.BoolOutput)

sdk/go/dokploy/environment.go

@@ -12,6 +12,9 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// An environment inside a Dokploy project, such as `staging` or `production`. Services belong to an environment rather than directly to a project.
+//
+// Dokploy creates a default `production` environment with every project; reference it via `dokploy_project.<name>.default_environment_id` instead of declaring it here.
 type Environment struct {
 	pulumi.CustomResourceState
 

sdk/go/dokploy/getApplication.go

@@ -11,6 +11,7 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// Look up an existing application by ID.
 func LookupApplication(ctx *pulumi.Context, args *LookupApplicationArgs, opts ...pulumi.InvokeOption) (*LookupApplicationResult, error) {
 	opts = internal.PkgInvokeDefaultOpts(opts)
 	var rv LookupApplicationResult
@@ -23,20 +24,30 @@ func LookupApplication(ctx *pulumi.Context, args *LookupApplicationArgs, opts ..
 
 // A collection of arguments for invoking getApplication.
 type LookupApplicationArgs struct {
+	// Application identifier.
 	Id string `pulumi:"id"`
 }
 
 // A collection of values returned by getApplication.
 type LookupApplicationResult struct {
-	AppName           string `pulumi:"appName"`
+	// Docker service name.
+	AppName string `pulumi:"appName"`
+	// Current status.
 	ApplicationStatus string `pulumi:"applicationStatus"`
-	BuildType         string `pulumi:"buildType"`
+	// Build strategy.
-	CreatedAt         string `pulumi:"createdAt"`
+	BuildType string `pulumi:"buildType"`
-	Description       string `pulumi:"description"`
+	// Creation timestamp.
-	EnvironmentId     string `pulumi:"environmentId"`
+	CreatedAt string `pulumi:"createdAt"`
-	Id                string `pulumi:"id"`
+	// Application description.
-	Name              string `pulumi:"name"`
+	Description string `pulumi:"description"`
-	SourceType        string `pulumi:"sourceType"`
+	// Owning environment.
+	EnvironmentId string `pulumi:"environmentId"`
+	// Application identifier.
+	Id string `pulumi:"id"`
+	// Application name.
+	Name string `pulumi:"name"`
+	// Source of the code or image.
+	SourceType string `pulumi:"sourceType"`
 }
 
 func LookupApplicationOutput(ctx *pulumi.Context, args LookupApplicationOutputArgs, opts ...pulumi.InvokeOption) LookupApplicationResultOutput {
@@ -50,6 +61,7 @@ func LookupApplicationOutput(ctx *pulumi.Context, args LookupApplicationOutputAr
 
 // A collection of arguments for invoking getApplication.
 type LookupApplicationOutputArgs struct {
+	// Application identifier.
 	Id pulumi.StringInput `pulumi:"id"`
 }
 
@@ -72,38 +84,47 @@ func (o LookupApplicationResultOutput) ToLookupApplicationResultOutputWithContex
 	return o
 }
 
+// Docker service name.
 func (o LookupApplicationResultOutput) AppName() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupApplicationResult) string { return v.AppName }).(pulumi.StringOutput)
 }
 
+// Current status.
 func (o LookupApplicationResultOutput) ApplicationStatus() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupApplicationResult) string { return v.ApplicationStatus }).(pulumi.StringOutput)
 }
 
+// Build strategy.
 func (o LookupApplicationResultOutput) BuildType() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupApplicationResult) string { return v.BuildType }).(pulumi.StringOutput)
 }
 
+// Creation timestamp.
 func (o LookupApplicationResultOutput) CreatedAt() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupApplicationResult) string { return v.CreatedAt }).(pulumi.StringOutput)
 }
 
+// Application description.
 func (o LookupApplicationResultOutput) Description() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupApplicationResult) string { return v.Description }).(pulumi.StringOutput)
 }
 
+// Owning environment.
 func (o LookupApplicationResultOutput) EnvironmentId() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupApplicationResult) string { return v.EnvironmentId }).(pulumi.StringOutput)
 }
 
+// Application identifier.
 func (o LookupApplicationResultOutput) Id() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupApplicationResult) string { return v.Id }).(pulumi.StringOutput)
 }
 
+// Application name.
 func (o LookupApplicationResultOutput) Name() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupApplicationResult) string { return v.Name }).(pulumi.StringOutput)
 }
 
+// Source of the code or image.
 func (o LookupApplicationResultOutput) SourceType() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupApplicationResult) string { return v.SourceType }).(pulumi.StringOutput)
 }

sdk/go/dokploy/getEnvironment.go

@@ -11,6 +11,7 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// Look up an existing environment by ID.
 func LookupEnvironment(ctx *pulumi.Context, args *LookupEnvironmentArgs, opts ...pulumi.InvokeOption) (*LookupEnvironmentResult, error) {
 	opts = internal.PkgInvokeDefaultOpts(opts)
 	var rv LookupEnvironmentResult
@@ -23,18 +24,26 @@ func LookupEnvironment(ctx *pulumi.Context, args *LookupEnvironmentArgs, opts ..
 
 // A collection of arguments for invoking getEnvironment.
 type LookupEnvironmentArgs struct {
+	// Environment identifier.
 	Id string `pulumi:"id"`
 }
 
 // A collection of values returned by getEnvironment.
 type LookupEnvironmentResult struct {
-	CreatedAt   string `pulumi:"createdAt"`
+	// Creation timestamp.
+	CreatedAt string `pulumi:"createdAt"`
+	// Environment description.
 	Description string `pulumi:"description"`
-	Env         string `pulumi:"env"`
+	// Environment-wide variables.
-	Id          string `pulumi:"id"`
+	Env string `pulumi:"env"`
-	IsDefault   bool   `pulumi:"isDefault"`
+	// Environment identifier.
-	Name        string `pulumi:"name"`
+	Id string `pulumi:"id"`
-	ProjectId   string `pulumi:"projectId"`
+	// Whether this is the project's default environment.
+	IsDefault bool `pulumi:"isDefault"`
+	// Environment name.
+	Name string `pulumi:"name"`
+	// Owning project.
+	ProjectId string `pulumi:"projectId"`
 }
 
 func LookupEnvironmentOutput(ctx *pulumi.Context, args LookupEnvironmentOutputArgs, opts ...pulumi.InvokeOption) LookupEnvironmentResultOutput {
@@ -48,6 +57,7 @@ func LookupEnvironmentOutput(ctx *pulumi.Context, args LookupEnvironmentOutputAr
 
 // A collection of arguments for invoking getEnvironment.
 type LookupEnvironmentOutputArgs struct {
+	// Environment identifier.
 	Id pulumi.StringInput `pulumi:"id"`
 }
 
@@ -70,30 +80,37 @@ func (o LookupEnvironmentResultOutput) ToLookupEnvironmentResultOutputWithContex
 	return o
 }
 
+// Creation timestamp.
 func (o LookupEnvironmentResultOutput) CreatedAt() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupEnvironmentResult) string { return v.CreatedAt }).(pulumi.StringOutput)
 }
 
+// Environment description.
 func (o LookupEnvironmentResultOutput) Description() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupEnvironmentResult) string { return v.Description }).(pulumi.StringOutput)
 }
 
+// Environment-wide variables.
 func (o LookupEnvironmentResultOutput) Env() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupEnvironmentResult) string { return v.Env }).(pulumi.StringOutput)
 }
 
+// Environment identifier.
 func (o LookupEnvironmentResultOutput) Id() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupEnvironmentResult) string { return v.Id }).(pulumi.StringOutput)
 }
 
+// Whether this is the project's default environment.
 func (o LookupEnvironmentResultOutput) IsDefault() pulumi.BoolOutput {
 	return o.ApplyT(func(v LookupEnvironmentResult) bool { return v.IsDefault }).(pulumi.BoolOutput)
 }
 
+// Environment name.
 func (o LookupEnvironmentResultOutput) Name() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupEnvironmentResult) string { return v.Name }).(pulumi.StringOutput)
 }
 
+// Owning project.
 func (o LookupEnvironmentResultOutput) ProjectId() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupEnvironmentResult) string { return v.ProjectId }).(pulumi.StringOutput)
 }

sdk/go/dokploy/getProject.go

@@ -11,6 +11,7 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// Look up an existing Dokploy project by ID, including its environments.
 func LookupProject(ctx *pulumi.Context, args *LookupProjectArgs, opts ...pulumi.InvokeOption) (*LookupProjectResult, error) {
 	opts = internal.PkgInvokeDefaultOpts(opts)
 	var rv LookupProjectResult
@@ -23,19 +24,28 @@ func LookupProject(ctx *pulumi.Context, args *LookupProjectArgs, opts ...pulumi.
 
 // A collection of arguments for invoking getProject.
 type LookupProjectArgs struct {
+	// Project identifier.
 	Id string `pulumi:"id"`
 }
 
 // A collection of values returned by getProject.
 type LookupProjectResult struct {
-	CreatedAt            string                  `pulumi:"createdAt"`
+	// Creation timestamp.
-	DefaultEnvironmentId string                  `pulumi:"defaultEnvironmentId"`
+	CreatedAt string `pulumi:"createdAt"`
-	Description          string                  `pulumi:"description"`
+	// ID of the project's default environment.
-	Env                  string                  `pulumi:"env"`
+	DefaultEnvironmentId string `pulumi:"defaultEnvironmentId"`
-	Environments         []GetProjectEnvironment `pulumi:"environments"`
+	// Project description.
-	Id                   string                  `pulumi:"id"`
+	Description string `pulumi:"description"`
-	Name                 string                  `pulumi:"name"`
+	// Project-wide environment variables.
-	OrganizationId       string                  `pulumi:"organizationId"`
+	Env string `pulumi:"env"`
+	// Every environment in the project.
+	Environments []GetProjectEnvironment `pulumi:"environments"`
+	// Project identifier.
+	Id string `pulumi:"id"`
+	// Project name.
+	Name string `pulumi:"name"`
+	// Owning organization.
+	OrganizationId string `pulumi:"organizationId"`
 }
 
 func LookupProjectOutput(ctx *pulumi.Context, args LookupProjectOutputArgs, opts ...pulumi.InvokeOption) LookupProjectResultOutput {
@@ -49,6 +59,7 @@ func LookupProjectOutput(ctx *pulumi.Context, args LookupProjectOutputArgs, opts
 
 // A collection of arguments for invoking getProject.
 type LookupProjectOutputArgs struct {
+	// Project identifier.
 	Id pulumi.StringInput `pulumi:"id"`
 }
 
@@ -71,34 +82,42 @@ func (o LookupProjectResultOutput) ToLookupProjectResultOutputWithContext(ctx co
 	return o
 }
 
+// Creation timestamp.
 func (o LookupProjectResultOutput) CreatedAt() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupProjectResult) string { return v.CreatedAt }).(pulumi.StringOutput)
 }
 
+// ID of the project's default environment.
 func (o LookupProjectResultOutput) DefaultEnvironmentId() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupProjectResult) string { return v.DefaultEnvironmentId }).(pulumi.StringOutput)
 }
 
+// Project description.
 func (o LookupProjectResultOutput) Description() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupProjectResult) string { return v.Description }).(pulumi.StringOutput)
 }
 
+// Project-wide environment variables.
 func (o LookupProjectResultOutput) Env() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupProjectResult) string { return v.Env }).(pulumi.StringOutput)
 }
 
+// Every environment in the project.
 func (o LookupProjectResultOutput) Environments() GetProjectEnvironmentArrayOutput {
 	return o.ApplyT(func(v LookupProjectResult) []GetProjectEnvironment { return v.Environments }).(GetProjectEnvironmentArrayOutput)
 }
 
+// Project identifier.
 func (o LookupProjectResultOutput) Id() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupProjectResult) string { return v.Id }).(pulumi.StringOutput)
 }
 
+// Project name.
 func (o LookupProjectResultOutput) Name() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupProjectResult) string { return v.Name }).(pulumi.StringOutput)
 }
 
+// Owning organization.
 func (o LookupProjectResultOutput) OrganizationId() pulumi.StringOutput {
 	return o.ApplyT(func(v LookupProjectResult) string { return v.OrganizationId }).(pulumi.StringOutput)
 }

sdk/go/dokploy/getProjects.go

@@ -11,6 +11,7 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// List every Dokploy project the API token can see.
 func GetProjects(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetProjectsResult, error) {
 	opts = internal.PkgInvokeDefaultOpts(opts)
 	var rv GetProjectsResult
@@ -23,6 +24,7 @@ func GetProjects(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetProjects
 
 // A collection of values returned by getProjects.
 type GetProjectsResult struct {
+	// All visible projects.
 	Projects []GetProjectsProject `pulumi:"projects"`
 }
 
@@ -48,6 +50,7 @@ func (o GetProjectsResultOutput) ToGetProjectsResultOutputWithContext(ctx contex
 	return o
 }
 
+// All visible projects.
 func (o GetProjectsResultOutput) Projects() GetProjectsProjectArrayOutput {
 	return o.ApplyT(func(v GetProjectsResult) []GetProjectsProject { return v.Projects }).(GetProjectsProjectArrayOutput)
 }

sdk/go/dokploy/getServers.go

@@ -11,6 +11,7 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// List the remote servers registered with Dokploy. Use a server's `id` as the `serverId` of an application, stack, or database to deploy it away from the Dokploy host.
 func GetServers(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetServersResult, error) {
 	opts = internal.PkgInvokeDefaultOpts(opts)
 	var rv GetServersResult
@@ -23,6 +24,7 @@ func GetServers(ctx *pulumi.Context, opts ...pulumi.InvokeOption) (*GetServersRe
 
 // A collection of values returned by getServers.
 type GetServersResult struct {
+	// All registered servers.
 	Servers []GetServersServer `pulumi:"servers"`
 }
 
@@ -48,6 +50,7 @@ func (o GetServersResultOutput) ToGetServersResultOutputWithContext(ctx context.
 	return o
 }
 
+// All registered servers.
 func (o GetServersResultOutput) Servers() GetServersServerArrayOutput {
 	return o.ApplyT(func(v GetServersResult) []GetServersServer { return v.Servers }).(GetServersServerArrayOutput)
 }

sdk/go/dokploy/init.go

@@ -29,10 +29,14 @@ func (m *module) Construct(ctx *pulumi.Context, name, typ, urn string) (r pulumi
 		r = &Compose{}
 	case "dokploy:index/destination:Destination":
 		r = &Destination{}
+	case "dokploy:index/dnsProvider:DnsProvider":
+		r = &DnsProvider{}
 	case "dokploy:index/domain:Domain":
 		r = &Domain{}
 	case "dokploy:index/environment:Environment":
 		r = &Environment{}
+	case "dokploy:index/libsql:Libsql":
+		r = &Libsql{}
 	case "dokploy:index/mariaDb:MariaDb":
 		r = &MariaDb{}
 	case "dokploy:index/mongo:Mongo":
@@ -41,6 +45,8 @@ func (m *module) Construct(ctx *pulumi.Context, name, typ, urn string) (r pulumi
 		r = &Mount{}
 	case "dokploy:index/mySql:MySql":
 		r = &MySql{}
+	case "dokploy:index/network:Network":
+		r = &Network{}
 	case "dokploy:index/port:Port":
 		r = &Port{}
 	case "dokploy:index/postgres:Postgres":
@@ -53,10 +59,16 @@ func (m *module) Construct(ctx *pulumi.Context, name, typ, urn string) (r pulumi
 		r = &Redis{}
 	case "dokploy:index/registry:Registry":
 		r = &Registry{}
+	case "dokploy:index/schedule:Schedule":
+		r = &Schedule{}
 	case "dokploy:index/security:Security":
 		r = &Security{}
 	case "dokploy:index/sshKey:SshKey":
 		r = &SshKey{}
+	case "dokploy:index/vaultProvider:VaultProvider":
+		r = &VaultProvider{}
+	case "dokploy:index/volumeBackup:VolumeBackup":
+		r = &VolumeBackup{}
 	default:
 		return nil, fmt.Errorf("unknown resource type: %s", typ)
 	}
@@ -108,6 +120,11 @@ func init() {
 		"index/destination",
 		&module{version},
 	)
+	pulumi.RegisterResourceModule(
+		"dokploy",
+		"index/dnsProvider",
+		&module{version},
+	)
 	pulumi.RegisterResourceModule(
 		"dokploy",
 		"index/domain",
@@ -118,6 +135,11 @@ func init() {
 		"index/environment",
 		&module{version},
 	)
+	pulumi.RegisterResourceModule(
+		"dokploy",
+		"index/libsql",
+		&module{version},
+	)
 	pulumi.RegisterResourceModule(
 		"dokploy",
 		"index/mariaDb",
@@ -138,6 +160,11 @@ func init() {
 		"index/mySql",
 		&module{version},
 	)
+	pulumi.RegisterResourceModule(
+		"dokploy",
+		"index/network",
+		&module{version},
+	)
 	pulumi.RegisterResourceModule(
 		"dokploy",
 		"index/port",
@@ -168,6 +195,11 @@ func init() {
 		"index/registry",
 		&module{version},
 	)
+	pulumi.RegisterResourceModule(
+		"dokploy",
+		"index/schedule",
+		&module{version},
+	)
 	pulumi.RegisterResourceModule(
 		"dokploy",
 		"index/security",
@@ -178,6 +210,16 @@ func init() {
 		"index/sshKey",
 		&module{version},
 	)
+	pulumi.RegisterResourceModule(
+		"dokploy",
+		"index/vaultProvider",
+		&module{version},
+	)
+	pulumi.RegisterResourceModule(
+		"dokploy",
+		"index/volumeBackup",
+		&module{version},
+	)
 	pulumi.RegisterResourcePackage(
 		"dokploy",
 		&pkg{version},

sdk/go/dokploy/internal/pulumiUtilities.go

@@ -165,7 +165,7 @@ func callPlainInner(
 func PkgResourceDefaultOpts(opts []pulumi.ResourceOption) []pulumi.ResourceOption {
 	defaults := []pulumi.ResourceOption{}
 	defaults = append(defaults, pulumi.PluginDownloadURL("https://gitea.coolify.vojtkov.dev/usr_unknown/pulumi-dokploy/releases/download/v${VERSION}"))
-	version := semver.MustParse("0.1.0")
+	version := semver.MustParse("0.2.0")
 	if !version.Equals(semver.Version{}) {
 		defaults = append(defaults, pulumi.Version(version.String()))
 	}
@@ -176,7 +176,7 @@ func PkgResourceDefaultOpts(opts []pulumi.ResourceOption) []pulumi.ResourceOptio
 func PkgInvokeDefaultOpts(opts []pulumi.InvokeOption) []pulumi.InvokeOption {
 	defaults := []pulumi.InvokeOption{}
 	defaults = append(defaults, pulumi.PluginDownloadURL("https://gitea.coolify.vojtkov.dev/usr_unknown/pulumi-dokploy/releases/download/v${VERSION}"))
-	version := semver.MustParse("0.1.0")
+	version := semver.MustParse("0.2.0")
 	if !version.Equals(semver.Version{}) {
 		defaults = append(defaults, pulumi.Version(version.String()))
 	}

sdk/go/dokploy/libsql.go

@@ -0,0 +1,743 @@
+// Code generated by pulumi-language-go DO NOT EDIT.
+// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***
+
+package dokploy
+
+import (
+	"context"
+	"reflect"
+
+	"errors"
+	"github.com/maxvojtkov/pulumi-dokploy/sdk/go/dokploy/internal"
+	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+)
+
+// A managed libSQL instance running on Dokploy.
+//
+// > Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+//
+// > Credentials are stored in Terraform state. Use a state backend with encryption at rest.
+//
+// libSQL runs as a `sqld` server. A `primary` node owns the data; a `replica` node follows a primary named by `sqldPrimaryUrl`.
+type Libsql struct {
+	pulumi.CustomResourceState
+
+	// Unique Docker service name. Generated from `name` when omitted, because Dokploy's libSQL endpoint does not generate one. Changing it forces a new database.
+	AppName pulumi.StringOutput `pulumi:"appName"`
+	// Current status reported by Dokploy: `idle`, `running`, `done` or `error`.
+	ApplicationStatus pulumi.StringOutput `pulumi:"applicationStatus"`
+	// Override the container entrypoint command.
+	Command pulumi.StringPtrOutput `pulumi:"command"`
+	// Hard CPU limit, for example `1`.
+	CpuLimit pulumi.StringPtrOutput `pulumi:"cpuLimit"`
+	// Soft CPU reservation, for example `0.5`.
+	CpuReservation pulumi.StringPtrOutput `pulumi:"cpuReservation"`
+	// RFC 3339 timestamp of when the database was created.
+	CreatedAt pulumi.StringOutput `pulumi:"createdAt"`
+	// Password for the database user.
+	DatabasePassword pulumi.StringOutput `pulumi:"databasePassword"`
+	// Database user to create.
+	DatabaseUser pulumi.StringOutput `pulumi:"databaseUser"`
+	// Free-form description.
+	Description pulumi.StringPtrOutput `pulumi:"description"`
+	// Detach the service from the shared `dokploy-network`.
+	DetachDokployNetwork pulumi.BoolOutput `pulumi:"detachDokployNetwork"`
+	// libSQL server image to run, for example `ghcr.io/tursodatabase/libsql-server:latest`.
+	DockerImage pulumi.StringOutput `pulumi:"dockerImage"`
+	// Serve multiple logical databases from one instance through libSQL namespaces.
+	EnableNamespaces pulumi.BoolOutput `pulumi:"enableNamespaces"`
+	// Docker Swarm endpoint specification, as a JSON object.
+	EndpointSpecSwarm pulumi.StringPtrOutput `pulumi:"endpointSpecSwarm"`
+	// Environment variables in `KEY=value` format, one per line.
+	Env pulumi.StringPtrOutput `pulumi:"env"`
+	// Environment this database belongs to.
+	EnvironmentId pulumi.StringOutput `pulumi:"environmentId"`
+	// Host port exposing the admin API.
+	ExternalAdminPort pulumi.IntPtrOutput `pulumi:"externalAdminPort"`
+	// Host port exposing the gRPC replication endpoint.
+	ExternalGrpcPort pulumi.IntPtrOutput `pulumi:"externalGrpcPort"`
+	// Host port exposing the HTTP API.
+	ExternalPort pulumi.IntPtrOutput `pulumi:"externalPort"`
+	// Docker Swarm health check configuration, as a JSON object.
+	HealthCheckSwarm pulumi.StringPtrOutput `pulumi:"healthCheckSwarm"`
+	// Docker Swarm service labels, as a JSON object.
+	LabelsSwarm pulumi.StringPtrOutput `pulumi:"labelsSwarm"`
+	// Hard memory limit, for example `512m`.
+	MemoryLimit pulumi.StringPtrOutput `pulumi:"memoryLimit"`
+	// Soft memory reservation, for example `256m`.
+	MemoryReservation pulumi.StringPtrOutput `pulumi:"memoryReservation"`
+	// Docker Swarm service mode, as a JSON object.
+	ModeSwarm pulumi.StringPtrOutput `pulumi:"modeSwarm"`
+	// Display name of the database.
+	Name pulumi.StringOutput `pulumi:"name"`
+	// IDs of additional Docker networks to attach.
+	NetworkIds pulumi.StringArrayOutput `pulumi:"networkIds"`
+	// Docker Swarm network attachments, as a JSON array.
+	NetworkSwarm pulumi.StringPtrOutput `pulumi:"networkSwarm"`
+	// Docker Swarm placement constraints, as a JSON object.
+	PlacementSwarm pulumi.StringPtrOutput `pulumi:"placementSwarm"`
+	// Number of replicas to run.
+	Replicas pulumi.IntOutput `pulumi:"replicas"`
+	// Docker Swarm restart policy, as a JSON object.
+	RestartPolicySwarm pulumi.StringPtrOutput `pulumi:"restartPolicySwarm"`
+	// Docker Swarm rollback configuration, as a JSON object.
+	RollbackConfigSwarm pulumi.StringPtrOutput `pulumi:"rollbackConfigSwarm"`
+	// Remote server to deploy on. Omit to use the Dokploy host itself.
+	ServerId pulumi.StringPtrOutput `pulumi:"serverId"`
+	// Role this node plays in a libSQL cluster. Valid values: `primary`, `replica`. Defaults to `primary`.
+	SqldNode pulumi.StringOutput `pulumi:"sqldNode"`
+	// URL of the primary node, when `sqldNode` is `replica`.
+	SqldPrimaryUrl pulumi.StringPtrOutput `pulumi:"sqldPrimaryUrl"`
+	// Grace period in nanoseconds before a container is killed.
+	StopGracePeriodSwarm pulumi.IntPtrOutput `pulumi:"stopGracePeriodSwarm"`
+	// Docker Swarm rolling update configuration, as a JSON object.
+	UpdateConfigSwarm pulumi.StringPtrOutput `pulumi:"updateConfigSwarm"`
+}
+
+// NewLibsql registers a new resource with the given unique name, arguments, and options.
+func NewLibsql(ctx *pulumi.Context,
+	name string, args *LibsqlArgs, opts ...pulumi.ResourceOption) (*Libsql, error) {
+	if args == nil {
+		return nil, errors.New("missing one or more required arguments")
+	}
+
+	if args.DatabasePassword == nil {
+		return nil, errors.New("invalid value for required argument 'DatabasePassword'")
+	}
+	if args.DatabaseUser == nil {
+		return nil, errors.New("invalid value for required argument 'DatabaseUser'")
+	}
+	if args.DockerImage == nil {
+		return nil, errors.New("invalid value for required argument 'DockerImage'")
+	}
+	if args.EnvironmentId == nil {
+		return nil, errors.New("invalid value for required argument 'EnvironmentId'")
+	}
+	if args.DatabasePassword != nil {
+		args.DatabasePassword = pulumi.ToSecret(args.DatabasePassword).(pulumi.StringInput)
+	}
+	secrets := pulumi.AdditionalSecretOutputs([]string{
+		"databasePassword",
+	})
+	opts = append(opts, secrets)
+	opts = internal.PkgResourceDefaultOpts(opts)
+	var resource Libsql
+	err := ctx.RegisterResource("dokploy:index/libsql:Libsql", name, args, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// GetLibsql gets an existing Libsql resource's state with the given name, ID, and optional
+// state properties that are used to uniquely qualify the lookup (nil if not required).
+func GetLibsql(ctx *pulumi.Context,
+	name string, id pulumi.IDInput, state *LibsqlState, opts ...pulumi.ResourceOption) (*Libsql, error) {
+	var resource Libsql
+	err := ctx.ReadResource("dokploy:index/libsql:Libsql", name, id, state, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// Input properties used for looking up and filtering Libsql resources.
+type libsqlState struct {
+	// Unique Docker service name. Generated from `name` when omitted, because Dokploy's libSQL endpoint does not generate one. Changing it forces a new database.
+	AppName *string `pulumi:"appName"`
+	// Current status reported by Dokploy: `idle`, `running`, `done` or `error`.
+	ApplicationStatus *string `pulumi:"applicationStatus"`
+	// Override the container entrypoint command.
+	Command *string `pulumi:"command"`
+	// Hard CPU limit, for example `1`.
+	CpuLimit *string `pulumi:"cpuLimit"`
+	// Soft CPU reservation, for example `0.5`.
+	CpuReservation *string `pulumi:"cpuReservation"`
+	// RFC 3339 timestamp of when the database was created.
+	CreatedAt *string `pulumi:"createdAt"`
+	// Password for the database user.
+	DatabasePassword *string `pulumi:"databasePassword"`
+	// Database user to create.
+	DatabaseUser *string `pulumi:"databaseUser"`
+	// Free-form description.
+	Description *string `pulumi:"description"`
+	// Detach the service from the shared `dokploy-network`.
+	DetachDokployNetwork *bool `pulumi:"detachDokployNetwork"`
+	// libSQL server image to run, for example `ghcr.io/tursodatabase/libsql-server:latest`.
+	DockerImage *string `pulumi:"dockerImage"`
+	// Serve multiple logical databases from one instance through libSQL namespaces.
+	EnableNamespaces *bool `pulumi:"enableNamespaces"`
+	// Docker Swarm endpoint specification, as a JSON object.
+	EndpointSpecSwarm *string `pulumi:"endpointSpecSwarm"`
+	// Environment variables in `KEY=value` format, one per line.
+	Env *string `pulumi:"env"`
+	// Environment this database belongs to.
+	EnvironmentId *string `pulumi:"environmentId"`
+	// Host port exposing the admin API.
+	ExternalAdminPort *int `pulumi:"externalAdminPort"`
+	// Host port exposing the gRPC replication endpoint.
+	ExternalGrpcPort *int `pulumi:"externalGrpcPort"`
+	// Host port exposing the HTTP API.
+	ExternalPort *int `pulumi:"externalPort"`
+	// Docker Swarm health check configuration, as a JSON object.
+	HealthCheckSwarm *string `pulumi:"healthCheckSwarm"`
+	// Docker Swarm service labels, as a JSON object.
+	LabelsSwarm *string `pulumi:"labelsSwarm"`
+	// Hard memory limit, for example `512m`.
+	MemoryLimit *string `pulumi:"memoryLimit"`
+	// Soft memory reservation, for example `256m`.
+	MemoryReservation *string `pulumi:"memoryReservation"`
+	// Docker Swarm service mode, as a JSON object.
+	ModeSwarm *string `pulumi:"modeSwarm"`
+	// Display name of the database.
+	Name *string `pulumi:"name"`
+	// IDs of additional Docker networks to attach.
+	NetworkIds []string `pulumi:"networkIds"`
+	// Docker Swarm network attachments, as a JSON array.
+	NetworkSwarm *string `pulumi:"networkSwarm"`
+	// Docker Swarm placement constraints, as a JSON object.
+	PlacementSwarm *string `pulumi:"placementSwarm"`
+	// Number of replicas to run.
+	Replicas *int `pulumi:"replicas"`
+	// Docker Swarm restart policy, as a JSON object.
+	RestartPolicySwarm *string `pulumi:"restartPolicySwarm"`
+	// Docker Swarm rollback configuration, as a JSON object.
+	RollbackConfigSwarm *string `pulumi:"rollbackConfigSwarm"`
+	// Remote server to deploy on. Omit to use the Dokploy host itself.
+	ServerId *string `pulumi:"serverId"`
+	// Role this node plays in a libSQL cluster. Valid values: `primary`, `replica`. Defaults to `primary`.
+	SqldNode *string `pulumi:"sqldNode"`
+	// URL of the primary node, when `sqldNode` is `replica`.
+	SqldPrimaryUrl *string `pulumi:"sqldPrimaryUrl"`
+	// Grace period in nanoseconds before a container is killed.
+	StopGracePeriodSwarm *int `pulumi:"stopGracePeriodSwarm"`
+	// Docker Swarm rolling update configuration, as a JSON object.
+	UpdateConfigSwarm *string `pulumi:"updateConfigSwarm"`
+}
+
+type LibsqlState struct {
+	// Unique Docker service name. Generated from `name` when omitted, because Dokploy's libSQL endpoint does not generate one. Changing it forces a new database.
+	AppName pulumi.StringPtrInput
+	// Current status reported by Dokploy: `idle`, `running`, `done` or `error`.
+	ApplicationStatus pulumi.StringPtrInput
+	// Override the container entrypoint command.
+	Command pulumi.StringPtrInput
+	// Hard CPU limit, for example `1`.
+	CpuLimit pulumi.StringPtrInput
+	// Soft CPU reservation, for example `0.5`.
+	CpuReservation pulumi.StringPtrInput
+	// RFC 3339 timestamp of when the database was created.
+	CreatedAt pulumi.StringPtrInput
+	// Password for the database user.
+	DatabasePassword pulumi.StringPtrInput
+	// Database user to create.
+	DatabaseUser pulumi.StringPtrInput
+	// Free-form description.
+	Description pulumi.StringPtrInput
+	// Detach the service from the shared `dokploy-network`.
+	DetachDokployNetwork pulumi.BoolPtrInput
+	// libSQL server image to run, for example `ghcr.io/tursodatabase/libsql-server:latest`.
+	DockerImage pulumi.StringPtrInput
+	// Serve multiple logical databases from one instance through libSQL namespaces.
+	EnableNamespaces pulumi.BoolPtrInput
+	// Docker Swarm endpoint specification, as a JSON object.
+	EndpointSpecSwarm pulumi.StringPtrInput
+	// Environment variables in `KEY=value` format, one per line.
+	Env pulumi.StringPtrInput
+	// Environment this database belongs to.
+	EnvironmentId pulumi.StringPtrInput
+	// Host port exposing the admin API.
+	ExternalAdminPort pulumi.IntPtrInput
+	// Host port exposing the gRPC replication endpoint.
+	ExternalGrpcPort pulumi.IntPtrInput
+	// Host port exposing the HTTP API.
+	ExternalPort pulumi.IntPtrInput
+	// Docker Swarm health check configuration, as a JSON object.
+	HealthCheckSwarm pulumi.StringPtrInput
+	// Docker Swarm service labels, as a JSON object.
+	LabelsSwarm pulumi.StringPtrInput
+	// Hard memory limit, for example `512m`.
+	MemoryLimit pulumi.StringPtrInput
+	// Soft memory reservation, for example `256m`.
+	MemoryReservation pulumi.StringPtrInput
+	// Docker Swarm service mode, as a JSON object.
+	ModeSwarm pulumi.StringPtrInput
+	// Display name of the database.
+	Name pulumi.StringPtrInput
+	// IDs of additional Docker networks to attach.
+	NetworkIds pulumi.StringArrayInput
+	// Docker Swarm network attachments, as a JSON array.
+	NetworkSwarm pulumi.StringPtrInput
+	// Docker Swarm placement constraints, as a JSON object.
+	PlacementSwarm pulumi.StringPtrInput
+	// Number of replicas to run.
+	Replicas pulumi.IntPtrInput
+	// Docker Swarm restart policy, as a JSON object.
+	RestartPolicySwarm pulumi.StringPtrInput
+	// Docker Swarm rollback configuration, as a JSON object.
+	RollbackConfigSwarm pulumi.StringPtrInput
+	// Remote server to deploy on. Omit to use the Dokploy host itself.
+	ServerId pulumi.StringPtrInput
+	// Role this node plays in a libSQL cluster. Valid values: `primary`, `replica`. Defaults to `primary`.
+	SqldNode pulumi.StringPtrInput
+	// URL of the primary node, when `sqldNode` is `replica`.
+	SqldPrimaryUrl pulumi.StringPtrInput
+	// Grace period in nanoseconds before a container is killed.
+	StopGracePeriodSwarm pulumi.IntPtrInput
+	// Docker Swarm rolling update configuration, as a JSON object.
+	UpdateConfigSwarm pulumi.StringPtrInput
+}
+
+func (LibsqlState) ElementType() reflect.Type {
+	return reflect.TypeOf((*libsqlState)(nil)).Elem()
+}
+
+type libsqlArgs struct {
+	// Unique Docker service name. Generated from `name` when omitted, because Dokploy's libSQL endpoint does not generate one. Changing it forces a new database.
+	AppName *string `pulumi:"appName"`
+	// Override the container entrypoint command.
+	Command *string `pulumi:"command"`
+	// Hard CPU limit, for example `1`.
+	CpuLimit *string `pulumi:"cpuLimit"`
+	// Soft CPU reservation, for example `0.5`.
+	CpuReservation *string `pulumi:"cpuReservation"`
+	// Password for the database user.
+	DatabasePassword string `pulumi:"databasePassword"`
+	// Database user to create.
+	DatabaseUser string `pulumi:"databaseUser"`
+	// Free-form description.
+	Description *string `pulumi:"description"`
+	// Detach the service from the shared `dokploy-network`.
+	DetachDokployNetwork *bool `pulumi:"detachDokployNetwork"`
+	// libSQL server image to run, for example `ghcr.io/tursodatabase/libsql-server:latest`.
+	DockerImage string `pulumi:"dockerImage"`
+	// Serve multiple logical databases from one instance through libSQL namespaces.
+	EnableNamespaces *bool `pulumi:"enableNamespaces"`
+	// Docker Swarm endpoint specification, as a JSON object.
+	EndpointSpecSwarm *string `pulumi:"endpointSpecSwarm"`
+	// Environment variables in `KEY=value` format, one per line.
+	Env *string `pulumi:"env"`
+	// Environment this database belongs to.
+	EnvironmentId string `pulumi:"environmentId"`
+	// Host port exposing the admin API.
+	ExternalAdminPort *int `pulumi:"externalAdminPort"`
+	// Host port exposing the gRPC replication endpoint.
+	ExternalGrpcPort *int `pulumi:"externalGrpcPort"`
+	// Host port exposing the HTTP API.
+	ExternalPort *int `pulumi:"externalPort"`
+	// Docker Swarm health check configuration, as a JSON object.
+	HealthCheckSwarm *string `pulumi:"healthCheckSwarm"`
+	// Docker Swarm service labels, as a JSON object.
+	LabelsSwarm *string `pulumi:"labelsSwarm"`
+	// Hard memory limit, for example `512m`.
+	MemoryLimit *string `pulumi:"memoryLimit"`
+	// Soft memory reservation, for example `256m`.
+	MemoryReservation *string `pulumi:"memoryReservation"`
+	// Docker Swarm service mode, as a JSON object.
+	ModeSwarm *string `pulumi:"modeSwarm"`
+	// Display name of the database.
+	Name *string `pulumi:"name"`
+	// IDs of additional Docker networks to attach.
+	NetworkIds []string `pulumi:"networkIds"`
+	// Docker Swarm network attachments, as a JSON array.
+	NetworkSwarm *string `pulumi:"networkSwarm"`
+	// Docker Swarm placement constraints, as a JSON object.
+	PlacementSwarm *string `pulumi:"placementSwarm"`
+	// Number of replicas to run.
+	Replicas *int `pulumi:"replicas"`
+	// Docker Swarm restart policy, as a JSON object.
+	RestartPolicySwarm *string `pulumi:"restartPolicySwarm"`
+	// Docker Swarm rollback configuration, as a JSON object.
+	RollbackConfigSwarm *string `pulumi:"rollbackConfigSwarm"`
+	// Remote server to deploy on. Omit to use the Dokploy host itself.
+	ServerId *string `pulumi:"serverId"`
+	// Role this node plays in a libSQL cluster. Valid values: `primary`, `replica`. Defaults to `primary`.
+	SqldNode *string `pulumi:"sqldNode"`
+	// URL of the primary node, when `sqldNode` is `replica`.
+	SqldPrimaryUrl *string `pulumi:"sqldPrimaryUrl"`
+	// Grace period in nanoseconds before a container is killed.
+	StopGracePeriodSwarm *int `pulumi:"stopGracePeriodSwarm"`
+	// Docker Swarm rolling update configuration, as a JSON object.
+	UpdateConfigSwarm *string `pulumi:"updateConfigSwarm"`
+}
+
+// The set of arguments for constructing a Libsql resource.
+type LibsqlArgs struct {
+	// Unique Docker service name. Generated from `name` when omitted, because Dokploy's libSQL endpoint does not generate one. Changing it forces a new database.
+	AppName pulumi.StringPtrInput
+	// Override the container entrypoint command.
+	Command pulumi.StringPtrInput
+	// Hard CPU limit, for example `1`.
+	CpuLimit pulumi.StringPtrInput
+	// Soft CPU reservation, for example `0.5`.
+	CpuReservation pulumi.StringPtrInput
+	// Password for the database user.
+	DatabasePassword pulumi.StringInput
+	// Database user to create.
+	DatabaseUser pulumi.StringInput
+	// Free-form description.
+	Description pulumi.StringPtrInput
+	// Detach the service from the shared `dokploy-network`.
+	DetachDokployNetwork pulumi.BoolPtrInput
+	// libSQL server image to run, for example `ghcr.io/tursodatabase/libsql-server:latest`.
+	DockerImage pulumi.StringInput
+	// Serve multiple logical databases from one instance through libSQL namespaces.
+	EnableNamespaces pulumi.BoolPtrInput
+	// Docker Swarm endpoint specification, as a JSON object.
+	EndpointSpecSwarm pulumi.StringPtrInput
+	// Environment variables in `KEY=value` format, one per line.
+	Env pulumi.StringPtrInput
+	// Environment this database belongs to.
+	EnvironmentId pulumi.StringInput
+	// Host port exposing the admin API.
+	ExternalAdminPort pulumi.IntPtrInput
+	// Host port exposing the gRPC replication endpoint.
+	ExternalGrpcPort pulumi.IntPtrInput
+	// Host port exposing the HTTP API.
+	ExternalPort pulumi.IntPtrInput
+	// Docker Swarm health check configuration, as a JSON object.
+	HealthCheckSwarm pulumi.StringPtrInput
+	// Docker Swarm service labels, as a JSON object.
+	LabelsSwarm pulumi.StringPtrInput
+	// Hard memory limit, for example `512m`.
+	MemoryLimit pulumi.StringPtrInput
+	// Soft memory reservation, for example `256m`.
+	MemoryReservation pulumi.StringPtrInput
+	// Docker Swarm service mode, as a JSON object.
+	ModeSwarm pulumi.StringPtrInput
+	// Display name of the database.
+	Name pulumi.StringPtrInput
+	// IDs of additional Docker networks to attach.
+	NetworkIds pulumi.StringArrayInput
+	// Docker Swarm network attachments, as a JSON array.
+	NetworkSwarm pulumi.StringPtrInput
+	// Docker Swarm placement constraints, as a JSON object.
+	PlacementSwarm pulumi.StringPtrInput
+	// Number of replicas to run.
+	Replicas pulumi.IntPtrInput
+	// Docker Swarm restart policy, as a JSON object.
+	RestartPolicySwarm pulumi.StringPtrInput
+	// Docker Swarm rollback configuration, as a JSON object.
+	RollbackConfigSwarm pulumi.StringPtrInput
+	// Remote server to deploy on. Omit to use the Dokploy host itself.
+	ServerId pulumi.StringPtrInput
+	// Role this node plays in a libSQL cluster. Valid values: `primary`, `replica`. Defaults to `primary`.
+	SqldNode pulumi.StringPtrInput
+	// URL of the primary node, when `sqldNode` is `replica`.
+	SqldPrimaryUrl pulumi.StringPtrInput
+	// Grace period in nanoseconds before a container is killed.
+	StopGracePeriodSwarm pulumi.IntPtrInput
+	// Docker Swarm rolling update configuration, as a JSON object.
+	UpdateConfigSwarm pulumi.StringPtrInput
+}
+
+func (LibsqlArgs) ElementType() reflect.Type {
+	return reflect.TypeOf((*libsqlArgs)(nil)).Elem()
+}
+
+type LibsqlInput interface {
+	pulumi.Input
+
+	ToLibsqlOutput() LibsqlOutput
+	ToLibsqlOutputWithContext(ctx context.Context) LibsqlOutput
+}
+
+func (*Libsql) ElementType() reflect.Type {
+	return reflect.TypeOf((**Libsql)(nil)).Elem()
+}
+
+func (i *Libsql) ToLibsqlOutput() LibsqlOutput {
+	return i.ToLibsqlOutputWithContext(context.Background())
+}
+
+func (i *Libsql) ToLibsqlOutputWithContext(ctx context.Context) LibsqlOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(LibsqlOutput)
+}
+
+// LibsqlArrayInput is an input type that accepts LibsqlArray and LibsqlArrayOutput values.
+// You can construct a concrete instance of `LibsqlArrayInput` via:
+//
+//	LibsqlArray{ LibsqlArgs{...} }
+type LibsqlArrayInput interface {
+	pulumi.Input
+
+	ToLibsqlArrayOutput() LibsqlArrayOutput
+	ToLibsqlArrayOutputWithContext(context.Context) LibsqlArrayOutput
+}
+
+type LibsqlArray []LibsqlInput
+
+func (LibsqlArray) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]*Libsql)(nil)).Elem()
+}
+
+func (i LibsqlArray) ToLibsqlArrayOutput() LibsqlArrayOutput {
+	return i.ToLibsqlArrayOutputWithContext(context.Background())
+}
+
+func (i LibsqlArray) ToLibsqlArrayOutputWithContext(ctx context.Context) LibsqlArrayOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(LibsqlArrayOutput)
+}
+
+// LibsqlMapInput is an input type that accepts LibsqlMap and LibsqlMapOutput values.
+// You can construct a concrete instance of `LibsqlMapInput` via:
+//
+//	LibsqlMap{ "key": LibsqlArgs{...} }
+type LibsqlMapInput interface {
+	pulumi.Input
+
+	ToLibsqlMapOutput() LibsqlMapOutput
+	ToLibsqlMapOutputWithContext(context.Context) LibsqlMapOutput
+}
+
+type LibsqlMap map[string]LibsqlInput
+
+func (LibsqlMap) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]*Libsql)(nil)).Elem()
+}
+
+func (i LibsqlMap) ToLibsqlMapOutput() LibsqlMapOutput {
+	return i.ToLibsqlMapOutputWithContext(context.Background())
+}
+
+func (i LibsqlMap) ToLibsqlMapOutputWithContext(ctx context.Context) LibsqlMapOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(LibsqlMapOutput)
+}
+
+type LibsqlOutput struct{ *pulumi.OutputState }
+
+func (LibsqlOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((**Libsql)(nil)).Elem()
+}
+
+func (o LibsqlOutput) ToLibsqlOutput() LibsqlOutput {
+	return o
+}
+
+func (o LibsqlOutput) ToLibsqlOutputWithContext(ctx context.Context) LibsqlOutput {
+	return o
+}
+
+// Unique Docker service name. Generated from `name` when omitted, because Dokploy's libSQL endpoint does not generate one. Changing it forces a new database.
+func (o LibsqlOutput) AppName() pulumi.StringOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringOutput { return v.AppName }).(pulumi.StringOutput)
+}
+
+// Current status reported by Dokploy: `idle`, `running`, `done` or `error`.
+func (o LibsqlOutput) ApplicationStatus() pulumi.StringOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringOutput { return v.ApplicationStatus }).(pulumi.StringOutput)
+}
+
+// Override the container entrypoint command.
+func (o LibsqlOutput) Command() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.Command }).(pulumi.StringPtrOutput)
+}
+
+// Hard CPU limit, for example `1`.
+func (o LibsqlOutput) CpuLimit() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.CpuLimit }).(pulumi.StringPtrOutput)
+}
+
+// Soft CPU reservation, for example `0.5`.
+func (o LibsqlOutput) CpuReservation() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.CpuReservation }).(pulumi.StringPtrOutput)
+}
+
+// RFC 3339 timestamp of when the database was created.
+func (o LibsqlOutput) CreatedAt() pulumi.StringOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput)
+}
+
+// Password for the database user.
+func (o LibsqlOutput) DatabasePassword() pulumi.StringOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringOutput { return v.DatabasePassword }).(pulumi.StringOutput)
+}
+
+// Database user to create.
+func (o LibsqlOutput) DatabaseUser() pulumi.StringOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringOutput { return v.DatabaseUser }).(pulumi.StringOutput)
+}
+
+// Free-form description.
+func (o LibsqlOutput) Description() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput)
+}
+
+// Detach the service from the shared `dokploy-network`.
+func (o LibsqlOutput) DetachDokployNetwork() pulumi.BoolOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.BoolOutput { return v.DetachDokployNetwork }).(pulumi.BoolOutput)
+}
+
+// libSQL server image to run, for example `ghcr.io/tursodatabase/libsql-server:latest`.
+func (o LibsqlOutput) DockerImage() pulumi.StringOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringOutput { return v.DockerImage }).(pulumi.StringOutput)
+}
+
+// Serve multiple logical databases from one instance through libSQL namespaces.
+func (o LibsqlOutput) EnableNamespaces() pulumi.BoolOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.BoolOutput { return v.EnableNamespaces }).(pulumi.BoolOutput)
+}
+
+// Docker Swarm endpoint specification, as a JSON object.
+func (o LibsqlOutput) EndpointSpecSwarm() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.EndpointSpecSwarm }).(pulumi.StringPtrOutput)
+}
+
+// Environment variables in `KEY=value` format, one per line.
+func (o LibsqlOutput) Env() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.Env }).(pulumi.StringPtrOutput)
+}
+
+// Environment this database belongs to.
+func (o LibsqlOutput) EnvironmentId() pulumi.StringOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringOutput { return v.EnvironmentId }).(pulumi.StringOutput)
+}
+
+// Host port exposing the admin API.
+func (o LibsqlOutput) ExternalAdminPort() pulumi.IntPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.IntPtrOutput { return v.ExternalAdminPort }).(pulumi.IntPtrOutput)
+}
+
+// Host port exposing the gRPC replication endpoint.
+func (o LibsqlOutput) ExternalGrpcPort() pulumi.IntPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.IntPtrOutput { return v.ExternalGrpcPort }).(pulumi.IntPtrOutput)
+}
+
+// Host port exposing the HTTP API.
+func (o LibsqlOutput) ExternalPort() pulumi.IntPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.IntPtrOutput { return v.ExternalPort }).(pulumi.IntPtrOutput)
+}
+
+// Docker Swarm health check configuration, as a JSON object.
+func (o LibsqlOutput) HealthCheckSwarm() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.HealthCheckSwarm }).(pulumi.StringPtrOutput)
+}
+
+// Docker Swarm service labels, as a JSON object.
+func (o LibsqlOutput) LabelsSwarm() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.LabelsSwarm }).(pulumi.StringPtrOutput)
+}
+
+// Hard memory limit, for example `512m`.
+func (o LibsqlOutput) MemoryLimit() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.MemoryLimit }).(pulumi.StringPtrOutput)
+}
+
+// Soft memory reservation, for example `256m`.
+func (o LibsqlOutput) MemoryReservation() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.MemoryReservation }).(pulumi.StringPtrOutput)
+}
+
+// Docker Swarm service mode, as a JSON object.
+func (o LibsqlOutput) ModeSwarm() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.ModeSwarm }).(pulumi.StringPtrOutput)
+}
+
+// Display name of the database.
+func (o LibsqlOutput) Name() pulumi.StringOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput)
+}
+
+// IDs of additional Docker networks to attach.
+func (o LibsqlOutput) NetworkIds() pulumi.StringArrayOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringArrayOutput { return v.NetworkIds }).(pulumi.StringArrayOutput)
+}
+
+// Docker Swarm network attachments, as a JSON array.
+func (o LibsqlOutput) NetworkSwarm() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.NetworkSwarm }).(pulumi.StringPtrOutput)
+}
+
+// Docker Swarm placement constraints, as a JSON object.
+func (o LibsqlOutput) PlacementSwarm() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.PlacementSwarm }).(pulumi.StringPtrOutput)
+}
+
+// Number of replicas to run.
+func (o LibsqlOutput) Replicas() pulumi.IntOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.IntOutput { return v.Replicas }).(pulumi.IntOutput)
+}
+
+// Docker Swarm restart policy, as a JSON object.
+func (o LibsqlOutput) RestartPolicySwarm() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.RestartPolicySwarm }).(pulumi.StringPtrOutput)
+}
+
+// Docker Swarm rollback configuration, as a JSON object.
+func (o LibsqlOutput) RollbackConfigSwarm() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.RollbackConfigSwarm }).(pulumi.StringPtrOutput)
+}
+
+// Remote server to deploy on. Omit to use the Dokploy host itself.
+func (o LibsqlOutput) ServerId() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.ServerId }).(pulumi.StringPtrOutput)
+}
+
+// Role this node plays in a libSQL cluster. Valid values: `primary`, `replica`. Defaults to `primary`.
+func (o LibsqlOutput) SqldNode() pulumi.StringOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringOutput { return v.SqldNode }).(pulumi.StringOutput)
+}
+
+// URL of the primary node, when `sqldNode` is `replica`.
+func (o LibsqlOutput) SqldPrimaryUrl() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.SqldPrimaryUrl }).(pulumi.StringPtrOutput)
+}
+
+// Grace period in nanoseconds before a container is killed.
+func (o LibsqlOutput) StopGracePeriodSwarm() pulumi.IntPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.IntPtrOutput { return v.StopGracePeriodSwarm }).(pulumi.IntPtrOutput)
+}
+
+// Docker Swarm rolling update configuration, as a JSON object.
+func (o LibsqlOutput) UpdateConfigSwarm() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Libsql) pulumi.StringPtrOutput { return v.UpdateConfigSwarm }).(pulumi.StringPtrOutput)
+}
+
+type LibsqlArrayOutput struct{ *pulumi.OutputState }
+
+func (LibsqlArrayOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]*Libsql)(nil)).Elem()
+}
+
+func (o LibsqlArrayOutput) ToLibsqlArrayOutput() LibsqlArrayOutput {
+	return o
+}
+
+func (o LibsqlArrayOutput) ToLibsqlArrayOutputWithContext(ctx context.Context) LibsqlArrayOutput {
+	return o
+}
+
+func (o LibsqlArrayOutput) Index(i pulumi.IntInput) LibsqlOutput {
+	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Libsql {
+		return vs[0].([]*Libsql)[vs[1].(int)]
+	}).(LibsqlOutput)
+}
+
+type LibsqlMapOutput struct{ *pulumi.OutputState }
+
+func (LibsqlMapOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]*Libsql)(nil)).Elem()
+}
+
+func (o LibsqlMapOutput) ToLibsqlMapOutput() LibsqlMapOutput {
+	return o
+}
+
+func (o LibsqlMapOutput) ToLibsqlMapOutputWithContext(ctx context.Context) LibsqlMapOutput {
+	return o
+}
+
+func (o LibsqlMapOutput) MapIndex(k pulumi.StringInput) LibsqlOutput {
+	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Libsql {
+		return vs[0].(map[string]*Libsql)[vs[1].(string)]
+	}).(LibsqlOutput)
+}
+
+func init() {
+	pulumi.RegisterInputType(reflect.TypeOf((*LibsqlInput)(nil)).Elem(), &Libsql{})
+	pulumi.RegisterInputType(reflect.TypeOf((*LibsqlArrayInput)(nil)).Elem(), LibsqlArray{})
+	pulumi.RegisterInputType(reflect.TypeOf((*LibsqlMapInput)(nil)).Elem(), LibsqlMap{})
+	pulumi.RegisterOutputType(LibsqlOutput{})
+	pulumi.RegisterOutputType(LibsqlArrayOutput{})
+	pulumi.RegisterOutputType(LibsqlMapOutput{})
+}

sdk/go/dokploy/mariaDb.go

@@ -12,6 +12,11 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// A managed MariaDB instance running on Dokploy.
+//
+// > Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+//
+// > Credentials are stored in Terraform state. Use a state backend with encryption at rest.
 type MariaDb struct {
 	pulumi.CustomResourceState
 

sdk/go/dokploy/mongo.go

@@ -12,6 +12,11 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// A managed MongoDB instance running on Dokploy.
+//
+// > Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+//
+// > Credentials are stored in Terraform state. Use a state backend with encryption at rest.
 type Mongo struct {
 	pulumi.CustomResourceState
 

sdk/go/dokploy/mount.go

@@ -12,6 +12,13 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// A volume, bind mount, or config file attached to a Dokploy service.
+//
+// * `type = "volume"` — a named Docker volume; set `volumeName`.
+// * `type = "bind"` — a path on the host; set `hostPath`.
+// * `type = "file"` — a file rendered from `content`; set `filePath`.
+//
+// > **A `volume` mount must set `volumeName`.** Dokploy hands an unset name to Docker as an empty source, which creates a fresh anonymous volume on every deploy and orphans the previous one — the data never survives a redeploy. The provider rejects that combination at plan time.
 type Mount struct {
 	pulumi.CustomResourceState
 
@@ -25,7 +32,7 @@ type Mount struct {
 	MountPath pulumi.StringOutput `pulumi:"mountPath"`
 	// ID of the service this mount attaches to. Must match `serviceType` — an application ID, a compose ID, a postgres ID, and so on.
 	ServiceId pulumi.StringOutput `pulumi:"serviceId"`
-	// The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`.
+	// The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`, `libsql`.
 	ServiceType pulumi.StringOutput `pulumi:"serviceType"`
 	// The kind of mount to create. Valid values: `bind`, `volume`, `file`.
 	Type pulumi.StringOutput `pulumi:"type"`
@@ -85,7 +92,7 @@ type mountState struct {
 	MountPath *string `pulumi:"mountPath"`
 	// ID of the service this mount attaches to. Must match `serviceType` — an application ID, a compose ID, a postgres ID, and so on.
 	ServiceId *string `pulumi:"serviceId"`
-	// The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`.
+	// The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`, `libsql`.
 	ServiceType *string `pulumi:"serviceType"`
 	// The kind of mount to create. Valid values: `bind`, `volume`, `file`.
 	Type *string `pulumi:"type"`
@@ -104,7 +111,7 @@ type MountState struct {
 	MountPath pulumi.StringPtrInput
 	// ID of the service this mount attaches to. Must match `serviceType` — an application ID, a compose ID, a postgres ID, and so on.
 	ServiceId pulumi.StringPtrInput
-	// The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`.
+	// The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`, `libsql`.
 	ServiceType pulumi.StringPtrInput
 	// The kind of mount to create. Valid values: `bind`, `volume`, `file`.
 	Type pulumi.StringPtrInput
@@ -127,7 +134,7 @@ type mountArgs struct {
 	MountPath string `pulumi:"mountPath"`
 	// ID of the service this mount attaches to. Must match `serviceType` — an application ID, a compose ID, a postgres ID, and so on.
 	ServiceId string `pulumi:"serviceId"`
-	// The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`.
+	// The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`, `libsql`.
 	ServiceType string `pulumi:"serviceType"`
 	// The kind of mount to create. Valid values: `bind`, `volume`, `file`.
 	Type string `pulumi:"type"`
@@ -147,7 +154,7 @@ type MountArgs struct {
 	MountPath pulumi.StringInput
 	// ID of the service this mount attaches to. Must match `serviceType` — an application ID, a compose ID, a postgres ID, and so on.
 	ServiceId pulumi.StringInput
-	// The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`.
+	// The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`, `libsql`.
 	ServiceType pulumi.StringInput
 	// The kind of mount to create. Valid values: `bind`, `volume`, `file`.
 	Type pulumi.StringInput
@@ -267,7 +274,7 @@ func (o MountOutput) ServiceId() pulumi.StringOutput {
 	return o.ApplyT(func(v *Mount) pulumi.StringOutput { return v.ServiceId }).(pulumi.StringOutput)
 }
 
-// The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`.
+// The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`, `libsql`.
 func (o MountOutput) ServiceType() pulumi.StringOutput {
 	return o.ApplyT(func(v *Mount) pulumi.StringOutput { return v.ServiceType }).(pulumi.StringOutput)
 }

sdk/go/dokploy/mySql.go

@@ -12,6 +12,11 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// A managed MySQL instance running on Dokploy.
+//
+// > Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+//
+// > Credentials are stored in Terraform state. Use a state backend with encryption at rest.
 type MySql struct {
 	pulumi.CustomResourceState
 

sdk/go/dokploy/network.go

@@ -0,0 +1,361 @@
+// Code generated by pulumi-language-go DO NOT EDIT.
+// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***
+
+package dokploy
+
+import (
+	"context"
+	"reflect"
+
+	"github.com/maxvojtkov/pulumi-dokploy/sdk/go/dokploy/internal"
+	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+)
+
+// A Docker network managed by Dokploy.
+//
+// Attach services to it with `networkIds` on `Application`, `Compose` and the database resources. Every service also joins the shared `dokploy-network` unless `detachDokployNetwork` is set.
+//
+// > Docker networks are immutable. Dokploy has no update endpoint, so changing any attribute replaces the network — which detaches the services currently using it until they redeploy.
+type Network struct {
+	pulumi.CustomResourceState
+
+	// Allow standalone containers to attach to an overlay network.
+	Attachable pulumi.BoolOutput `pulumi:"attachable"`
+	// RFC 3339 timestamp of when the network was created.
+	CreatedAt pulumi.StringOutput `pulumi:"createdAt"`
+	// Network driver. Use `overlay` for multi-node Swarm clusters and `bridge` for a single host. Valid values: `bridge`, `overlay`.
+	Driver pulumi.StringOutput `pulumi:"driver"`
+	// Enable IPv4 address allocation.
+	EnableIpv4 pulumi.BoolOutput `pulumi:"enableIpv4"`
+	// Enable IPv6 address allocation.
+	EnableIpv6 pulumi.BoolOutput `pulumi:"enableIpv6"`
+	// Isolate the network from external access.
+	Internal pulumi.BoolOutput `pulumi:"internal"`
+	// Custom IP address management, as a JSON object with `subnet`, `gateway` and `ipRange` keys. Leave unset to let Docker choose a subnet.
+	Ipam pulumi.StringPtrOutput `pulumi:"ipam"`
+	// Maximum transmission unit for the network. Leave unset to use Docker's default.
+	Mtu pulumi.IntPtrOutput `pulumi:"mtu"`
+	// Name of the Docker network.
+	Name pulumi.StringOutput `pulumi:"name"`
+	// Organization that owns the network.
+	OrganizationId pulumi.StringOutput `pulumi:"organizationId"`
+	// Remote server to create the network on. Omit to use the Dokploy host itself.
+	ServerId pulumi.StringPtrOutput `pulumi:"serverId"`
+}
+
+// NewNetwork registers a new resource with the given unique name, arguments, and options.
+func NewNetwork(ctx *pulumi.Context,
+	name string, args *NetworkArgs, opts ...pulumi.ResourceOption) (*Network, error) {
+	if args == nil {
+		args = &NetworkArgs{}
+	}
+
+	opts = internal.PkgResourceDefaultOpts(opts)
+	var resource Network
+	err := ctx.RegisterResource("dokploy:index/network:Network", name, args, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// GetNetwork gets an existing Network resource's state with the given name, ID, and optional
+// state properties that are used to uniquely qualify the lookup (nil if not required).
+func GetNetwork(ctx *pulumi.Context,
+	name string, id pulumi.IDInput, state *NetworkState, opts ...pulumi.ResourceOption) (*Network, error) {
+	var resource Network
+	err := ctx.ReadResource("dokploy:index/network:Network", name, id, state, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// Input properties used for looking up and filtering Network resources.
+type networkState struct {
+	// Allow standalone containers to attach to an overlay network.
+	Attachable *bool `pulumi:"attachable"`
+	// RFC 3339 timestamp of when the network was created.
+	CreatedAt *string `pulumi:"createdAt"`
+	// Network driver. Use `overlay` for multi-node Swarm clusters and `bridge` for a single host. Valid values: `bridge`, `overlay`.
+	Driver *string `pulumi:"driver"`
+	// Enable IPv4 address allocation.
+	EnableIpv4 *bool `pulumi:"enableIpv4"`
+	// Enable IPv6 address allocation.
+	EnableIpv6 *bool `pulumi:"enableIpv6"`
+	// Isolate the network from external access.
+	Internal *bool `pulumi:"internal"`
+	// Custom IP address management, as a JSON object with `subnet`, `gateway` and `ipRange` keys. Leave unset to let Docker choose a subnet.
+	Ipam *string `pulumi:"ipam"`
+	// Maximum transmission unit for the network. Leave unset to use Docker's default.
+	Mtu *int `pulumi:"mtu"`
+	// Name of the Docker network.
+	Name *string `pulumi:"name"`
+	// Organization that owns the network.
+	OrganizationId *string `pulumi:"organizationId"`
+	// Remote server to create the network on. Omit to use the Dokploy host itself.
+	ServerId *string `pulumi:"serverId"`
+}
+
+type NetworkState struct {
+	// Allow standalone containers to attach to an overlay network.
+	Attachable pulumi.BoolPtrInput
+	// RFC 3339 timestamp of when the network was created.
+	CreatedAt pulumi.StringPtrInput
+	// Network driver. Use `overlay` for multi-node Swarm clusters and `bridge` for a single host. Valid values: `bridge`, `overlay`.
+	Driver pulumi.StringPtrInput
+	// Enable IPv4 address allocation.
+	EnableIpv4 pulumi.BoolPtrInput
+	// Enable IPv6 address allocation.
+	EnableIpv6 pulumi.BoolPtrInput
+	// Isolate the network from external access.
+	Internal pulumi.BoolPtrInput
+	// Custom IP address management, as a JSON object with `subnet`, `gateway` and `ipRange` keys. Leave unset to let Docker choose a subnet.
+	Ipam pulumi.StringPtrInput
+	// Maximum transmission unit for the network. Leave unset to use Docker's default.
+	Mtu pulumi.IntPtrInput
+	// Name of the Docker network.
+	Name pulumi.StringPtrInput
+	// Organization that owns the network.
+	OrganizationId pulumi.StringPtrInput
+	// Remote server to create the network on. Omit to use the Dokploy host itself.
+	ServerId pulumi.StringPtrInput
+}
+
+func (NetworkState) ElementType() reflect.Type {
+	return reflect.TypeOf((*networkState)(nil)).Elem()
+}
+
+type networkArgs struct {
+	// Allow standalone containers to attach to an overlay network.
+	Attachable *bool `pulumi:"attachable"`
+	// Network driver. Use `overlay` for multi-node Swarm clusters and `bridge` for a single host. Valid values: `bridge`, `overlay`.
+	Driver *string `pulumi:"driver"`
+	// Enable IPv4 address allocation.
+	EnableIpv4 *bool `pulumi:"enableIpv4"`
+	// Enable IPv6 address allocation.
+	EnableIpv6 *bool `pulumi:"enableIpv6"`
+	// Isolate the network from external access.
+	Internal *bool `pulumi:"internal"`
+	// Custom IP address management, as a JSON object with `subnet`, `gateway` and `ipRange` keys. Leave unset to let Docker choose a subnet.
+	Ipam *string `pulumi:"ipam"`
+	// Maximum transmission unit for the network. Leave unset to use Docker's default.
+	Mtu *int `pulumi:"mtu"`
+	// Name of the Docker network.
+	Name *string `pulumi:"name"`
+	// Remote server to create the network on. Omit to use the Dokploy host itself.
+	ServerId *string `pulumi:"serverId"`
+}
+
+// The set of arguments for constructing a Network resource.
+type NetworkArgs struct {
+	// Allow standalone containers to attach to an overlay network.
+	Attachable pulumi.BoolPtrInput
+	// Network driver. Use `overlay` for multi-node Swarm clusters and `bridge` for a single host. Valid values: `bridge`, `overlay`.
+	Driver pulumi.StringPtrInput
+	// Enable IPv4 address allocation.
+	EnableIpv4 pulumi.BoolPtrInput
+	// Enable IPv6 address allocation.
+	EnableIpv6 pulumi.BoolPtrInput
+	// Isolate the network from external access.
+	Internal pulumi.BoolPtrInput
+	// Custom IP address management, as a JSON object with `subnet`, `gateway` and `ipRange` keys. Leave unset to let Docker choose a subnet.
+	Ipam pulumi.StringPtrInput
+	// Maximum transmission unit for the network. Leave unset to use Docker's default.
+	Mtu pulumi.IntPtrInput
+	// Name of the Docker network.
+	Name pulumi.StringPtrInput
+	// Remote server to create the network on. Omit to use the Dokploy host itself.
+	ServerId pulumi.StringPtrInput
+}
+
+func (NetworkArgs) ElementType() reflect.Type {
+	return reflect.TypeOf((*networkArgs)(nil)).Elem()
+}
+
+type NetworkInput interface {
+	pulumi.Input
+
+	ToNetworkOutput() NetworkOutput
+	ToNetworkOutputWithContext(ctx context.Context) NetworkOutput
+}
+
+func (*Network) ElementType() reflect.Type {
+	return reflect.TypeOf((**Network)(nil)).Elem()
+}
+
+func (i *Network) ToNetworkOutput() NetworkOutput {
+	return i.ToNetworkOutputWithContext(context.Background())
+}
+
+func (i *Network) ToNetworkOutputWithContext(ctx context.Context) NetworkOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(NetworkOutput)
+}
+
+// NetworkArrayInput is an input type that accepts NetworkArray and NetworkArrayOutput values.
+// You can construct a concrete instance of `NetworkArrayInput` via:
+//
+//	NetworkArray{ NetworkArgs{...} }
+type NetworkArrayInput interface {
+	pulumi.Input
+
+	ToNetworkArrayOutput() NetworkArrayOutput
+	ToNetworkArrayOutputWithContext(context.Context) NetworkArrayOutput
+}
+
+type NetworkArray []NetworkInput
+
+func (NetworkArray) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]*Network)(nil)).Elem()
+}
+
+func (i NetworkArray) ToNetworkArrayOutput() NetworkArrayOutput {
+	return i.ToNetworkArrayOutputWithContext(context.Background())
+}
+
+func (i NetworkArray) ToNetworkArrayOutputWithContext(ctx context.Context) NetworkArrayOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(NetworkArrayOutput)
+}
+
+// NetworkMapInput is an input type that accepts NetworkMap and NetworkMapOutput values.
+// You can construct a concrete instance of `NetworkMapInput` via:
+//
+//	NetworkMap{ "key": NetworkArgs{...} }
+type NetworkMapInput interface {
+	pulumi.Input
+
+	ToNetworkMapOutput() NetworkMapOutput
+	ToNetworkMapOutputWithContext(context.Context) NetworkMapOutput
+}
+
+type NetworkMap map[string]NetworkInput
+
+func (NetworkMap) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]*Network)(nil)).Elem()
+}
+
+func (i NetworkMap) ToNetworkMapOutput() NetworkMapOutput {
+	return i.ToNetworkMapOutputWithContext(context.Background())
+}
+
+func (i NetworkMap) ToNetworkMapOutputWithContext(ctx context.Context) NetworkMapOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(NetworkMapOutput)
+}
+
+type NetworkOutput struct{ *pulumi.OutputState }
+
+func (NetworkOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((**Network)(nil)).Elem()
+}
+
+func (o NetworkOutput) ToNetworkOutput() NetworkOutput {
+	return o
+}
+
+func (o NetworkOutput) ToNetworkOutputWithContext(ctx context.Context) NetworkOutput {
+	return o
+}
+
+// Allow standalone containers to attach to an overlay network.
+func (o NetworkOutput) Attachable() pulumi.BoolOutput {
+	return o.ApplyT(func(v *Network) pulumi.BoolOutput { return v.Attachable }).(pulumi.BoolOutput)
+}
+
+// RFC 3339 timestamp of when the network was created.
+func (o NetworkOutput) CreatedAt() pulumi.StringOutput {
+	return o.ApplyT(func(v *Network) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput)
+}
+
+// Network driver. Use `overlay` for multi-node Swarm clusters and `bridge` for a single host. Valid values: `bridge`, `overlay`.
+func (o NetworkOutput) Driver() pulumi.StringOutput {
+	return o.ApplyT(func(v *Network) pulumi.StringOutput { return v.Driver }).(pulumi.StringOutput)
+}
+
+// Enable IPv4 address allocation.
+func (o NetworkOutput) EnableIpv4() pulumi.BoolOutput {
+	return o.ApplyT(func(v *Network) pulumi.BoolOutput { return v.EnableIpv4 }).(pulumi.BoolOutput)
+}
+
+// Enable IPv6 address allocation.
+func (o NetworkOutput) EnableIpv6() pulumi.BoolOutput {
+	return o.ApplyT(func(v *Network) pulumi.BoolOutput { return v.EnableIpv6 }).(pulumi.BoolOutput)
+}
+
+// Isolate the network from external access.
+func (o NetworkOutput) Internal() pulumi.BoolOutput {
+	return o.ApplyT(func(v *Network) pulumi.BoolOutput { return v.Internal }).(pulumi.BoolOutput)
+}
+
+// Custom IP address management, as a JSON object with `subnet`, `gateway` and `ipRange` keys. Leave unset to let Docker choose a subnet.
+func (o NetworkOutput) Ipam() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Network) pulumi.StringPtrOutput { return v.Ipam }).(pulumi.StringPtrOutput)
+}
+
+// Maximum transmission unit for the network. Leave unset to use Docker's default.
+func (o NetworkOutput) Mtu() pulumi.IntPtrOutput {
+	return o.ApplyT(func(v *Network) pulumi.IntPtrOutput { return v.Mtu }).(pulumi.IntPtrOutput)
+}
+
+// Name of the Docker network.
+func (o NetworkOutput) Name() pulumi.StringOutput {
+	return o.ApplyT(func(v *Network) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput)
+}
+
+// Organization that owns the network.
+func (o NetworkOutput) OrganizationId() pulumi.StringOutput {
+	return o.ApplyT(func(v *Network) pulumi.StringOutput { return v.OrganizationId }).(pulumi.StringOutput)
+}
+
+// Remote server to create the network on. Omit to use the Dokploy host itself.
+func (o NetworkOutput) ServerId() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Network) pulumi.StringPtrOutput { return v.ServerId }).(pulumi.StringPtrOutput)
+}
+
+type NetworkArrayOutput struct{ *pulumi.OutputState }
+
+func (NetworkArrayOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]*Network)(nil)).Elem()
+}
+
+func (o NetworkArrayOutput) ToNetworkArrayOutput() NetworkArrayOutput {
+	return o
+}
+
+func (o NetworkArrayOutput) ToNetworkArrayOutputWithContext(ctx context.Context) NetworkArrayOutput {
+	return o
+}
+
+func (o NetworkArrayOutput) Index(i pulumi.IntInput) NetworkOutput {
+	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Network {
+		return vs[0].([]*Network)[vs[1].(int)]
+	}).(NetworkOutput)
+}
+
+type NetworkMapOutput struct{ *pulumi.OutputState }
+
+func (NetworkMapOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]*Network)(nil)).Elem()
+}
+
+func (o NetworkMapOutput) ToNetworkMapOutput() NetworkMapOutput {
+	return o
+}
+
+func (o NetworkMapOutput) ToNetworkMapOutputWithContext(ctx context.Context) NetworkMapOutput {
+	return o
+}
+
+func (o NetworkMapOutput) MapIndex(k pulumi.StringInput) NetworkOutput {
+	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Network {
+		return vs[0].(map[string]*Network)[vs[1].(string)]
+	}).(NetworkOutput)
+}
+
+func init() {
+	pulumi.RegisterInputType(reflect.TypeOf((*NetworkInput)(nil)).Elem(), &Network{})
+	pulumi.RegisterInputType(reflect.TypeOf((*NetworkArrayInput)(nil)).Elem(), NetworkArray{})
+	pulumi.RegisterInputType(reflect.TypeOf((*NetworkMapInput)(nil)).Elem(), NetworkMap{})
+	pulumi.RegisterOutputType(NetworkOutput{})
+	pulumi.RegisterOutputType(NetworkArrayOutput{})
+	pulumi.RegisterOutputType(NetworkMapOutput{})
+}

sdk/go/dokploy/port.go

@@ -12,6 +12,7 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// A published port that exposes an application directly on the host, bypassing Traefik.
 type Port struct {
 	pulumi.CustomResourceState
 

sdk/go/dokploy/postgres.go

@@ -12,6 +12,11 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// A managed PostgreSQL instance running on Dokploy.
+//
+// > Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+//
+// > Credentials are stored in Terraform state. Use a state backend with encryption at rest.
 type Postgres struct {
 	pulumi.CustomResourceState
 

sdk/go/dokploy/project.go

@@ -11,6 +11,9 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// A Dokploy project: the top-level container for environments and services.
+//
+// Creating a project automatically creates a default `production` environment. Its ID is exposed as `defaultEnvironmentId`, so services can be attached without declaring a separate `Environment` resource.
 type Project struct {
 	pulumi.CustomResourceState
 

sdk/go/dokploy/pulumi-plugin.json

@@ -1,6 +1,6 @@
 {
   "resource": true,
   "name": "dokploy",
-  "version": "0.1.0",
+  "version": "0.2.0",
   "server": "https://gitea.coolify.vojtkov.dev/usr_unknown/pulumi-dokploy/releases/download/v${VERSION}"
 }

sdk/go/dokploy/redirect.go

@@ -12,6 +12,7 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// A Traefik redirect rule attached to an application.
 type Redirect struct {
 	pulumi.CustomResourceState
 

sdk/go/dokploy/redis.go

@@ -12,6 +12,11 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// A managed Redis instance running on Dokploy.
+//
+// > Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+//
+// > Credentials are stored in Terraform state. Use a state backend with encryption at rest.
 type Redis struct {
 	pulumi.CustomResourceState
 

sdk/go/dokploy/registry.go

@@ -12,6 +12,7 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// A container registry that Dokploy pushes built images to and pulls them from.
 type Registry struct {
 	pulumi.CustomResourceState
 

sdk/go/dokploy/schedule.go

@@ -0,0 +1,437 @@
+// Code generated by pulumi-language-go DO NOT EDIT.
+// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***
+
+package dokploy
+
+import (
+	"context"
+	"reflect"
+
+	"errors"
+	"github.com/maxvojtkov/pulumi-dokploy/sdk/go/dokploy/internal"
+	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+)
+
+// A cron job Dokploy runs on a schedule.
+//
+// `scheduleType` selects where the command runs:
+//
+// * `application` — inside a running application container; set `applicationId`.
+// * `compose` — inside one service of a Compose stack; set `composeId` and `serviceName`.
+// * `server` — on a remote server; set `serverId`.
+// * `dokploy-server` — on the Dokploy host itself.
+//
+// > A schedule targeting an application runs inside its container, so the container has to be running when the cron fires.
+type Schedule struct {
+	pulumi.CustomResourceState
+
+	// Docker service name the schedule targets. Derived by Dokploy when omitted.
+	AppName pulumi.StringOutput `pulumi:"appName"`
+	// Application this schedule belongs to.
+	ApplicationId pulumi.StringPtrOutput `pulumi:"applicationId"`
+	// Command to run.
+	Command pulumi.StringOutput `pulumi:"command"`
+	// Compose stack this schedule belongs to.
+	ComposeId pulumi.StringPtrOutput `pulumi:"composeId"`
+	// RFC 3339 timestamp of when the schedule was created.
+	CreatedAt pulumi.StringOutput `pulumi:"createdAt"`
+	// Standard five-field cron expression, for example `0 3 * * *`.
+	CronExpression pulumi.StringOutput `pulumi:"cronExpression"`
+	// Free-form description.
+	Description pulumi.StringPtrOutput `pulumi:"description"`
+	// Whether the schedule is active.
+	Enabled pulumi.BoolOutput `pulumi:"enabled"`
+	// Display name of the schedule.
+	Name pulumi.StringOutput `pulumi:"name"`
+	// Where the command runs. Valid values: `application`, `compose`, `server`, `dokploy-server`. Defaults to `application`.
+	ScheduleType pulumi.StringOutput `pulumi:"scheduleType"`
+	// Multi-line script to run instead of a single command.
+	Script pulumi.StringPtrOutput `pulumi:"script"`
+	// Server this schedule runs on.
+	ServerId pulumi.StringPtrOutput `pulumi:"serverId"`
+	// Service inside a Compose stack to run the command in.
+	ServiceName pulumi.StringPtrOutput `pulumi:"serviceName"`
+	// Shell used to interpret the command. Valid values: `bash`, `sh`. Defaults to `bash`.
+	ShellType pulumi.StringOutput `pulumi:"shellType"`
+	// IANA timezone the cron expression is evaluated in, for example `Europe/Berlin`.
+	Timezone pulumi.StringPtrOutput `pulumi:"timezone"`
+}
+
+// NewSchedule registers a new resource with the given unique name, arguments, and options.
+func NewSchedule(ctx *pulumi.Context,
+	name string, args *ScheduleArgs, opts ...pulumi.ResourceOption) (*Schedule, error) {
+	if args == nil {
+		return nil, errors.New("missing one or more required arguments")
+	}
+
+	if args.Command == nil {
+		return nil, errors.New("invalid value for required argument 'Command'")
+	}
+	if args.CronExpression == nil {
+		return nil, errors.New("invalid value for required argument 'CronExpression'")
+	}
+	opts = internal.PkgResourceDefaultOpts(opts)
+	var resource Schedule
+	err := ctx.RegisterResource("dokploy:index/schedule:Schedule", name, args, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// GetSchedule gets an existing Schedule resource's state with the given name, ID, and optional
+// state properties that are used to uniquely qualify the lookup (nil if not required).
+func GetSchedule(ctx *pulumi.Context,
+	name string, id pulumi.IDInput, state *ScheduleState, opts ...pulumi.ResourceOption) (*Schedule, error) {
+	var resource Schedule
+	err := ctx.ReadResource("dokploy:index/schedule:Schedule", name, id, state, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// Input properties used for looking up and filtering Schedule resources.
+type scheduleState struct {
+	// Docker service name the schedule targets. Derived by Dokploy when omitted.
+	AppName *string `pulumi:"appName"`
+	// Application this schedule belongs to.
+	ApplicationId *string `pulumi:"applicationId"`
+	// Command to run.
+	Command *string `pulumi:"command"`
+	// Compose stack this schedule belongs to.
+	ComposeId *string `pulumi:"composeId"`
+	// RFC 3339 timestamp of when the schedule was created.
+	CreatedAt *string `pulumi:"createdAt"`
+	// Standard five-field cron expression, for example `0 3 * * *`.
+	CronExpression *string `pulumi:"cronExpression"`
+	// Free-form description.
+	Description *string `pulumi:"description"`
+	// Whether the schedule is active.
+	Enabled *bool `pulumi:"enabled"`
+	// Display name of the schedule.
+	Name *string `pulumi:"name"`
+	// Where the command runs. Valid values: `application`, `compose`, `server`, `dokploy-server`. Defaults to `application`.
+	ScheduleType *string `pulumi:"scheduleType"`
+	// Multi-line script to run instead of a single command.
+	Script *string `pulumi:"script"`
+	// Server this schedule runs on.
+	ServerId *string `pulumi:"serverId"`
+	// Service inside a Compose stack to run the command in.
+	ServiceName *string `pulumi:"serviceName"`
+	// Shell used to interpret the command. Valid values: `bash`, `sh`. Defaults to `bash`.
+	ShellType *string `pulumi:"shellType"`
+	// IANA timezone the cron expression is evaluated in, for example `Europe/Berlin`.
+	Timezone *string `pulumi:"timezone"`
+}
+
+type ScheduleState struct {
+	// Docker service name the schedule targets. Derived by Dokploy when omitted.
+	AppName pulumi.StringPtrInput
+	// Application this schedule belongs to.
+	ApplicationId pulumi.StringPtrInput
+	// Command to run.
+	Command pulumi.StringPtrInput
+	// Compose stack this schedule belongs to.
+	ComposeId pulumi.StringPtrInput
+	// RFC 3339 timestamp of when the schedule was created.
+	CreatedAt pulumi.StringPtrInput
+	// Standard five-field cron expression, for example `0 3 * * *`.
+	CronExpression pulumi.StringPtrInput
+	// Free-form description.
+	Description pulumi.StringPtrInput
+	// Whether the schedule is active.
+	Enabled pulumi.BoolPtrInput
+	// Display name of the schedule.
+	Name pulumi.StringPtrInput
+	// Where the command runs. Valid values: `application`, `compose`, `server`, `dokploy-server`. Defaults to `application`.
+	ScheduleType pulumi.StringPtrInput
+	// Multi-line script to run instead of a single command.
+	Script pulumi.StringPtrInput
+	// Server this schedule runs on.
+	ServerId pulumi.StringPtrInput
+	// Service inside a Compose stack to run the command in.
+	ServiceName pulumi.StringPtrInput
+	// Shell used to interpret the command. Valid values: `bash`, `sh`. Defaults to `bash`.
+	ShellType pulumi.StringPtrInput
+	// IANA timezone the cron expression is evaluated in, for example `Europe/Berlin`.
+	Timezone pulumi.StringPtrInput
+}
+
+func (ScheduleState) ElementType() reflect.Type {
+	return reflect.TypeOf((*scheduleState)(nil)).Elem()
+}
+
+type scheduleArgs struct {
+	// Docker service name the schedule targets. Derived by Dokploy when omitted.
+	AppName *string `pulumi:"appName"`
+	// Application this schedule belongs to.
+	ApplicationId *string `pulumi:"applicationId"`
+	// Command to run.
+	Command string `pulumi:"command"`
+	// Compose stack this schedule belongs to.
+	ComposeId *string `pulumi:"composeId"`
+	// Standard five-field cron expression, for example `0 3 * * *`.
+	CronExpression string `pulumi:"cronExpression"`
+	// Free-form description.
+	Description *string `pulumi:"description"`
+	// Whether the schedule is active.
+	Enabled *bool `pulumi:"enabled"`
+	// Display name of the schedule.
+	Name *string `pulumi:"name"`
+	// Where the command runs. Valid values: `application`, `compose`, `server`, `dokploy-server`. Defaults to `application`.
+	ScheduleType *string `pulumi:"scheduleType"`
+	// Multi-line script to run instead of a single command.
+	Script *string `pulumi:"script"`
+	// Server this schedule runs on.
+	ServerId *string `pulumi:"serverId"`
+	// Service inside a Compose stack to run the command in.
+	ServiceName *string `pulumi:"serviceName"`
+	// Shell used to interpret the command. Valid values: `bash`, `sh`. Defaults to `bash`.
+	ShellType *string `pulumi:"shellType"`
+	// IANA timezone the cron expression is evaluated in, for example `Europe/Berlin`.
+	Timezone *string `pulumi:"timezone"`
+}
+
+// The set of arguments for constructing a Schedule resource.
+type ScheduleArgs struct {
+	// Docker service name the schedule targets. Derived by Dokploy when omitted.
+	AppName pulumi.StringPtrInput
+	// Application this schedule belongs to.
+	ApplicationId pulumi.StringPtrInput
+	// Command to run.
+	Command pulumi.StringInput
+	// Compose stack this schedule belongs to.
+	ComposeId pulumi.StringPtrInput
+	// Standard five-field cron expression, for example `0 3 * * *`.
+	CronExpression pulumi.StringInput
+	// Free-form description.
+	Description pulumi.StringPtrInput
+	// Whether the schedule is active.
+	Enabled pulumi.BoolPtrInput
+	// Display name of the schedule.
+	Name pulumi.StringPtrInput
+	// Where the command runs. Valid values: `application`, `compose`, `server`, `dokploy-server`. Defaults to `application`.
+	ScheduleType pulumi.StringPtrInput
+	// Multi-line script to run instead of a single command.
+	Script pulumi.StringPtrInput
+	// Server this schedule runs on.
+	ServerId pulumi.StringPtrInput
+	// Service inside a Compose stack to run the command in.
+	ServiceName pulumi.StringPtrInput
+	// Shell used to interpret the command. Valid values: `bash`, `sh`. Defaults to `bash`.
+	ShellType pulumi.StringPtrInput
+	// IANA timezone the cron expression is evaluated in, for example `Europe/Berlin`.
+	Timezone pulumi.StringPtrInput
+}
+
+func (ScheduleArgs) ElementType() reflect.Type {
+	return reflect.TypeOf((*scheduleArgs)(nil)).Elem()
+}
+
+type ScheduleInput interface {
+	pulumi.Input
+
+	ToScheduleOutput() ScheduleOutput
+	ToScheduleOutputWithContext(ctx context.Context) ScheduleOutput
+}
+
+func (*Schedule) ElementType() reflect.Type {
+	return reflect.TypeOf((**Schedule)(nil)).Elem()
+}
+
+func (i *Schedule) ToScheduleOutput() ScheduleOutput {
+	return i.ToScheduleOutputWithContext(context.Background())
+}
+
+func (i *Schedule) ToScheduleOutputWithContext(ctx context.Context) ScheduleOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ScheduleOutput)
+}
+
+// ScheduleArrayInput is an input type that accepts ScheduleArray and ScheduleArrayOutput values.
+// You can construct a concrete instance of `ScheduleArrayInput` via:
+//
+//	ScheduleArray{ ScheduleArgs{...} }
+type ScheduleArrayInput interface {
+	pulumi.Input
+
+	ToScheduleArrayOutput() ScheduleArrayOutput
+	ToScheduleArrayOutputWithContext(context.Context) ScheduleArrayOutput
+}
+
+type ScheduleArray []ScheduleInput
+
+func (ScheduleArray) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]*Schedule)(nil)).Elem()
+}
+
+func (i ScheduleArray) ToScheduleArrayOutput() ScheduleArrayOutput {
+	return i.ToScheduleArrayOutputWithContext(context.Background())
+}
+
+func (i ScheduleArray) ToScheduleArrayOutputWithContext(ctx context.Context) ScheduleArrayOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ScheduleArrayOutput)
+}
+
+// ScheduleMapInput is an input type that accepts ScheduleMap and ScheduleMapOutput values.
+// You can construct a concrete instance of `ScheduleMapInput` via:
+//
+//	ScheduleMap{ "key": ScheduleArgs{...} }
+type ScheduleMapInput interface {
+	pulumi.Input
+
+	ToScheduleMapOutput() ScheduleMapOutput
+	ToScheduleMapOutputWithContext(context.Context) ScheduleMapOutput
+}
+
+type ScheduleMap map[string]ScheduleInput
+
+func (ScheduleMap) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]*Schedule)(nil)).Elem()
+}
+
+func (i ScheduleMap) ToScheduleMapOutput() ScheduleMapOutput {
+	return i.ToScheduleMapOutputWithContext(context.Background())
+}
+
+func (i ScheduleMap) ToScheduleMapOutputWithContext(ctx context.Context) ScheduleMapOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(ScheduleMapOutput)
+}
+
+type ScheduleOutput struct{ *pulumi.OutputState }
+
+func (ScheduleOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((**Schedule)(nil)).Elem()
+}
+
+func (o ScheduleOutput) ToScheduleOutput() ScheduleOutput {
+	return o
+}
+
+func (o ScheduleOutput) ToScheduleOutputWithContext(ctx context.Context) ScheduleOutput {
+	return o
+}
+
+// Docker service name the schedule targets. Derived by Dokploy when omitted.
+func (o ScheduleOutput) AppName() pulumi.StringOutput {
+	return o.ApplyT(func(v *Schedule) pulumi.StringOutput { return v.AppName }).(pulumi.StringOutput)
+}
+
+// Application this schedule belongs to.
+func (o ScheduleOutput) ApplicationId() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Schedule) pulumi.StringPtrOutput { return v.ApplicationId }).(pulumi.StringPtrOutput)
+}
+
+// Command to run.
+func (o ScheduleOutput) Command() pulumi.StringOutput {
+	return o.ApplyT(func(v *Schedule) pulumi.StringOutput { return v.Command }).(pulumi.StringOutput)
+}
+
+// Compose stack this schedule belongs to.
+func (o ScheduleOutput) ComposeId() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Schedule) pulumi.StringPtrOutput { return v.ComposeId }).(pulumi.StringPtrOutput)
+}
+
+// RFC 3339 timestamp of when the schedule was created.
+func (o ScheduleOutput) CreatedAt() pulumi.StringOutput {
+	return o.ApplyT(func(v *Schedule) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput)
+}
+
+// Standard five-field cron expression, for example `0 3 * * *`.
+func (o ScheduleOutput) CronExpression() pulumi.StringOutput {
+	return o.ApplyT(func(v *Schedule) pulumi.StringOutput { return v.CronExpression }).(pulumi.StringOutput)
+}
+
+// Free-form description.
+func (o ScheduleOutput) Description() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Schedule) pulumi.StringPtrOutput { return v.Description }).(pulumi.StringPtrOutput)
+}
+
+// Whether the schedule is active.
+func (o ScheduleOutput) Enabled() pulumi.BoolOutput {
+	return o.ApplyT(func(v *Schedule) pulumi.BoolOutput { return v.Enabled }).(pulumi.BoolOutput)
+}
+
+// Display name of the schedule.
+func (o ScheduleOutput) Name() pulumi.StringOutput {
+	return o.ApplyT(func(v *Schedule) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput)
+}
+
+// Where the command runs. Valid values: `application`, `compose`, `server`, `dokploy-server`. Defaults to `application`.
+func (o ScheduleOutput) ScheduleType() pulumi.StringOutput {
+	return o.ApplyT(func(v *Schedule) pulumi.StringOutput { return v.ScheduleType }).(pulumi.StringOutput)
+}
+
+// Multi-line script to run instead of a single command.
+func (o ScheduleOutput) Script() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Schedule) pulumi.StringPtrOutput { return v.Script }).(pulumi.StringPtrOutput)
+}
+
+// Server this schedule runs on.
+func (o ScheduleOutput) ServerId() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Schedule) pulumi.StringPtrOutput { return v.ServerId }).(pulumi.StringPtrOutput)
+}
+
+// Service inside a Compose stack to run the command in.
+func (o ScheduleOutput) ServiceName() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Schedule) pulumi.StringPtrOutput { return v.ServiceName }).(pulumi.StringPtrOutput)
+}
+
+// Shell used to interpret the command. Valid values: `bash`, `sh`. Defaults to `bash`.
+func (o ScheduleOutput) ShellType() pulumi.StringOutput {
+	return o.ApplyT(func(v *Schedule) pulumi.StringOutput { return v.ShellType }).(pulumi.StringOutput)
+}
+
+// IANA timezone the cron expression is evaluated in, for example `Europe/Berlin`.
+func (o ScheduleOutput) Timezone() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *Schedule) pulumi.StringPtrOutput { return v.Timezone }).(pulumi.StringPtrOutput)
+}
+
+type ScheduleArrayOutput struct{ *pulumi.OutputState }
+
+func (ScheduleArrayOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]*Schedule)(nil)).Elem()
+}
+
+func (o ScheduleArrayOutput) ToScheduleArrayOutput() ScheduleArrayOutput {
+	return o
+}
+
+func (o ScheduleArrayOutput) ToScheduleArrayOutputWithContext(ctx context.Context) ScheduleArrayOutput {
+	return o
+}
+
+func (o ScheduleArrayOutput) Index(i pulumi.IntInput) ScheduleOutput {
+	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *Schedule {
+		return vs[0].([]*Schedule)[vs[1].(int)]
+	}).(ScheduleOutput)
+}
+
+type ScheduleMapOutput struct{ *pulumi.OutputState }
+
+func (ScheduleMapOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]*Schedule)(nil)).Elem()
+}
+
+func (o ScheduleMapOutput) ToScheduleMapOutput() ScheduleMapOutput {
+	return o
+}
+
+func (o ScheduleMapOutput) ToScheduleMapOutputWithContext(ctx context.Context) ScheduleMapOutput {
+	return o
+}
+
+func (o ScheduleMapOutput) MapIndex(k pulumi.StringInput) ScheduleOutput {
+	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *Schedule {
+		return vs[0].(map[string]*Schedule)[vs[1].(string)]
+	}).(ScheduleOutput)
+}
+
+func init() {
+	pulumi.RegisterInputType(reflect.TypeOf((*ScheduleInput)(nil)).Elem(), &Schedule{})
+	pulumi.RegisterInputType(reflect.TypeOf((*ScheduleArrayInput)(nil)).Elem(), ScheduleArray{})
+	pulumi.RegisterInputType(reflect.TypeOf((*ScheduleMapInput)(nil)).Elem(), ScheduleMap{})
+	pulumi.RegisterOutputType(ScheduleOutput{})
+	pulumi.RegisterOutputType(ScheduleArrayOutput{})
+	pulumi.RegisterOutputType(ScheduleMapOutput{})
+}

sdk/go/dokploy/security.go

@@ -12,6 +12,9 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// HTTP basic authentication credentials protecting an application's domains.
+//
+// > Dokploy stores the password hashed and does not return it. The value in Terraform state is the one you configured.
 type Security struct {
 	pulumi.CustomResourceState
 

sdk/go/dokploy/sshKey.go

@@ -12,6 +12,11 @@ import (
 	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
 )
 
+// An SSH key pair Dokploy uses to clone private Git repositories and to reach remote servers.
+//
+// > The private key is stored in Terraform state. Use a state backend with encryption at rest.
+//
+// > Dokploy's update endpoint only accepts `name` and `description`. Changing either key forces a new resource.
 type SshKey struct {
 	pulumi.CustomResourceState
 

sdk/go/dokploy/vaultProvider.go

@@ -0,0 +1,296 @@
+// Code generated by pulumi-language-go DO NOT EDIT.
+// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***
+
+package dokploy
+
+import (
+	"context"
+	"reflect"
+
+	"errors"
+	"github.com/maxvojtkov/pulumi-dokploy/sdk/go/dokploy/internal"
+	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+)
+
+// An external secret manager Dokploy resolves environment variables from at deploy time.
+//
+// Reference a secret from any `env` value with `${{vault.<scope>.<key>}}`. The value is fetched when the deployment runs and is never stored in Dokploy — so rotating it in the vault takes effect on the next deploy with no Terraform change.
+//
+// Supported `providerType` values: `hashicorp` (Vault/OpenBao), `infisical`, `aws` (Secrets Manager), `doppler`, `azure` (Key Vault) and `scaleway`.
+type VaultProvider struct {
+	pulumi.CustomResourceState
+
+	// JSON array scoping which projects or environments may resolve secrets from this provider. Pass `jsonencode([])` to leave it unscoped.
+	Assignments pulumi.StringOutput `pulumi:"assignments"`
+	// Provider credentials as a JSON object, including the `providerType` discriminator.
+	Config pulumi.StringOutput `pulumi:"config"`
+	// RFC 3339 timestamp of when the connection was created.
+	CreatedAt pulumi.StringOutput `pulumi:"createdAt"`
+	// Name of the connection, unique within the organization.
+	Name pulumi.StringOutput `pulumi:"name"`
+	// Organization that owns the connection.
+	OrganizationId pulumi.StringOutput `pulumi:"organizationId"`
+	// Provider kind derived from `config`.
+	ProviderType pulumi.StringOutput `pulumi:"providerType"`
+}
+
+// NewVaultProvider registers a new resource with the given unique name, arguments, and options.
+func NewVaultProvider(ctx *pulumi.Context,
+	name string, args *VaultProviderArgs, opts ...pulumi.ResourceOption) (*VaultProvider, error) {
+	if args == nil {
+		return nil, errors.New("missing one or more required arguments")
+	}
+
+	if args.Assignments == nil {
+		return nil, errors.New("invalid value for required argument 'Assignments'")
+	}
+	if args.Config == nil {
+		return nil, errors.New("invalid value for required argument 'Config'")
+	}
+	if args.Config != nil {
+		args.Config = pulumi.ToSecret(args.Config).(pulumi.StringInput)
+	}
+	secrets := pulumi.AdditionalSecretOutputs([]string{
+		"config",
+	})
+	opts = append(opts, secrets)
+	opts = internal.PkgResourceDefaultOpts(opts)
+	var resource VaultProvider
+	err := ctx.RegisterResource("dokploy:index/vaultProvider:VaultProvider", name, args, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// GetVaultProvider gets an existing VaultProvider resource's state with the given name, ID, and optional
+// state properties that are used to uniquely qualify the lookup (nil if not required).
+func GetVaultProvider(ctx *pulumi.Context,
+	name string, id pulumi.IDInput, state *VaultProviderState, opts ...pulumi.ResourceOption) (*VaultProvider, error) {
+	var resource VaultProvider
+	err := ctx.ReadResource("dokploy:index/vaultProvider:VaultProvider", name, id, state, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// Input properties used for looking up and filtering VaultProvider resources.
+type vaultProviderState struct {
+	// JSON array scoping which projects or environments may resolve secrets from this provider. Pass `jsonencode([])` to leave it unscoped.
+	Assignments *string `pulumi:"assignments"`
+	// Provider credentials as a JSON object, including the `providerType` discriminator.
+	Config *string `pulumi:"config"`
+	// RFC 3339 timestamp of when the connection was created.
+	CreatedAt *string `pulumi:"createdAt"`
+	// Name of the connection, unique within the organization.
+	Name *string `pulumi:"name"`
+	// Organization that owns the connection.
+	OrganizationId *string `pulumi:"organizationId"`
+	// Provider kind derived from `config`.
+	ProviderType *string `pulumi:"providerType"`
+}
+
+type VaultProviderState struct {
+	// JSON array scoping which projects or environments may resolve secrets from this provider. Pass `jsonencode([])` to leave it unscoped.
+	Assignments pulumi.StringPtrInput
+	// Provider credentials as a JSON object, including the `providerType` discriminator.
+	Config pulumi.StringPtrInput
+	// RFC 3339 timestamp of when the connection was created.
+	CreatedAt pulumi.StringPtrInput
+	// Name of the connection, unique within the organization.
+	Name pulumi.StringPtrInput
+	// Organization that owns the connection.
+	OrganizationId pulumi.StringPtrInput
+	// Provider kind derived from `config`.
+	ProviderType pulumi.StringPtrInput
+}
+
+func (VaultProviderState) ElementType() reflect.Type {
+	return reflect.TypeOf((*vaultProviderState)(nil)).Elem()
+}
+
+type vaultProviderArgs struct {
+	// JSON array scoping which projects or environments may resolve secrets from this provider. Pass `jsonencode([])` to leave it unscoped.
+	Assignments string `pulumi:"assignments"`
+	// Provider credentials as a JSON object, including the `providerType` discriminator.
+	Config string `pulumi:"config"`
+	// Name of the connection, unique within the organization.
+	Name *string `pulumi:"name"`
+}
+
+// The set of arguments for constructing a VaultProvider resource.
+type VaultProviderArgs struct {
+	// JSON array scoping which projects or environments may resolve secrets from this provider. Pass `jsonencode([])` to leave it unscoped.
+	Assignments pulumi.StringInput
+	// Provider credentials as a JSON object, including the `providerType` discriminator.
+	Config pulumi.StringInput
+	// Name of the connection, unique within the organization.
+	Name pulumi.StringPtrInput
+}
+
+func (VaultProviderArgs) ElementType() reflect.Type {
+	return reflect.TypeOf((*vaultProviderArgs)(nil)).Elem()
+}
+
+type VaultProviderInput interface {
+	pulumi.Input
+
+	ToVaultProviderOutput() VaultProviderOutput
+	ToVaultProviderOutputWithContext(ctx context.Context) VaultProviderOutput
+}
+
+func (*VaultProvider) ElementType() reflect.Type {
+	return reflect.TypeOf((**VaultProvider)(nil)).Elem()
+}
+
+func (i *VaultProvider) ToVaultProviderOutput() VaultProviderOutput {
+	return i.ToVaultProviderOutputWithContext(context.Background())
+}
+
+func (i *VaultProvider) ToVaultProviderOutputWithContext(ctx context.Context) VaultProviderOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(VaultProviderOutput)
+}
+
+// VaultProviderArrayInput is an input type that accepts VaultProviderArray and VaultProviderArrayOutput values.
+// You can construct a concrete instance of `VaultProviderArrayInput` via:
+//
+//	VaultProviderArray{ VaultProviderArgs{...} }
+type VaultProviderArrayInput interface {
+	pulumi.Input
+
+	ToVaultProviderArrayOutput() VaultProviderArrayOutput
+	ToVaultProviderArrayOutputWithContext(context.Context) VaultProviderArrayOutput
+}
+
+type VaultProviderArray []VaultProviderInput
+
+func (VaultProviderArray) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]*VaultProvider)(nil)).Elem()
+}
+
+func (i VaultProviderArray) ToVaultProviderArrayOutput() VaultProviderArrayOutput {
+	return i.ToVaultProviderArrayOutputWithContext(context.Background())
+}
+
+func (i VaultProviderArray) ToVaultProviderArrayOutputWithContext(ctx context.Context) VaultProviderArrayOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(VaultProviderArrayOutput)
+}
+
+// VaultProviderMapInput is an input type that accepts VaultProviderMap and VaultProviderMapOutput values.
+// You can construct a concrete instance of `VaultProviderMapInput` via:
+//
+//	VaultProviderMap{ "key": VaultProviderArgs{...} }
+type VaultProviderMapInput interface {
+	pulumi.Input
+
+	ToVaultProviderMapOutput() VaultProviderMapOutput
+	ToVaultProviderMapOutputWithContext(context.Context) VaultProviderMapOutput
+}
+
+type VaultProviderMap map[string]VaultProviderInput
+
+func (VaultProviderMap) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]*VaultProvider)(nil)).Elem()
+}
+
+func (i VaultProviderMap) ToVaultProviderMapOutput() VaultProviderMapOutput {
+	return i.ToVaultProviderMapOutputWithContext(context.Background())
+}
+
+func (i VaultProviderMap) ToVaultProviderMapOutputWithContext(ctx context.Context) VaultProviderMapOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(VaultProviderMapOutput)
+}
+
+type VaultProviderOutput struct{ *pulumi.OutputState }
+
+func (VaultProviderOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((**VaultProvider)(nil)).Elem()
+}
+
+func (o VaultProviderOutput) ToVaultProviderOutput() VaultProviderOutput {
+	return o
+}
+
+func (o VaultProviderOutput) ToVaultProviderOutputWithContext(ctx context.Context) VaultProviderOutput {
+	return o
+}
+
+// JSON array scoping which projects or environments may resolve secrets from this provider. Pass `jsonencode([])` to leave it unscoped.
+func (o VaultProviderOutput) Assignments() pulumi.StringOutput {
+	return o.ApplyT(func(v *VaultProvider) pulumi.StringOutput { return v.Assignments }).(pulumi.StringOutput)
+}
+
+// Provider credentials as a JSON object, including the `providerType` discriminator.
+func (o VaultProviderOutput) Config() pulumi.StringOutput {
+	return o.ApplyT(func(v *VaultProvider) pulumi.StringOutput { return v.Config }).(pulumi.StringOutput)
+}
+
+// RFC 3339 timestamp of when the connection was created.
+func (o VaultProviderOutput) CreatedAt() pulumi.StringOutput {
+	return o.ApplyT(func(v *VaultProvider) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput)
+}
+
+// Name of the connection, unique within the organization.
+func (o VaultProviderOutput) Name() pulumi.StringOutput {
+	return o.ApplyT(func(v *VaultProvider) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput)
+}
+
+// Organization that owns the connection.
+func (o VaultProviderOutput) OrganizationId() pulumi.StringOutput {
+	return o.ApplyT(func(v *VaultProvider) pulumi.StringOutput { return v.OrganizationId }).(pulumi.StringOutput)
+}
+
+// Provider kind derived from `config`.
+func (o VaultProviderOutput) ProviderType() pulumi.StringOutput {
+	return o.ApplyT(func(v *VaultProvider) pulumi.StringOutput { return v.ProviderType }).(pulumi.StringOutput)
+}
+
+type VaultProviderArrayOutput struct{ *pulumi.OutputState }
+
+func (VaultProviderArrayOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]*VaultProvider)(nil)).Elem()
+}
+
+func (o VaultProviderArrayOutput) ToVaultProviderArrayOutput() VaultProviderArrayOutput {
+	return o
+}
+
+func (o VaultProviderArrayOutput) ToVaultProviderArrayOutputWithContext(ctx context.Context) VaultProviderArrayOutput {
+	return o
+}
+
+func (o VaultProviderArrayOutput) Index(i pulumi.IntInput) VaultProviderOutput {
+	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *VaultProvider {
+		return vs[0].([]*VaultProvider)[vs[1].(int)]
+	}).(VaultProviderOutput)
+}
+
+type VaultProviderMapOutput struct{ *pulumi.OutputState }
+
+func (VaultProviderMapOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]*VaultProvider)(nil)).Elem()
+}
+
+func (o VaultProviderMapOutput) ToVaultProviderMapOutput() VaultProviderMapOutput {
+	return o
+}
+
+func (o VaultProviderMapOutput) ToVaultProviderMapOutputWithContext(ctx context.Context) VaultProviderMapOutput {
+	return o
+}
+
+func (o VaultProviderMapOutput) MapIndex(k pulumi.StringInput) VaultProviderOutput {
+	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *VaultProvider {
+		return vs[0].(map[string]*VaultProvider)[vs[1].(string)]
+	}).(VaultProviderOutput)
+}
+
+func init() {
+	pulumi.RegisterInputType(reflect.TypeOf((*VaultProviderInput)(nil)).Elem(), &VaultProvider{})
+	pulumi.RegisterInputType(reflect.TypeOf((*VaultProviderArrayInput)(nil)).Elem(), VaultProviderArray{})
+	pulumi.RegisterInputType(reflect.TypeOf((*VaultProviderMapInput)(nil)).Elem(), VaultProviderMap{})
+	pulumi.RegisterOutputType(VaultProviderOutput{})
+	pulumi.RegisterOutputType(VaultProviderArrayOutput{})
+	pulumi.RegisterOutputType(VaultProviderMapOutput{})
+}

sdk/go/dokploy/volumeBackup.go

@@ -0,0 +1,513 @@
+// Code generated by pulumi-language-go DO NOT EDIT.
+// *** WARNING: Do not edit by hand unless you're certain you know what you are doing! ***
+
+package dokploy
+
+import (
+	"context"
+	"reflect"
+
+	"errors"
+	"github.com/maxvojtkov/pulumi-dokploy/sdk/go/dokploy/internal"
+	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
+)
+
+// A scheduled backup of a Docker volume to a configured `Destination`.
+//
+// This is the counterpart to a `Mount` with `type = "volume"`: the mount gives the volume a stable name, and this resource copies its contents off the host on a schedule.
+//
+// Set exactly one of the `*_id` attributes to say which service owns the volume.
+type VolumeBackup struct {
+	pulumi.CustomResourceState
+
+	// Docker service name that owns the volume. Derived by Dokploy when omitted.
+	AppName pulumi.StringOutput `pulumi:"appName"`
+	// Application that owns the volume.
+	ApplicationId pulumi.StringPtrOutput `pulumi:"applicationId"`
+	// Compose stack that owns the volume.
+	ComposeId pulumi.StringPtrOutput `pulumi:"composeId"`
+	// RFC 3339 timestamp of when the backup job was created.
+	CreatedAt pulumi.StringOutput `pulumi:"createdAt"`
+	// Standard five-field cron expression, for example `0 4 * * *`.
+	CronExpression pulumi.StringOutput `pulumi:"cronExpression"`
+	// Backup destination (S3-compatible bucket) to upload to.
+	DestinationId pulumi.StringOutput `pulumi:"destinationId"`
+	// Whether the backup schedule is active.
+	Enabled pulumi.BoolOutput `pulumi:"enabled"`
+	// Number of backups to retain. Older ones are pruned.
+	KeepLatestCount pulumi.IntOutput `pulumi:"keepLatestCount"`
+	// libSQL instance that owns the volume.
+	LibsqlId pulumi.StringPtrOutput `pulumi:"libsqlId"`
+	// MariaDB instance that owns the volume.
+	MariadbId pulumi.StringPtrOutput `pulumi:"mariadbId"`
+	// MongoDB instance that owns the volume.
+	MongoId pulumi.StringPtrOutput `pulumi:"mongoId"`
+	// MySQL instance that owns the volume.
+	MysqlId pulumi.StringPtrOutput `pulumi:"mysqlId"`
+	// Display name of the backup job.
+	Name pulumi.StringOutput `pulumi:"name"`
+	// PostgreSQL instance that owns the volume.
+	PostgresId pulumi.StringPtrOutput `pulumi:"postgresId"`
+	// Path prefix inside the destination bucket, for example `backups/shop/`.
+	Prefix pulumi.StringOutput `pulumi:"prefix"`
+	// Redis instance that owns the volume.
+	RedisId pulumi.StringPtrOutput `pulumi:"redisId"`
+	// Service inside a Compose stack that owns the volume.
+	ServiceName pulumi.StringPtrOutput `pulumi:"serviceName"`
+	// The kind of service that owns the volume. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`, `libsql`. Defaults to `application`.
+	ServiceType pulumi.StringOutput `pulumi:"serviceType"`
+	// Stop the service while the backup runs. Slower, but guarantees a consistent copy of data that is being written to.
+	TurnOff pulumi.BoolOutput `pulumi:"turnOff"`
+	// Name of the Docker volume to back up.
+	VolumeName pulumi.StringOutput `pulumi:"volumeName"`
+}
+
+// NewVolumeBackup registers a new resource with the given unique name, arguments, and options.
+func NewVolumeBackup(ctx *pulumi.Context,
+	name string, args *VolumeBackupArgs, opts ...pulumi.ResourceOption) (*VolumeBackup, error) {
+	if args == nil {
+		return nil, errors.New("missing one or more required arguments")
+	}
+
+	if args.CronExpression == nil {
+		return nil, errors.New("invalid value for required argument 'CronExpression'")
+	}
+	if args.DestinationId == nil {
+		return nil, errors.New("invalid value for required argument 'DestinationId'")
+	}
+	if args.Prefix == nil {
+		return nil, errors.New("invalid value for required argument 'Prefix'")
+	}
+	if args.VolumeName == nil {
+		return nil, errors.New("invalid value for required argument 'VolumeName'")
+	}
+	opts = internal.PkgResourceDefaultOpts(opts)
+	var resource VolumeBackup
+	err := ctx.RegisterResource("dokploy:index/volumeBackup:VolumeBackup", name, args, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// GetVolumeBackup gets an existing VolumeBackup resource's state with the given name, ID, and optional
+// state properties that are used to uniquely qualify the lookup (nil if not required).
+func GetVolumeBackup(ctx *pulumi.Context,
+	name string, id pulumi.IDInput, state *VolumeBackupState, opts ...pulumi.ResourceOption) (*VolumeBackup, error) {
+	var resource VolumeBackup
+	err := ctx.ReadResource("dokploy:index/volumeBackup:VolumeBackup", name, id, state, &resource, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return &resource, nil
+}
+
+// Input properties used for looking up and filtering VolumeBackup resources.
+type volumeBackupState struct {
+	// Docker service name that owns the volume. Derived by Dokploy when omitted.
+	AppName *string `pulumi:"appName"`
+	// Application that owns the volume.
+	ApplicationId *string `pulumi:"applicationId"`
+	// Compose stack that owns the volume.
+	ComposeId *string `pulumi:"composeId"`
+	// RFC 3339 timestamp of when the backup job was created.
+	CreatedAt *string `pulumi:"createdAt"`
+	// Standard five-field cron expression, for example `0 4 * * *`.
+	CronExpression *string `pulumi:"cronExpression"`
+	// Backup destination (S3-compatible bucket) to upload to.
+	DestinationId *string `pulumi:"destinationId"`
+	// Whether the backup schedule is active.
+	Enabled *bool `pulumi:"enabled"`
+	// Number of backups to retain. Older ones are pruned.
+	KeepLatestCount *int `pulumi:"keepLatestCount"`
+	// libSQL instance that owns the volume.
+	LibsqlId *string `pulumi:"libsqlId"`
+	// MariaDB instance that owns the volume.
+	MariadbId *string `pulumi:"mariadbId"`
+	// MongoDB instance that owns the volume.
+	MongoId *string `pulumi:"mongoId"`
+	// MySQL instance that owns the volume.
+	MysqlId *string `pulumi:"mysqlId"`
+	// Display name of the backup job.
+	Name *string `pulumi:"name"`
+	// PostgreSQL instance that owns the volume.
+	PostgresId *string `pulumi:"postgresId"`
+	// Path prefix inside the destination bucket, for example `backups/shop/`.
+	Prefix *string `pulumi:"prefix"`
+	// Redis instance that owns the volume.
+	RedisId *string `pulumi:"redisId"`
+	// Service inside a Compose stack that owns the volume.
+	ServiceName *string `pulumi:"serviceName"`
+	// The kind of service that owns the volume. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`, `libsql`. Defaults to `application`.
+	ServiceType *string `pulumi:"serviceType"`
+	// Stop the service while the backup runs. Slower, but guarantees a consistent copy of data that is being written to.
+	TurnOff *bool `pulumi:"turnOff"`
+	// Name of the Docker volume to back up.
+	VolumeName *string `pulumi:"volumeName"`
+}
+
+type VolumeBackupState struct {
+	// Docker service name that owns the volume. Derived by Dokploy when omitted.
+	AppName pulumi.StringPtrInput
+	// Application that owns the volume.
+	ApplicationId pulumi.StringPtrInput
+	// Compose stack that owns the volume.
+	ComposeId pulumi.StringPtrInput
+	// RFC 3339 timestamp of when the backup job was created.
+	CreatedAt pulumi.StringPtrInput
+	// Standard five-field cron expression, for example `0 4 * * *`.
+	CronExpression pulumi.StringPtrInput
+	// Backup destination (S3-compatible bucket) to upload to.
+	DestinationId pulumi.StringPtrInput
+	// Whether the backup schedule is active.
+	Enabled pulumi.BoolPtrInput
+	// Number of backups to retain. Older ones are pruned.
+	KeepLatestCount pulumi.IntPtrInput
+	// libSQL instance that owns the volume.
+	LibsqlId pulumi.StringPtrInput
+	// MariaDB instance that owns the volume.
+	MariadbId pulumi.StringPtrInput
+	// MongoDB instance that owns the volume.
+	MongoId pulumi.StringPtrInput
+	// MySQL instance that owns the volume.
+	MysqlId pulumi.StringPtrInput
+	// Display name of the backup job.
+	Name pulumi.StringPtrInput
+	// PostgreSQL instance that owns the volume.
+	PostgresId pulumi.StringPtrInput
+	// Path prefix inside the destination bucket, for example `backups/shop/`.
+	Prefix pulumi.StringPtrInput
+	// Redis instance that owns the volume.
+	RedisId pulumi.StringPtrInput
+	// Service inside a Compose stack that owns the volume.
+	ServiceName pulumi.StringPtrInput
+	// The kind of service that owns the volume. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`, `libsql`. Defaults to `application`.
+	ServiceType pulumi.StringPtrInput
+	// Stop the service while the backup runs. Slower, but guarantees a consistent copy of data that is being written to.
+	TurnOff pulumi.BoolPtrInput
+	// Name of the Docker volume to back up.
+	VolumeName pulumi.StringPtrInput
+}
+
+func (VolumeBackupState) ElementType() reflect.Type {
+	return reflect.TypeOf((*volumeBackupState)(nil)).Elem()
+}
+
+type volumeBackupArgs struct {
+	// Docker service name that owns the volume. Derived by Dokploy when omitted.
+	AppName *string `pulumi:"appName"`
+	// Application that owns the volume.
+	ApplicationId *string `pulumi:"applicationId"`
+	// Compose stack that owns the volume.
+	ComposeId *string `pulumi:"composeId"`
+	// Standard five-field cron expression, for example `0 4 * * *`.
+	CronExpression string `pulumi:"cronExpression"`
+	// Backup destination (S3-compatible bucket) to upload to.
+	DestinationId string `pulumi:"destinationId"`
+	// Whether the backup schedule is active.
+	Enabled *bool `pulumi:"enabled"`
+	// Number of backups to retain. Older ones are pruned.
+	KeepLatestCount *int `pulumi:"keepLatestCount"`
+	// libSQL instance that owns the volume.
+	LibsqlId *string `pulumi:"libsqlId"`
+	// MariaDB instance that owns the volume.
+	MariadbId *string `pulumi:"mariadbId"`
+	// MongoDB instance that owns the volume.
+	MongoId *string `pulumi:"mongoId"`
+	// MySQL instance that owns the volume.
+	MysqlId *string `pulumi:"mysqlId"`
+	// Display name of the backup job.
+	Name *string `pulumi:"name"`
+	// PostgreSQL instance that owns the volume.
+	PostgresId *string `pulumi:"postgresId"`
+	// Path prefix inside the destination bucket, for example `backups/shop/`.
+	Prefix string `pulumi:"prefix"`
+	// Redis instance that owns the volume.
+	RedisId *string `pulumi:"redisId"`
+	// Service inside a Compose stack that owns the volume.
+	ServiceName *string `pulumi:"serviceName"`
+	// The kind of service that owns the volume. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`, `libsql`. Defaults to `application`.
+	ServiceType *string `pulumi:"serviceType"`
+	// Stop the service while the backup runs. Slower, but guarantees a consistent copy of data that is being written to.
+	TurnOff *bool `pulumi:"turnOff"`
+	// Name of the Docker volume to back up.
+	VolumeName string `pulumi:"volumeName"`
+}
+
+// The set of arguments for constructing a VolumeBackup resource.
+type VolumeBackupArgs struct {
+	// Docker service name that owns the volume. Derived by Dokploy when omitted.
+	AppName pulumi.StringPtrInput
+	// Application that owns the volume.
+	ApplicationId pulumi.StringPtrInput
+	// Compose stack that owns the volume.
+	ComposeId pulumi.StringPtrInput
+	// Standard five-field cron expression, for example `0 4 * * *`.
+	CronExpression pulumi.StringInput
+	// Backup destination (S3-compatible bucket) to upload to.
+	DestinationId pulumi.StringInput
+	// Whether the backup schedule is active.
+	Enabled pulumi.BoolPtrInput
+	// Number of backups to retain. Older ones are pruned.
+	KeepLatestCount pulumi.IntPtrInput
+	// libSQL instance that owns the volume.
+	LibsqlId pulumi.StringPtrInput
+	// MariaDB instance that owns the volume.
+	MariadbId pulumi.StringPtrInput
+	// MongoDB instance that owns the volume.
+	MongoId pulumi.StringPtrInput
+	// MySQL instance that owns the volume.
+	MysqlId pulumi.StringPtrInput
+	// Display name of the backup job.
+	Name pulumi.StringPtrInput
+	// PostgreSQL instance that owns the volume.
+	PostgresId pulumi.StringPtrInput
+	// Path prefix inside the destination bucket, for example `backups/shop/`.
+	Prefix pulumi.StringInput
+	// Redis instance that owns the volume.
+	RedisId pulumi.StringPtrInput
+	// Service inside a Compose stack that owns the volume.
+	ServiceName pulumi.StringPtrInput
+	// The kind of service that owns the volume. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`, `libsql`. Defaults to `application`.
+	ServiceType pulumi.StringPtrInput
+	// Stop the service while the backup runs. Slower, but guarantees a consistent copy of data that is being written to.
+	TurnOff pulumi.BoolPtrInput
+	// Name of the Docker volume to back up.
+	VolumeName pulumi.StringInput
+}
+
+func (VolumeBackupArgs) ElementType() reflect.Type {
+	return reflect.TypeOf((*volumeBackupArgs)(nil)).Elem()
+}
+
+type VolumeBackupInput interface {
+	pulumi.Input
+
+	ToVolumeBackupOutput() VolumeBackupOutput
+	ToVolumeBackupOutputWithContext(ctx context.Context) VolumeBackupOutput
+}
+
+func (*VolumeBackup) ElementType() reflect.Type {
+	return reflect.TypeOf((**VolumeBackup)(nil)).Elem()
+}
+
+func (i *VolumeBackup) ToVolumeBackupOutput() VolumeBackupOutput {
+	return i.ToVolumeBackupOutputWithContext(context.Background())
+}
+
+func (i *VolumeBackup) ToVolumeBackupOutputWithContext(ctx context.Context) VolumeBackupOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(VolumeBackupOutput)
+}
+
+// VolumeBackupArrayInput is an input type that accepts VolumeBackupArray and VolumeBackupArrayOutput values.
+// You can construct a concrete instance of `VolumeBackupArrayInput` via:
+//
+//	VolumeBackupArray{ VolumeBackupArgs{...} }
+type VolumeBackupArrayInput interface {
+	pulumi.Input
+
+	ToVolumeBackupArrayOutput() VolumeBackupArrayOutput
+	ToVolumeBackupArrayOutputWithContext(context.Context) VolumeBackupArrayOutput
+}
+
+type VolumeBackupArray []VolumeBackupInput
+
+func (VolumeBackupArray) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]*VolumeBackup)(nil)).Elem()
+}
+
+func (i VolumeBackupArray) ToVolumeBackupArrayOutput() VolumeBackupArrayOutput {
+	return i.ToVolumeBackupArrayOutputWithContext(context.Background())
+}
+
+func (i VolumeBackupArray) ToVolumeBackupArrayOutputWithContext(ctx context.Context) VolumeBackupArrayOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(VolumeBackupArrayOutput)
+}
+
+// VolumeBackupMapInput is an input type that accepts VolumeBackupMap and VolumeBackupMapOutput values.
+// You can construct a concrete instance of `VolumeBackupMapInput` via:
+//
+//	VolumeBackupMap{ "key": VolumeBackupArgs{...} }
+type VolumeBackupMapInput interface {
+	pulumi.Input
+
+	ToVolumeBackupMapOutput() VolumeBackupMapOutput
+	ToVolumeBackupMapOutputWithContext(context.Context) VolumeBackupMapOutput
+}
+
+type VolumeBackupMap map[string]VolumeBackupInput
+
+func (VolumeBackupMap) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]*VolumeBackup)(nil)).Elem()
+}
+
+func (i VolumeBackupMap) ToVolumeBackupMapOutput() VolumeBackupMapOutput {
+	return i.ToVolumeBackupMapOutputWithContext(context.Background())
+}
+
+func (i VolumeBackupMap) ToVolumeBackupMapOutputWithContext(ctx context.Context) VolumeBackupMapOutput {
+	return pulumi.ToOutputWithContext(ctx, i).(VolumeBackupMapOutput)
+}
+
+type VolumeBackupOutput struct{ *pulumi.OutputState }
+
+func (VolumeBackupOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((**VolumeBackup)(nil)).Elem()
+}
+
+func (o VolumeBackupOutput) ToVolumeBackupOutput() VolumeBackupOutput {
+	return o
+}
+
+func (o VolumeBackupOutput) ToVolumeBackupOutputWithContext(ctx context.Context) VolumeBackupOutput {
+	return o
+}
+
+// Docker service name that owns the volume. Derived by Dokploy when omitted.
+func (o VolumeBackupOutput) AppName() pulumi.StringOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.StringOutput { return v.AppName }).(pulumi.StringOutput)
+}
+
+// Application that owns the volume.
+func (o VolumeBackupOutput) ApplicationId() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.StringPtrOutput { return v.ApplicationId }).(pulumi.StringPtrOutput)
+}
+
+// Compose stack that owns the volume.
+func (o VolumeBackupOutput) ComposeId() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.StringPtrOutput { return v.ComposeId }).(pulumi.StringPtrOutput)
+}
+
+// RFC 3339 timestamp of when the backup job was created.
+func (o VolumeBackupOutput) CreatedAt() pulumi.StringOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.StringOutput { return v.CreatedAt }).(pulumi.StringOutput)
+}
+
+// Standard five-field cron expression, for example `0 4 * * *`.
+func (o VolumeBackupOutput) CronExpression() pulumi.StringOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.StringOutput { return v.CronExpression }).(pulumi.StringOutput)
+}
+
+// Backup destination (S3-compatible bucket) to upload to.
+func (o VolumeBackupOutput) DestinationId() pulumi.StringOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.StringOutput { return v.DestinationId }).(pulumi.StringOutput)
+}
+
+// Whether the backup schedule is active.
+func (o VolumeBackupOutput) Enabled() pulumi.BoolOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.BoolOutput { return v.Enabled }).(pulumi.BoolOutput)
+}
+
+// Number of backups to retain. Older ones are pruned.
+func (o VolumeBackupOutput) KeepLatestCount() pulumi.IntOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.IntOutput { return v.KeepLatestCount }).(pulumi.IntOutput)
+}
+
+// libSQL instance that owns the volume.
+func (o VolumeBackupOutput) LibsqlId() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.StringPtrOutput { return v.LibsqlId }).(pulumi.StringPtrOutput)
+}
+
+// MariaDB instance that owns the volume.
+func (o VolumeBackupOutput) MariadbId() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.StringPtrOutput { return v.MariadbId }).(pulumi.StringPtrOutput)
+}
+
+// MongoDB instance that owns the volume.
+func (o VolumeBackupOutput) MongoId() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.StringPtrOutput { return v.MongoId }).(pulumi.StringPtrOutput)
+}
+
+// MySQL instance that owns the volume.
+func (o VolumeBackupOutput) MysqlId() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.StringPtrOutput { return v.MysqlId }).(pulumi.StringPtrOutput)
+}
+
+// Display name of the backup job.
+func (o VolumeBackupOutput) Name() pulumi.StringOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.StringOutput { return v.Name }).(pulumi.StringOutput)
+}
+
+// PostgreSQL instance that owns the volume.
+func (o VolumeBackupOutput) PostgresId() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.StringPtrOutput { return v.PostgresId }).(pulumi.StringPtrOutput)
+}
+
+// Path prefix inside the destination bucket, for example `backups/shop/`.
+func (o VolumeBackupOutput) Prefix() pulumi.StringOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.StringOutput { return v.Prefix }).(pulumi.StringOutput)
+}
+
+// Redis instance that owns the volume.
+func (o VolumeBackupOutput) RedisId() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.StringPtrOutput { return v.RedisId }).(pulumi.StringPtrOutput)
+}
+
+// Service inside a Compose stack that owns the volume.
+func (o VolumeBackupOutput) ServiceName() pulumi.StringPtrOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.StringPtrOutput { return v.ServiceName }).(pulumi.StringPtrOutput)
+}
+
+// The kind of service that owns the volume. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`, `libsql`. Defaults to `application`.
+func (o VolumeBackupOutput) ServiceType() pulumi.StringOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.StringOutput { return v.ServiceType }).(pulumi.StringOutput)
+}
+
+// Stop the service while the backup runs. Slower, but guarantees a consistent copy of data that is being written to.
+func (o VolumeBackupOutput) TurnOff() pulumi.BoolOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.BoolOutput { return v.TurnOff }).(pulumi.BoolOutput)
+}
+
+// Name of the Docker volume to back up.
+func (o VolumeBackupOutput) VolumeName() pulumi.StringOutput {
+	return o.ApplyT(func(v *VolumeBackup) pulumi.StringOutput { return v.VolumeName }).(pulumi.StringOutput)
+}
+
+type VolumeBackupArrayOutput struct{ *pulumi.OutputState }
+
+func (VolumeBackupArrayOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*[]*VolumeBackup)(nil)).Elem()
+}
+
+func (o VolumeBackupArrayOutput) ToVolumeBackupArrayOutput() VolumeBackupArrayOutput {
+	return o
+}
+
+func (o VolumeBackupArrayOutput) ToVolumeBackupArrayOutputWithContext(ctx context.Context) VolumeBackupArrayOutput {
+	return o
+}
+
+func (o VolumeBackupArrayOutput) Index(i pulumi.IntInput) VolumeBackupOutput {
+	return pulumi.All(o, i).ApplyT(func(vs []interface{}) *VolumeBackup {
+		return vs[0].([]*VolumeBackup)[vs[1].(int)]
+	}).(VolumeBackupOutput)
+}
+
+type VolumeBackupMapOutput struct{ *pulumi.OutputState }
+
+func (VolumeBackupMapOutput) ElementType() reflect.Type {
+	return reflect.TypeOf((*map[string]*VolumeBackup)(nil)).Elem()
+}
+
+func (o VolumeBackupMapOutput) ToVolumeBackupMapOutput() VolumeBackupMapOutput {
+	return o
+}
+
+func (o VolumeBackupMapOutput) ToVolumeBackupMapOutputWithContext(ctx context.Context) VolumeBackupMapOutput {
+	return o
+}
+
+func (o VolumeBackupMapOutput) MapIndex(k pulumi.StringInput) VolumeBackupOutput {
+	return pulumi.All(o, k).ApplyT(func(vs []interface{}) *VolumeBackup {
+		return vs[0].(map[string]*VolumeBackup)[vs[1].(string)]
+	}).(VolumeBackupOutput)
+}
+
+func init() {
+	pulumi.RegisterInputType(reflect.TypeOf((*VolumeBackupInput)(nil)).Elem(), &VolumeBackup{})
+	pulumi.RegisterInputType(reflect.TypeOf((*VolumeBackupArrayInput)(nil)).Elem(), VolumeBackupArray{})
+	pulumi.RegisterInputType(reflect.TypeOf((*VolumeBackupMapInput)(nil)).Elem(), VolumeBackupMap{})
+	pulumi.RegisterOutputType(VolumeBackupOutput{})
+	pulumi.RegisterOutputType(VolumeBackupArrayOutput{})
+	pulumi.RegisterOutputType(VolumeBackupMapOutput{})
+}

sdk/nodejs/certificate.ts

@@ -4,6 +4,11 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * A TLS certificate uploaded to Dokploy, for domains that use `certificateType = "custom"`.
+ *
+ * > The private key is stored in Terraform state. Use a state backend with encryption at rest.
+ */
 export class Certificate extends pulumi.CustomResource {
     /**
      * Get an existing Certificate resource's state with the given name, ID, and optional extra
@@ -105,27 +110,27 @@ export interface CertificateState {
     /**
      * Whether Dokploy should renew this certificate automatically.
      */
-    autoRenew?: pulumi.Input<boolean>;
+    autoRenew?: pulumi.Input<boolean | undefined>;
     /**
      * PEM-encoded certificate chain.
      */
-    certificateData?: pulumi.Input<string>;
+    certificateData?: pulumi.Input<string | undefined>;
     /**
      * Path where Dokploy writes the certificate on disk.
      */
-    certificatePath?: pulumi.Input<string>;
+    certificatePath?: pulumi.Input<string | undefined>;
     /**
      * Display name of the certificate.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * PEM-encoded private key.
      */
-    privateKey?: pulumi.Input<string>;
+    privateKey?: pulumi.Input<string | undefined>;
     /**
      * Server this certificate is installed on.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
 }
 
 /**
@@ -135,7 +140,7 @@ export interface CertificateArgs {
     /**
      * Whether Dokploy should renew this certificate automatically.
      */
-    autoRenew?: pulumi.Input<boolean>;
+    autoRenew?: pulumi.Input<boolean | undefined>;
     /**
      * PEM-encoded certificate chain.
      */
@@ -143,7 +148,7 @@ export interface CertificateArgs {
     /**
      * Display name of the certificate.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * PEM-encoded private key.
      */
@@ -151,5 +156,5 @@ export interface CertificateArgs {
     /**
      * Server this certificate is installed on.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
 }

sdk/nodejs/compose.ts

@@ -4,6 +4,13 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * A Docker Compose or Docker Swarm stack managed by Dokploy.
+ *
+ * Set `composeFile` to manage the stack definition inline (with `sourceType = "raw"`), or point the stack at a Git repository and set `composePath`.
+ *
+ * > Creating this resource does **not** deploy the stack.
+ */
 export class Compose extends pulumi.CustomResource {
     /**
      * Get an existing Compose resource's state with the given name, ID, and optional extra
@@ -84,6 +91,10 @@ export class Compose extends pulumi.CustomResource {
      * Whether to run the stack with Docker Compose or Docker Swarm. Valid values: `docker-compose`, `stack`.
      */
     declare public readonly composeType: pulumi.Output<string>;
+    /**
+     * Write the environment variables to a `.env` file next to the Compose file.
+     */
+    declare public readonly createEnvFile: pulumi.Output<boolean>;
     /**
      * RFC 3339 timestamp of when the stack was created.
      */
@@ -164,6 +175,10 @@ export class Compose extends pulumi.CustomResource {
      * GitLab repository name.
      */
     declare public readonly gitlabRepository: pulumi.Output<string | undefined>;
+    /**
+     * Icon shown next to the stack in the Dokploy UI.
+     */
+    declare public readonly icon: pulumi.Output<string | undefined>;
     /**
      * Run the stack on its own isolated Docker network.
      */
@@ -192,6 +207,10 @@ export class Compose extends pulumi.CustomResource {
      * Remote server to deploy on. Omit to use the Dokploy host itself.
      */
     declare public readonly serverId: pulumi.Output<string | undefined>;
+    /**
+     * Per-service Docker network attachments, as a JSON object mapping each service name in the stack to an array of network IDs.
+     */
+    declare public readonly serviceNetworks: pulumi.Output<string | undefined>;
     /**
      * Where the Compose file comes from. Valid values: `git`, `github`, `gitlab`, `bitbucket`, `gitea`, `raw`.
      */
@@ -235,6 +254,7 @@ export class Compose extends pulumi.CustomResource {
             resourceInputs["composePath"] = state?.composePath;
             resourceInputs["composeStatus"] = state?.composeStatus;
             resourceInputs["composeType"] = state?.composeType;
+            resourceInputs["createEnvFile"] = state?.createEnvFile;
             resourceInputs["createdAt"] = state?.createdAt;
             resourceInputs["customGitBranch"] = state?.customGitBranch;
             resourceInputs["customGitSshKeyId"] = state?.customGitSshKeyId;
@@ -255,6 +275,7 @@ export class Compose extends pulumi.CustomResource {
             resourceInputs["gitlabPathNamespace"] = state?.gitlabPathNamespace;
             resourceInputs["gitlabProjectId"] = state?.gitlabProjectId;
             resourceInputs["gitlabRepository"] = state?.gitlabRepository;
+            resourceInputs["icon"] = state?.icon;
             resourceInputs["isolatedDeployment"] = state?.isolatedDeployment;
             resourceInputs["isolatedDeploymentsVolume"] = state?.isolatedDeploymentsVolume;
             resourceInputs["name"] = state?.name;
@@ -262,6 +283,7 @@ export class Compose extends pulumi.CustomResource {
             resourceInputs["randomize"] = state?.randomize;
             resourceInputs["repository"] = state?.repository;
             resourceInputs["serverId"] = state?.serverId;
+            resourceInputs["serviceNetworks"] = state?.serviceNetworks;
             resourceInputs["sourceType"] = state?.sourceType;
             resourceInputs["suffix"] = state?.suffix;
             resourceInputs["triggerType"] = state?.triggerType;
@@ -283,6 +305,7 @@ export class Compose extends pulumi.CustomResource {
             resourceInputs["composeFile"] = args?.composeFile;
             resourceInputs["composePath"] = args?.composePath;
             resourceInputs["composeType"] = args?.composeType;
+            resourceInputs["createEnvFile"] = args?.createEnvFile;
             resourceInputs["customGitBranch"] = args?.customGitBranch;
             resourceInputs["customGitSshKeyId"] = args?.customGitSshKeyId;
             resourceInputs["customGitUrl"] = args?.customGitUrl;
@@ -302,6 +325,7 @@ export class Compose extends pulumi.CustomResource {
             resourceInputs["gitlabPathNamespace"] = args?.gitlabPathNamespace;
             resourceInputs["gitlabProjectId"] = args?.gitlabProjectId;
             resourceInputs["gitlabRepository"] = args?.gitlabRepository;
+            resourceInputs["icon"] = args?.icon;
             resourceInputs["isolatedDeployment"] = args?.isolatedDeployment;
             resourceInputs["isolatedDeploymentsVolume"] = args?.isolatedDeploymentsVolume;
             resourceInputs["name"] = args?.name;
@@ -309,6 +333,7 @@ export class Compose extends pulumi.CustomResource {
             resourceInputs["randomize"] = args?.randomize;
             resourceInputs["repository"] = args?.repository;
             resourceInputs["serverId"] = args?.serverId;
+            resourceInputs["serviceNetworks"] = args?.serviceNetworks;
             resourceInputs["sourceType"] = args?.sourceType;
             resourceInputs["suffix"] = args?.suffix;
             resourceInputs["triggerType"] = args?.triggerType;
@@ -328,179 +353,191 @@ export interface ComposeState {
     /**
      * Unique Docker stack name. Generated by Dokploy when omitted. Changing it forces a new stack.
      */
-    appName?: pulumi.Input<string>;
+    appName?: pulumi.Input<string | undefined>;
     /**
      * Deploy automatically when the configured trigger fires.
      */
-    autoDeploy?: pulumi.Input<boolean>;
+    autoDeploy?: pulumi.Input<boolean | undefined>;
     /**
      * Bitbucket branch to deploy.
      */
-    bitbucketBranch?: pulumi.Input<string>;
+    bitbucketBranch?: pulumi.Input<string | undefined>;
     /**
      * ID of the configured Bitbucket provider connection.
      */
-    bitbucketId?: pulumi.Input<string>;
+    bitbucketId?: pulumi.Input<string | undefined>;
     /**
      * Bitbucket repository owner.
      */
-    bitbucketOwner?: pulumi.Input<string>;
+    bitbucketOwner?: pulumi.Input<string | undefined>;
     /**
      * Bitbucket repository name.
      */
-    bitbucketRepository?: pulumi.Input<string>;
+    bitbucketRepository?: pulumi.Input<string | undefined>;
     /**
      * Bitbucket repository slug.
      */
-    bitbucketRepositorySlug?: pulumi.Input<string>;
+    bitbucketRepositorySlug?: pulumi.Input<string | undefined>;
     /**
      * GitHub branch to deploy.
      */
-    branch?: pulumi.Input<string>;
+    branch?: pulumi.Input<string | undefined>;
     /**
      * Custom `docker compose` command to run.
      */
-    command?: pulumi.Input<string>;
+    command?: pulumi.Input<string | undefined>;
     /**
      * Inline Compose file contents. Used when `sourceType` is `raw`.
      */
-    composeFile?: pulumi.Input<string>;
+    composeFile?: pulumi.Input<string | undefined>;
     /**
      * Path to the Compose file within the repository.
      */
-    composePath?: pulumi.Input<string>;
+    composePath?: pulumi.Input<string | undefined>;
     /**
      * Current status reported by Dokploy: `idle`, `running`, `done` or `error`.
      */
-    composeStatus?: pulumi.Input<string>;
+    composeStatus?: pulumi.Input<string | undefined>;
     /**
      * Whether to run the stack with Docker Compose or Docker Swarm. Valid values: `docker-compose`, `stack`.
      */
-    composeType?: pulumi.Input<string>;
+    composeType?: pulumi.Input<string | undefined>;
+    /**
+     * Write the environment variables to a `.env` file next to the Compose file.
+     */
+    createEnvFile?: pulumi.Input<boolean | undefined>;
     /**
      * RFC 3339 timestamp of when the stack was created.
      */
-    createdAt?: pulumi.Input<string>;
+    createdAt?: pulumi.Input<string | undefined>;
     /**
      * Branch to deploy for a custom Git remote.
      */
-    customGitBranch?: pulumi.Input<string>;
+    customGitBranch?: pulumi.Input<string | undefined>;
     /**
      * SSH key used to clone a private custom Git remote.
      */
-    customGitSshKeyId?: pulumi.Input<string>;
+    customGitSshKeyId?: pulumi.Input<string | undefined>;
     /**
      * Git remote URL, when `sourceType` is `git`.
      */
-    customGitUrl?: pulumi.Input<string>;
+    customGitUrl?: pulumi.Input<string | undefined>;
     /**
      * Whether to delete the stack's Docker volumes when this resource is destroyed. Defaults to `false`, which preserves the data.
      */
-    deleteVolumes?: pulumi.Input<boolean>;
+    deleteVolumes?: pulumi.Input<boolean | undefined>;
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * Clone Git submodules when checking out the repository.
      */
-    enableSubmodules?: pulumi.Input<boolean>;
+    enableSubmodules?: pulumi.Input<boolean | undefined>;
     /**
      * Environment variables in `KEY=value` format, one per line.
      */
-    env?: pulumi.Input<string>;
+    env?: pulumi.Input<string | undefined>;
     /**
      * Environment this stack belongs to.
      */
-    environmentId?: pulumi.Input<string>;
+    environmentId?: pulumi.Input<string | undefined>;
     /**
      * Gitea branch to deploy.
      */
-    giteaBranch?: pulumi.Input<string>;
+    giteaBranch?: pulumi.Input<string | undefined>;
     /**
      * ID of the configured Gitea provider connection.
      */
-    giteaId?: pulumi.Input<string>;
+    giteaId?: pulumi.Input<string | undefined>;
     /**
      * Gitea repository owner.
      */
-    giteaOwner?: pulumi.Input<string>;
+    giteaOwner?: pulumi.Input<string | undefined>;
     /**
      * Gitea repository name.
      */
-    giteaRepository?: pulumi.Input<string>;
+    giteaRepository?: pulumi.Input<string | undefined>;
     /**
      * ID of the configured GitHub provider connection.
      */
-    githubId?: pulumi.Input<string>;
+    githubId?: pulumi.Input<string | undefined>;
     /**
      * GitLab branch to deploy.
      */
-    gitlabBranch?: pulumi.Input<string>;
+    gitlabBranch?: pulumi.Input<string | undefined>;
     /**
      * ID of the configured GitLab provider connection.
      */
-    gitlabId?: pulumi.Input<string>;
+    gitlabId?: pulumi.Input<string | undefined>;
     /**
      * GitLab repository owner.
      */
-    gitlabOwner?: pulumi.Input<string>;
+    gitlabOwner?: pulumi.Input<string | undefined>;
     /**
      * Full GitLab namespace path.
      */
-    gitlabPathNamespace?: pulumi.Input<string>;
+    gitlabPathNamespace?: pulumi.Input<string | undefined>;
     /**
      * Numeric GitLab project ID.
      */
-    gitlabProjectId?: pulumi.Input<number>;
+    gitlabProjectId?: pulumi.Input<number | undefined>;
     /**
      * GitLab repository name.
      */
-    gitlabRepository?: pulumi.Input<string>;
+    gitlabRepository?: pulumi.Input<string | undefined>;
+    /**
+     * Icon shown next to the stack in the Dokploy UI.
+     */
+    icon?: pulumi.Input<string | undefined>;
     /**
      * Run the stack on its own isolated Docker network.
      */
-    isolatedDeployment?: pulumi.Input<boolean>;
+    isolatedDeployment?: pulumi.Input<boolean | undefined>;
     /**
      * Prefix volume names for isolated deployments. Retained for backwards compatibility.
      */
-    isolatedDeploymentsVolume?: pulumi.Input<boolean>;
+    isolatedDeploymentsVolume?: pulumi.Input<boolean | undefined>;
     /**
      * Display name of the stack.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * GitHub repository owner.
      */
-    owner?: pulumi.Input<string>;
+    owner?: pulumi.Input<string | undefined>;
     /**
      * Append a random suffix to service and volume names.
      */
-    randomize?: pulumi.Input<boolean>;
+    randomize?: pulumi.Input<boolean | undefined>;
     /**
      * GitHub repository name.
      */
-    repository?: pulumi.Input<string>;
+    repository?: pulumi.Input<string | undefined>;
     /**
      * Remote server to deploy on. Omit to use the Dokploy host itself.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
+    /**
+     * Per-service Docker network attachments, as a JSON object mapping each service name in the stack to an array of network IDs.
+     */
+    serviceNetworks?: pulumi.Input<string | undefined>;
     /**
      * Where the Compose file comes from. Valid values: `git`, `github`, `gitlab`, `bitbucket`, `gitea`, `raw`.
      */
-    sourceType?: pulumi.Input<string>;
+    sourceType?: pulumi.Input<string | undefined>;
     /**
      * Suffix appended to generated resource names.
      */
-    suffix?: pulumi.Input<string>;
+    suffix?: pulumi.Input<string | undefined>;
     /**
      * What triggers an automatic deployment. Valid values: `push`, `tag`.
      */
-    triggerType?: pulumi.Input<string>;
+    triggerType?: pulumi.Input<string | undefined>;
     /**
      * Glob patterns that limit which changed paths trigger an automatic deployment.
      */
-    watchPaths?: pulumi.Input<pulumi.Input<string>[]>;
+    watchPaths?: pulumi.Input<pulumi.Input<string>[] | undefined>;
 }
 
 /**
@@ -510,79 +547,83 @@ export interface ComposeArgs {
     /**
      * Unique Docker stack name. Generated by Dokploy when omitted. Changing it forces a new stack.
      */
-    appName?: pulumi.Input<string>;
+    appName?: pulumi.Input<string | undefined>;
     /**
      * Deploy automatically when the configured trigger fires.
      */
-    autoDeploy?: pulumi.Input<boolean>;
+    autoDeploy?: pulumi.Input<boolean | undefined>;
     /**
      * Bitbucket branch to deploy.
      */
-    bitbucketBranch?: pulumi.Input<string>;
+    bitbucketBranch?: pulumi.Input<string | undefined>;
     /**
      * ID of the configured Bitbucket provider connection.
      */
-    bitbucketId?: pulumi.Input<string>;
+    bitbucketId?: pulumi.Input<string | undefined>;
     /**
      * Bitbucket repository owner.
      */
-    bitbucketOwner?: pulumi.Input<string>;
+    bitbucketOwner?: pulumi.Input<string | undefined>;
     /**
      * Bitbucket repository name.
      */
-    bitbucketRepository?: pulumi.Input<string>;
+    bitbucketRepository?: pulumi.Input<string | undefined>;
     /**
      * Bitbucket repository slug.
      */
-    bitbucketRepositorySlug?: pulumi.Input<string>;
+    bitbucketRepositorySlug?: pulumi.Input<string | undefined>;
     /**
      * GitHub branch to deploy.
      */
-    branch?: pulumi.Input<string>;
+    branch?: pulumi.Input<string | undefined>;
     /**
      * Custom `docker compose` command to run.
      */
-    command?: pulumi.Input<string>;
+    command?: pulumi.Input<string | undefined>;
     /**
      * Inline Compose file contents. Used when `sourceType` is `raw`.
      */
-    composeFile?: pulumi.Input<string>;
+    composeFile?: pulumi.Input<string | undefined>;
     /**
      * Path to the Compose file within the repository.
      */
-    composePath?: pulumi.Input<string>;
+    composePath?: pulumi.Input<string | undefined>;
     /**
      * Whether to run the stack with Docker Compose or Docker Swarm. Valid values: `docker-compose`, `stack`.
      */
-    composeType?: pulumi.Input<string>;
+    composeType?: pulumi.Input<string | undefined>;
+    /**
+     * Write the environment variables to a `.env` file next to the Compose file.
+     */
+    createEnvFile?: pulumi.Input<boolean | undefined>;
     /**
      * Branch to deploy for a custom Git remote.
      */
-    customGitBranch?: pulumi.Input<string>;
+    customGitBranch?: pulumi.Input<string | undefined>;
     /**
      * SSH key used to clone a private custom Git remote.
      */
-    customGitSshKeyId?: pulumi.Input<string>;
+    customGitSshKeyId?: pulumi.Input<string | undefined>;
     /**
      * Git remote URL, when `sourceType` is `git`.
      */
-    customGitUrl?: pulumi.Input<string>;
+    customGitUrl?: pulumi.Input<string | undefined>;
     /**
      * Whether to delete the stack's Docker volumes when this resource is destroyed. Defaults to `false`, which preserves the data.
      */
-    deleteVolumes?: pulumi.Input<boolean>;
+    deleteVolumes?: pulumi.Input<boolean | undefined>;
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * Clone Git submodules when checking out the repository.
      */
-    enableSubmodules?: pulumi.Input<boolean>;
+    enableSubmodules?: pulumi.Input<boolean | undefined>;
     /**
      * Environment variables in `KEY=value` format, one per line.
      */
-    env?: pulumi.Input<string>;
+    env?: pulumi.Input<string | undefined>;
     /**
      * Environment this stack belongs to.
      */
@@ -590,89 +631,97 @@ export interface ComposeArgs {
     /**
      * Gitea branch to deploy.
      */
-    giteaBranch?: pulumi.Input<string>;
+    giteaBranch?: pulumi.Input<string | undefined>;
     /**
      * ID of the configured Gitea provider connection.
      */
-    giteaId?: pulumi.Input<string>;
+    giteaId?: pulumi.Input<string | undefined>;
     /**
      * Gitea repository owner.
      */
-    giteaOwner?: pulumi.Input<string>;
+    giteaOwner?: pulumi.Input<string | undefined>;
     /**
      * Gitea repository name.
      */
-    giteaRepository?: pulumi.Input<string>;
+    giteaRepository?: pulumi.Input<string | undefined>;
     /**
      * ID of the configured GitHub provider connection.
      */
-    githubId?: pulumi.Input<string>;
+    githubId?: pulumi.Input<string | undefined>;
     /**
      * GitLab branch to deploy.
      */
-    gitlabBranch?: pulumi.Input<string>;
+    gitlabBranch?: pulumi.Input<string | undefined>;
     /**
      * ID of the configured GitLab provider connection.
      */
-    gitlabId?: pulumi.Input<string>;
+    gitlabId?: pulumi.Input<string | undefined>;
     /**
      * GitLab repository owner.
      */
-    gitlabOwner?: pulumi.Input<string>;
+    gitlabOwner?: pulumi.Input<string | undefined>;
     /**
      * Full GitLab namespace path.
      */
-    gitlabPathNamespace?: pulumi.Input<string>;
+    gitlabPathNamespace?: pulumi.Input<string | undefined>;
     /**
      * Numeric GitLab project ID.
      */
-    gitlabProjectId?: pulumi.Input<number>;
+    gitlabProjectId?: pulumi.Input<number | undefined>;
     /**
      * GitLab repository name.
      */
-    gitlabRepository?: pulumi.Input<string>;
+    gitlabRepository?: pulumi.Input<string | undefined>;
+    /**
+     * Icon shown next to the stack in the Dokploy UI.
+     */
+    icon?: pulumi.Input<string | undefined>;
     /**
      * Run the stack on its own isolated Docker network.
      */
-    isolatedDeployment?: pulumi.Input<boolean>;
+    isolatedDeployment?: pulumi.Input<boolean | undefined>;
     /**
      * Prefix volume names for isolated deployments. Retained for backwards compatibility.
      */
-    isolatedDeploymentsVolume?: pulumi.Input<boolean>;
+    isolatedDeploymentsVolume?: pulumi.Input<boolean | undefined>;
     /**
      * Display name of the stack.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * GitHub repository owner.
      */
-    owner?: pulumi.Input<string>;
+    owner?: pulumi.Input<string | undefined>;
     /**
      * Append a random suffix to service and volume names.
      */
-    randomize?: pulumi.Input<boolean>;
+    randomize?: pulumi.Input<boolean | undefined>;
     /**
      * GitHub repository name.
      */
-    repository?: pulumi.Input<string>;
+    repository?: pulumi.Input<string | undefined>;
     /**
      * Remote server to deploy on. Omit to use the Dokploy host itself.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
+    /**
+     * Per-service Docker network attachments, as a JSON object mapping each service name in the stack to an array of network IDs.
+     */
+    serviceNetworks?: pulumi.Input<string | undefined>;
     /**
      * Where the Compose file comes from. Valid values: `git`, `github`, `gitlab`, `bitbucket`, `gitea`, `raw`.
      */
-    sourceType?: pulumi.Input<string>;
+    sourceType?: pulumi.Input<string | undefined>;
     /**
      * Suffix appended to generated resource names.
      */
-    suffix?: pulumi.Input<string>;
+    suffix?: pulumi.Input<string | undefined>;
     /**
      * What triggers an automatic deployment. Valid values: `push`, `tag`.
      */
-    triggerType?: pulumi.Input<string>;
+    triggerType?: pulumi.Input<string | undefined>;
     /**
      * Glob patterns that limit which changed paths trigger an automatic deployment.
      */
-    watchPaths?: pulumi.Input<pulumi.Input<string>[]>;
+    watchPaths?: pulumi.Input<pulumi.Input<string>[] | undefined>;
 }

sdk/nodejs/destination.ts

@@ -4,6 +4,11 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * An S3-compatible bucket that Dokploy writes database and volume backups to.
+ *
+ * > The secret access key is stored in Terraform state. Use a state backend with encryption at rest.
+ */
 export class Destination extends pulumi.CustomResource {
     /**
      * Get an existing Destination resource's state with the given name, ID, and optional extra
@@ -138,43 +143,43 @@ export interface DestinationState {
     /**
      * S3 access key ID.
      */
-    accessKey?: pulumi.Input<string>;
+    accessKey?: pulumi.Input<string | undefined>;
     /**
      * Extra flags passed to the underlying `rclone` invocation.
      */
-    additionalFlags?: pulumi.Input<pulumi.Input<string>[]>;
+    additionalFlags?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Bucket name.
      */
-    bucket?: pulumi.Input<string>;
+    bucket?: pulumi.Input<string | undefined>;
     /**
      * Timestamp of when the destination was created.
      */
-    createdAt?: pulumi.Input<string>;
+    createdAt?: pulumi.Input<string | undefined>;
     /**
      * S3 endpoint URL.
      */
-    endpoint?: pulumi.Input<string>;
+    endpoint?: pulumi.Input<string | undefined>;
     /**
      * Display name of the destination.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * Provider label, for example `s3` or `cloudflare`. Named `providerName` because `provider` is reserved by Terraform.
      */
-    providerName?: pulumi.Input<string>;
+    providerName?: pulumi.Input<string | undefined>;
     /**
      * Bucket region, for example `us-east-1`.
      */
-    region?: pulumi.Input<string>;
+    region?: pulumi.Input<string | undefined>;
     /**
      * S3 secret access key.
      */
-    secretAccessKey?: pulumi.Input<string>;
+    secretAccessKey?: pulumi.Input<string | undefined>;
     /**
      * Server this destination is scoped to.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
 }
 
 /**
@@ -188,7 +193,7 @@ export interface DestinationArgs {
     /**
      * Extra flags passed to the underlying `rclone` invocation.
      */
-    additionalFlags?: pulumi.Input<pulumi.Input<string>[]>;
+    additionalFlags?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Bucket name.
      */
@@ -200,11 +205,11 @@ export interface DestinationArgs {
     /**
      * Display name of the destination.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * Provider label, for example `s3` or `cloudflare`. Named `providerName` because `provider` is reserved by Terraform.
      */
-    providerName?: pulumi.Input<string>;
+    providerName?: pulumi.Input<string | undefined>;
     /**
      * Bucket region, for example `us-east-1`.
      */
@@ -216,5 +221,5 @@ export interface DestinationArgs {
     /**
      * Server this destination is scoped to.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
 }

sdk/nodejs/dnsProvider.ts

@@ -0,0 +1,135 @@
+// *** WARNING: this file was generated by pulumi-language-nodejs. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import * as pulumi from "@pulumi/pulumi";
+import * as utilities from "./utilities";
+
+/**
+ * A DNS provider connection Dokploy uses to create records for domains automatically.
+ *
+ * `config` is a JSON object whose shape depends on `providerType`:
+ */
+export class DnsProvider extends pulumi.CustomResource {
+    /**
+     * Get an existing DnsProvider resource's state with the given name, ID, and optional extra
+     * properties used to qualify the lookup.
+     *
+     * @param name The _unique_ name of the resulting resource.
+     * @param id The _unique_ provider ID of the resource to lookup.
+     * @param state Any extra arguments used during the lookup.
+     * @param opts Optional settings to control the behavior of the CustomResource.
+     */
+    public static get(name: string, id: pulumi.Input<pulumi.ID>, state?: DnsProviderState, opts?: pulumi.CustomResourceOptions): DnsProvider {
+        return new DnsProvider(name, <any>state, { ...opts, id: id });
+    }
+
+    /** @internal */
+    public static readonly __pulumiType = 'dokploy:index/dnsProvider:DnsProvider';
+
+    /**
+     * Returns true if the given object is an instance of DnsProvider.  This is designed to work even
+     * when multiple copies of the Pulumi SDK have been loaded into the same process.
+     */
+    public static isInstance(obj: any): obj is DnsProvider {
+        if (obj === undefined || obj === null) {
+            return false;
+        }
+        return obj['__pulumiType'] === DnsProvider.__pulumiType;
+    }
+
+    /**
+     * Provider credentials as a JSON object, including the `providerType` discriminator.
+     */
+    declare public readonly config: pulumi.Output<string>;
+    /**
+     * RFC 3339 timestamp of when the connection was created.
+     */
+    declare public /*out*/ readonly createdAt: pulumi.Output<string>;
+    /**
+     * Name of the connection. Must be unique within the organization and may contain only letters, digits, `-` and `_`.
+     */
+    declare public readonly name: pulumi.Output<string>;
+    /**
+     * Organization that owns the connection.
+     */
+    declare public /*out*/ readonly organizationId: pulumi.Output<string>;
+    /**
+     * Provider kind derived from `config`: `cloudflare` or `route53`.
+     */
+    declare public /*out*/ readonly providerType: pulumi.Output<string>;
+
+    /**
+     * Create a DnsProvider resource with the given unique name, arguments, and options.
+     *
+     * @param name The _unique_ name of the resource.
+     * @param args The arguments to use to populate this resource's properties.
+     * @param opts A bag of options that control this resource's behavior.
+     */
+    constructor(name: string, args: DnsProviderArgs, opts?: pulumi.CustomResourceOptions)
+    constructor(name: string, argsOrState?: DnsProviderArgs | DnsProviderState, opts?: pulumi.CustomResourceOptions) {
+        let resourceInputs: pulumi.Inputs = {};
+        opts = opts || {};
+        if (opts.id) {
+            const state = argsOrState as DnsProviderState | undefined;
+            resourceInputs["config"] = state?.config;
+            resourceInputs["createdAt"] = state?.createdAt;
+            resourceInputs["name"] = state?.name;
+            resourceInputs["organizationId"] = state?.organizationId;
+            resourceInputs["providerType"] = state?.providerType;
+        } else {
+            const args = argsOrState as DnsProviderArgs | undefined;
+            if (args?.config === undefined && !opts.urn) {
+                throw new Error("Missing required property 'config'");
+            }
+            resourceInputs["config"] = args?.config ? pulumi.secret(args.config) : undefined;
+            resourceInputs["name"] = args?.name;
+            resourceInputs["createdAt"] = undefined /*out*/;
+            resourceInputs["organizationId"] = undefined /*out*/;
+            resourceInputs["providerType"] = undefined /*out*/;
+        }
+        opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts);
+        const secretOpts = { additionalSecretOutputs: ["config"] };
+        opts = pulumi.mergeOptions(opts, secretOpts);
+        super(DnsProvider.__pulumiType, name, resourceInputs, opts);
+    }
+}
+
+/**
+ * Input properties used for looking up and filtering DnsProvider resources.
+ */
+export interface DnsProviderState {
+    /**
+     * Provider credentials as a JSON object, including the `providerType` discriminator.
+     */
+    config?: pulumi.Input<string | undefined>;
+    /**
+     * RFC 3339 timestamp of when the connection was created.
+     */
+    createdAt?: pulumi.Input<string | undefined>;
+    /**
+     * Name of the connection. Must be unique within the organization and may contain only letters, digits, `-` and `_`.
+     */
+    name?: pulumi.Input<string | undefined>;
+    /**
+     * Organization that owns the connection.
+     */
+    organizationId?: pulumi.Input<string | undefined>;
+    /**
+     * Provider kind derived from `config`: `cloudflare` or `route53`.
+     */
+    providerType?: pulumi.Input<string | undefined>;
+}
+
+/**
+ * The set of arguments for constructing a DnsProvider resource.
+ */
+export interface DnsProviderArgs {
+    /**
+     * Provider credentials as a JSON object, including the `providerType` discriminator.
+     */
+    config: pulumi.Input<string>;
+    /**
+     * Name of the connection. Must be unique within the organization and may contain only letters, digits, `-` and `_`.
+     */
+    name?: pulumi.Input<string | undefined>;
+}

sdk/nodejs/domain.ts

@@ -4,6 +4,11 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * A domain routed to an application or a Compose service through Dokploy's Traefik instance.
+ *
+ * Set exactly one of `applicationId` or `composeId`. When targeting a Compose stack, `serviceName` selects which service in the stack receives the traffic.
+ */
 export class Domain extends pulumi.CustomResource {
     /**
      * Get an existing Domain resource's state with the given name, ID, and optional extra
@@ -60,6 +65,10 @@ export class Domain extends pulumi.CustomResource {
      * What kind of target this domain points at. Valid values: `compose`, `application`, `preview`.
      */
     declare public readonly domainType: pulumi.Output<string>;
+    /**
+     * Whether the domain is served. Setting this to `false` removes the route from Traefik but keeps the certificate, path and middleware configuration intact, so the domain can be brought back without reconfiguring it.
+     */
+    declare public readonly enabled: pulumi.Output<boolean>;
     /**
      * Protect this domain with Dokploy's forward auth.
      */
@@ -121,6 +130,7 @@ export class Domain extends pulumi.CustomResource {
             resourceInputs["customCertResolver"] = state?.customCertResolver;
             resourceInputs["customEntrypoint"] = state?.customEntrypoint;
             resourceInputs["domainType"] = state?.domainType;
+            resourceInputs["enabled"] = state?.enabled;
             resourceInputs["forwardAuthEnabled"] = state?.forwardAuthEnabled;
             resourceInputs["host"] = state?.host;
             resourceInputs["https"] = state?.https;
@@ -142,6 +152,7 @@ export class Domain extends pulumi.CustomResource {
             resourceInputs["customCertResolver"] = args?.customCertResolver;
             resourceInputs["customEntrypoint"] = args?.customEntrypoint;
             resourceInputs["domainType"] = args?.domainType;
+            resourceInputs["enabled"] = args?.enabled;
             resourceInputs["forwardAuthEnabled"] = args?.forwardAuthEnabled;
             resourceInputs["host"] = args?.host;
             resourceInputs["https"] = args?.https;
@@ -166,71 +177,75 @@ export interface DomainState {
     /**
      * Application this domain routes to.
      */
-    applicationId?: pulumi.Input<string>;
+    applicationId?: pulumi.Input<string | undefined>;
     /**
      * How TLS certificates are obtained. Use `letsencrypt` for automatic certificates. Valid values: `letsencrypt`, `none`, `custom`.
      */
-    certificateType?: pulumi.Input<string>;
+    certificateType?: pulumi.Input<string | undefined>;
     /**
      * Compose stack this domain routes to.
      */
-    composeId?: pulumi.Input<string>;
+    composeId?: pulumi.Input<string | undefined>;
     /**
      * RFC 3339 timestamp of when the domain was created.
      */
-    createdAt?: pulumi.Input<string>;
+    createdAt?: pulumi.Input<string | undefined>;
     /**
      * Traefik certificate resolver name, when `certificateType` is `custom`.
      */
-    customCertResolver?: pulumi.Input<string>;
+    customCertResolver?: pulumi.Input<string | undefined>;
     /**
      * Traefik entrypoint to bind, when not using the defaults.
      */
-    customEntrypoint?: pulumi.Input<string>;
+    customEntrypoint?: pulumi.Input<string | undefined>;
     /**
      * What kind of target this domain points at. Valid values: `compose`, `application`, `preview`.
      */
-    domainType?: pulumi.Input<string>;
+    domainType?: pulumi.Input<string | undefined>;
+    /**
+     * Whether the domain is served. Setting this to `false` removes the route from Traefik but keeps the certificate, path and middleware configuration intact, so the domain can be brought back without reconfiguring it.
+     */
+    enabled?: pulumi.Input<boolean | undefined>;
     /**
      * Protect this domain with Dokploy's forward auth.
      */
-    forwardAuthEnabled?: pulumi.Input<boolean>;
+    forwardAuthEnabled?: pulumi.Input<boolean | undefined>;
     /**
      * Fully-qualified hostname, for example `api.example.com`.
      */
-    host?: pulumi.Input<string>;
+    host?: pulumi.Input<string | undefined>;
     /**
      * Serve the domain over HTTPS and redirect HTTP traffic to it.
      */
-    https?: pulumi.Input<boolean>;
+    https?: pulumi.Input<boolean | undefined>;
     /**
      * Path the request is rewritten to before it reaches the container, defaults to `/`.
      */
-    internalPath?: pulumi.Input<string>;
+    internalPath?: pulumi.Input<string | undefined>;
     /**
      * Names of Traefik middlewares to apply.
      */
-    middlewares?: pulumi.Input<pulumi.Input<string>[]>;
+    middlewares?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Path prefix this domain routes, defaults to `/`.
      */
-    path?: pulumi.Input<string>;
+    path?: pulumi.Input<string | undefined>;
     /**
      * Container port that receives the traffic, defaults to `3000`.
      */
-    port?: pulumi.Input<number>;
+    port?: pulumi.Input<number | undefined>;
     /**
      * Preview deployment this domain routes to.
      */
-    previewDeploymentId?: pulumi.Input<string>;
+    previewDeploymentId?: pulumi.Input<string | undefined>;
     /**
      * Name of the service inside a Compose stack that receives the traffic. Required when `composeId` is set.
      */
-    serviceName?: pulumi.Input<string>;
+    serviceName?: pulumi.Input<string | undefined>;
     /**
      * Strip `path` from the request before forwarding it.
      */
-    stripPath?: pulumi.Input<boolean>;
+    stripPath?: pulumi.Input<boolean | undefined>;
 }
 
 /**
@@ -240,31 +255,35 @@ export interface DomainArgs {
     /**
      * Application this domain routes to.
      */
-    applicationId?: pulumi.Input<string>;
+    applicationId?: pulumi.Input<string | undefined>;
     /**
      * How TLS certificates are obtained. Use `letsencrypt` for automatic certificates. Valid values: `letsencrypt`, `none`, `custom`.
      */
-    certificateType?: pulumi.Input<string>;
+    certificateType?: pulumi.Input<string | undefined>;
     /**
      * Compose stack this domain routes to.
      */
-    composeId?: pulumi.Input<string>;
+    composeId?: pulumi.Input<string | undefined>;
     /**
      * Traefik certificate resolver name, when `certificateType` is `custom`.
      */
-    customCertResolver?: pulumi.Input<string>;
+    customCertResolver?: pulumi.Input<string | undefined>;
     /**
      * Traefik entrypoint to bind, when not using the defaults.
      */
-    customEntrypoint?: pulumi.Input<string>;
+    customEntrypoint?: pulumi.Input<string | undefined>;
     /**
      * What kind of target this domain points at. Valid values: `compose`, `application`, `preview`.
      */
-    domainType?: pulumi.Input<string>;
+    domainType?: pulumi.Input<string | undefined>;
+    /**
+     * Whether the domain is served. Setting this to `false` removes the route from Traefik but keeps the certificate, path and middleware configuration intact, so the domain can be brought back without reconfiguring it.
+     */
+    enabled?: pulumi.Input<boolean | undefined>;
     /**
      * Protect this domain with Dokploy's forward auth.
      */
-    forwardAuthEnabled?: pulumi.Input<boolean>;
+    forwardAuthEnabled?: pulumi.Input<boolean | undefined>;
     /**
      * Fully-qualified hostname, for example `api.example.com`.
      */
@@ -272,33 +291,33 @@ export interface DomainArgs {
     /**
      * Serve the domain over HTTPS and redirect HTTP traffic to it.
      */
-    https?: pulumi.Input<boolean>;
+    https?: pulumi.Input<boolean | undefined>;
     /**
      * Path the request is rewritten to before it reaches the container, defaults to `/`.
      */
-    internalPath?: pulumi.Input<string>;
+    internalPath?: pulumi.Input<string | undefined>;
     /**
      * Names of Traefik middlewares to apply.
      */
-    middlewares?: pulumi.Input<pulumi.Input<string>[]>;
+    middlewares?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Path prefix this domain routes, defaults to `/`.
      */
-    path?: pulumi.Input<string>;
+    path?: pulumi.Input<string | undefined>;
     /**
      * Container port that receives the traffic, defaults to `3000`.
      */
-    port?: pulumi.Input<number>;
+    port?: pulumi.Input<number | undefined>;
     /**
      * Preview deployment this domain routes to.
      */
-    previewDeploymentId?: pulumi.Input<string>;
+    previewDeploymentId?: pulumi.Input<string | undefined>;
     /**
      * Name of the service inside a Compose stack that receives the traffic. Required when `composeId` is set.
      */
-    serviceName?: pulumi.Input<string>;
+    serviceName?: pulumi.Input<string | undefined>;
     /**
      * Strip `path` from the request before forwarding it.
      */
-    stripPath?: pulumi.Input<boolean>;
+    stripPath?: pulumi.Input<boolean | undefined>;
 }

sdk/nodejs/environment.ts

@@ -4,6 +4,11 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * An environment inside a Dokploy project, such as `staging` or `production`. Services belong to an environment rather than directly to a project.
+ *
+ * Dokploy creates a default `production` environment with every project; reference it via `dokploy_project.<name>.default_environment_id` instead of declaring it here.
+ */
 export class Environment extends pulumi.CustomResource {
     /**
      * Get an existing Environment resource's state with the given name, ID, and optional extra
@@ -100,27 +105,27 @@ export interface EnvironmentState {
     /**
      * RFC 3339 timestamp of when the environment was created.
      */
-    createdAt?: pulumi.Input<string>;
+    createdAt?: pulumi.Input<string | undefined>;
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * Environment-wide variables in `KEY=value` format, one per line. These are merged into every service in this environment.
      */
-    env?: pulumi.Input<string>;
+    env?: pulumi.Input<string | undefined>;
     /**
      * Whether this is the project's default environment.
      */
-    isDefault?: pulumi.Input<boolean>;
+    isDefault?: pulumi.Input<boolean | undefined>;
     /**
      * Environment name, for example `staging`.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * Project this environment belongs to.
      */
-    projectId?: pulumi.Input<string>;
+    projectId?: pulumi.Input<string | undefined>;
 }
 
 /**
@@ -130,15 +135,15 @@ export interface EnvironmentArgs {
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * Environment-wide variables in `KEY=value` format, one per line. These are merged into every service in this environment.
      */
-    env?: pulumi.Input<string>;
+    env?: pulumi.Input<string | undefined>;
     /**
      * Environment name, for example `staging`.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * Project this environment belongs to.
      */

sdk/nodejs/getApplication.ts

@@ -4,6 +4,9 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * Look up an existing application by ID.
+ */
 export function getApplication(args: GetApplicationArgs, opts?: pulumi.InvokeOptions): Promise<GetApplicationResult> {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
     return pulumi.runtime.invoke("dokploy:index/getApplication:getApplication", {
@@ -15,6 +18,9 @@ export function getApplication(args: GetApplicationArgs, opts?: pulumi.InvokeOpt
  * A collection of arguments for invoking getApplication.
  */
 export interface GetApplicationArgs {
+    /**
+     * Application identifier.
+     */
     id: string;
 }
 
@@ -22,16 +28,46 @@ export interface GetApplicationArgs {
  * A collection of values returned by getApplication.
  */
 export interface GetApplicationResult {
+    /**
+     * Docker service name.
+     */
     readonly appName: string;
+    /**
+     * Current status.
+     */
     readonly applicationStatus: string;
+    /**
+     * Build strategy.
+     */
     readonly buildType: string;
+    /**
+     * Creation timestamp.
+     */
     readonly createdAt: string;
+    /**
+     * Application description.
+     */
     readonly description: string;
+    /**
+     * Owning environment.
+     */
     readonly environmentId: string;
+    /**
+     * Application identifier.
+     */
     readonly id: string;
+    /**
+     * Application name.
+     */
     readonly name: string;
+    /**
+     * Source of the code or image.
+     */
     readonly sourceType: string;
 }
+/**
+ * Look up an existing application by ID.
+ */
 export function getApplicationOutput(args: GetApplicationOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output<GetApplicationResult> {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
     return pulumi.runtime.invokeOutput("dokploy:index/getApplication:getApplication", {
@@ -43,5 +79,8 @@ export function getApplicationOutput(args: GetApplicationOutputArgs, opts?: pulu
  * A collection of arguments for invoking getApplication.
  */
 export interface GetApplicationOutputArgs {
+    /**
+     * Application identifier.
+     */
     id: pulumi.Input<string>;
 }

sdk/nodejs/getEnvironment.ts

@@ -4,6 +4,9 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * Look up an existing environment by ID.
+ */
 export function getEnvironment(args: GetEnvironmentArgs, opts?: pulumi.InvokeOptions): Promise<GetEnvironmentResult> {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
     return pulumi.runtime.invoke("dokploy:index/getEnvironment:getEnvironment", {
@@ -15,6 +18,9 @@ export function getEnvironment(args: GetEnvironmentArgs, opts?: pulumi.InvokeOpt
  * A collection of arguments for invoking getEnvironment.
  */
 export interface GetEnvironmentArgs {
+    /**
+     * Environment identifier.
+     */
     id: string;
 }
 
@@ -22,14 +28,38 @@ export interface GetEnvironmentArgs {
  * A collection of values returned by getEnvironment.
  */
 export interface GetEnvironmentResult {
+    /**
+     * Creation timestamp.
+     */
     readonly createdAt: string;
+    /**
+     * Environment description.
+     */
     readonly description: string;
+    /**
+     * Environment-wide variables.
+     */
     readonly env: string;
+    /**
+     * Environment identifier.
+     */
     readonly id: string;
+    /**
+     * Whether this is the project's default environment.
+     */
     readonly isDefault: boolean;
+    /**
+     * Environment name.
+     */
     readonly name: string;
+    /**
+     * Owning project.
+     */
     readonly projectId: string;
 }
+/**
+ * Look up an existing environment by ID.
+ */
 export function getEnvironmentOutput(args: GetEnvironmentOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output<GetEnvironmentResult> {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
     return pulumi.runtime.invokeOutput("dokploy:index/getEnvironment:getEnvironment", {
@@ -41,5 +71,8 @@ export function getEnvironmentOutput(args: GetEnvironmentOutputArgs, opts?: pulu
  * A collection of arguments for invoking getEnvironment.
  */
 export interface GetEnvironmentOutputArgs {
+    /**
+     * Environment identifier.
+     */
     id: pulumi.Input<string>;
 }

sdk/nodejs/getProject.ts

@@ -6,6 +6,9 @@ import * as inputs from "./types/input";
 import * as outputs from "./types/output";
 import * as utilities from "./utilities";
 
+/**
+ * Look up an existing Dokploy project by ID, including its environments.
+ */
 export function getProject(args: GetProjectArgs, opts?: pulumi.InvokeOptions): Promise<GetProjectResult> {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
     return pulumi.runtime.invoke("dokploy:index/getProject:getProject", {
@@ -17,6 +20,9 @@ export function getProject(args: GetProjectArgs, opts?: pulumi.InvokeOptions): P
  * A collection of arguments for invoking getProject.
  */
 export interface GetProjectArgs {
+    /**
+     * Project identifier.
+     */
     id: string;
 }
 
@@ -24,15 +30,42 @@ export interface GetProjectArgs {
  * A collection of values returned by getProject.
  */
 export interface GetProjectResult {
+    /**
+     * Creation timestamp.
+     */
     readonly createdAt: string;
+    /**
+     * ID of the project's default environment.
+     */
     readonly defaultEnvironmentId: string;
+    /**
+     * Project description.
+     */
     readonly description: string;
+    /**
+     * Project-wide environment variables.
+     */
     readonly env: string;
+    /**
+     * Every environment in the project.
+     */
     readonly environments: outputs.GetProjectEnvironment[];
+    /**
+     * Project identifier.
+     */
     readonly id: string;
+    /**
+     * Project name.
+     */
     readonly name: string;
+    /**
+     * Owning organization.
+     */
     readonly organizationId: string;
 }
+/**
+ * Look up an existing Dokploy project by ID, including its environments.
+ */
 export function getProjectOutput(args: GetProjectOutputArgs, opts?: pulumi.InvokeOutputOptions): pulumi.Output<GetProjectResult> {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
     return pulumi.runtime.invokeOutput("dokploy:index/getProject:getProject", {
@@ -44,5 +77,8 @@ export function getProjectOutput(args: GetProjectOutputArgs, opts?: pulumi.Invok
  * A collection of arguments for invoking getProject.
  */
 export interface GetProjectOutputArgs {
+    /**
+     * Project identifier.
+     */
     id: pulumi.Input<string>;
 }

sdk/nodejs/getProjects.ts

@@ -6,6 +6,9 @@ import * as inputs from "./types/input";
 import * as outputs from "./types/output";
 import * as utilities from "./utilities";
 
+/**
+ * List every Dokploy project the API token can see.
+ */
 export function getProjects(opts?: pulumi.InvokeOptions): Promise<GetProjectsResult> {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
     return pulumi.runtime.invoke("dokploy:index/getProjects:getProjects", {
@@ -16,8 +19,14 @@ export function getProjects(opts?: pulumi.InvokeOptions): Promise<GetProjectsRes
  * A collection of values returned by getProjects.
  */
 export interface GetProjectsResult {
+    /**
+     * All visible projects.
+     */
     readonly projects: outputs.GetProjectsProject[];
 }
+/**
+ * List every Dokploy project the API token can see.
+ */
 export function getProjectsOutput(opts?: pulumi.InvokeOutputOptions): pulumi.Output<GetProjectsResult> {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
     return pulumi.runtime.invokeOutput("dokploy:index/getProjects:getProjects", {

sdk/nodejs/getServers.ts

@@ -6,6 +6,9 @@ import * as inputs from "./types/input";
 import * as outputs from "./types/output";
 import * as utilities from "./utilities";
 
+/**
+ * List the remote servers registered with Dokploy. Use a server's `id` as the `serverId` of an application, stack, or database to deploy it away from the Dokploy host.
+ */
 export function getServers(opts?: pulumi.InvokeOptions): Promise<GetServersResult> {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
     return pulumi.runtime.invoke("dokploy:index/getServers:getServers", {
@@ -16,8 +19,14 @@ export function getServers(opts?: pulumi.InvokeOptions): Promise<GetServersResul
  * A collection of values returned by getServers.
  */
 export interface GetServersResult {
+    /**
+     * All registered servers.
+     */
     readonly servers: outputs.GetServersServer[];
 }
+/**
+ * List the remote servers registered with Dokploy. Use a server's `id` as the `serverId` of an application, stack, or database to deploy it away from the Dokploy host.
+ */
 export function getServersOutput(opts?: pulumi.InvokeOutputOptions): pulumi.Output<GetServersResult> {
     opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts || {});
     return pulumi.runtime.invokeOutput("dokploy:index/getServers:getServers", {

sdk/nodejs/index.ts

@@ -25,6 +25,11 @@ export type Destination = import("./destination").Destination;
 export const Destination: typeof import("./destination").Destination = null as any;
 utilities.lazyLoad(exports, ["Destination"], () => require("./destination"));
 
+export { DnsProviderArgs, DnsProviderState } from "./dnsProvider";
+export type DnsProvider = import("./dnsProvider").DnsProvider;
+export const DnsProvider: typeof import("./dnsProvider").DnsProvider = null as any;
+utilities.lazyLoad(exports, ["DnsProvider"], () => require("./dnsProvider"));
+
 export { DomainArgs, DomainState } from "./domain";
 export type Domain = import("./domain").Domain;
 export const Domain: typeof import("./domain").Domain = null as any;
@@ -60,6 +65,11 @@ export const getServers: typeof import("./getServers").getServers = null as any;
 export const getServersOutput: typeof import("./getServers").getServersOutput = null as any;
 utilities.lazyLoad(exports, ["getServers","getServersOutput"], () => require("./getServers"));
 
+export { LibsqlArgs, LibsqlState } from "./libsql";
+export type Libsql = import("./libsql").Libsql;
+export const Libsql: typeof import("./libsql").Libsql = null as any;
+utilities.lazyLoad(exports, ["Libsql"], () => require("./libsql"));
+
 export { MariaDbArgs, MariaDbState } from "./mariaDb";
 export type MariaDb = import("./mariaDb").MariaDb;
 export const MariaDb: typeof import("./mariaDb").MariaDb = null as any;
@@ -80,6 +90,11 @@ export type MySql = import("./mySql").MySql;
 export const MySql: typeof import("./mySql").MySql = null as any;
 utilities.lazyLoad(exports, ["MySql"], () => require("./mySql"));
 
+export { NetworkArgs, NetworkState } from "./network";
+export type Network = import("./network").Network;
+export const Network: typeof import("./network").Network = null as any;
+utilities.lazyLoad(exports, ["Network"], () => require("./network"));
+
 export { PortArgs, PortState } from "./port";
 export type Port = import("./port").Port;
 export const Port: typeof import("./port").Port = null as any;
@@ -113,6 +128,11 @@ export type Registry = import("./registry").Registry;
 export const Registry: typeof import("./registry").Registry = null as any;
 utilities.lazyLoad(exports, ["Registry"], () => require("./registry"));
 
+export { ScheduleArgs, ScheduleState } from "./schedule";
+export type Schedule = import("./schedule").Schedule;
+export const Schedule: typeof import("./schedule").Schedule = null as any;
+utilities.lazyLoad(exports, ["Schedule"], () => require("./schedule"));
+
 export { SecurityArgs, SecurityState } from "./security";
 export type Security = import("./security").Security;
 export const Security: typeof import("./security").Security = null as any;
@@ -123,6 +143,16 @@ export type SshKey = import("./sshKey").SshKey;
 export const SshKey: typeof import("./sshKey").SshKey = null as any;
 utilities.lazyLoad(exports, ["SshKey"], () => require("./sshKey"));
 
+export { VaultProviderArgs, VaultProviderState } from "./vaultProvider";
+export type VaultProvider = import("./vaultProvider").VaultProvider;
+export const VaultProvider: typeof import("./vaultProvider").VaultProvider = null as any;
+utilities.lazyLoad(exports, ["VaultProvider"], () => require("./vaultProvider"));
+
+export { VolumeBackupArgs, VolumeBackupState } from "./volumeBackup";
+export type VolumeBackup = import("./volumeBackup").VolumeBackup;
+export const VolumeBackup: typeof import("./volumeBackup").VolumeBackup = null as any;
+utilities.lazyLoad(exports, ["VolumeBackup"], () => require("./volumeBackup"));
+
 
 // Export sub-modules:
 import * as config from "./config";
@@ -145,10 +175,14 @@ const _module = {
                 return new Compose(name, <any>undefined, { urn })
             case "dokploy:index/destination:Destination":
                 return new Destination(name, <any>undefined, { urn })
+            case "dokploy:index/dnsProvider:DnsProvider":
+                return new DnsProvider(name, <any>undefined, { urn })
             case "dokploy:index/domain:Domain":
                 return new Domain(name, <any>undefined, { urn })
             case "dokploy:index/environment:Environment":
                 return new Environment(name, <any>undefined, { urn })
+            case "dokploy:index/libsql:Libsql":
+                return new Libsql(name, <any>undefined, { urn })
             case "dokploy:index/mariaDb:MariaDb":
                 return new MariaDb(name, <any>undefined, { urn })
             case "dokploy:index/mongo:Mongo":
@@ -157,6 +191,8 @@ const _module = {
                 return new Mount(name, <any>undefined, { urn })
             case "dokploy:index/mySql:MySql":
                 return new MySql(name, <any>undefined, { urn })
+            case "dokploy:index/network:Network":
+                return new Network(name, <any>undefined, { urn })
             case "dokploy:index/port:Port":
                 return new Port(name, <any>undefined, { urn })
             case "dokploy:index/postgres:Postgres":
@@ -169,10 +205,16 @@ const _module = {
                 return new Redis(name, <any>undefined, { urn })
             case "dokploy:index/registry:Registry":
                 return new Registry(name, <any>undefined, { urn })
+            case "dokploy:index/schedule:Schedule":
+                return new Schedule(name, <any>undefined, { urn })
             case "dokploy:index/security:Security":
                 return new Security(name, <any>undefined, { urn })
             case "dokploy:index/sshKey:SshKey":
                 return new SshKey(name, <any>undefined, { urn })
+            case "dokploy:index/vaultProvider:VaultProvider":
+                return new VaultProvider(name, <any>undefined, { urn })
+            case "dokploy:index/volumeBackup:VolumeBackup":
+                return new VolumeBackup(name, <any>undefined, { urn })
             default:
                 throw new Error(`unknown resource type ${type}`);
         }
@@ -182,20 +224,26 @@ pulumi.runtime.registerResourceModule("dokploy", "index/application", _module)
 pulumi.runtime.registerResourceModule("dokploy", "index/certificate", _module)
 pulumi.runtime.registerResourceModule("dokploy", "index/compose", _module)
 pulumi.runtime.registerResourceModule("dokploy", "index/destination", _module)
+pulumi.runtime.registerResourceModule("dokploy", "index/dnsProvider", _module)
 pulumi.runtime.registerResourceModule("dokploy", "index/domain", _module)
 pulumi.runtime.registerResourceModule("dokploy", "index/environment", _module)
+pulumi.runtime.registerResourceModule("dokploy", "index/libsql", _module)
 pulumi.runtime.registerResourceModule("dokploy", "index/mariaDb", _module)
 pulumi.runtime.registerResourceModule("dokploy", "index/mongo", _module)
 pulumi.runtime.registerResourceModule("dokploy", "index/mount", _module)
 pulumi.runtime.registerResourceModule("dokploy", "index/mySql", _module)
+pulumi.runtime.registerResourceModule("dokploy", "index/network", _module)
 pulumi.runtime.registerResourceModule("dokploy", "index/port", _module)
 pulumi.runtime.registerResourceModule("dokploy", "index/postgres", _module)
 pulumi.runtime.registerResourceModule("dokploy", "index/project", _module)
 pulumi.runtime.registerResourceModule("dokploy", "index/redirect", _module)
 pulumi.runtime.registerResourceModule("dokploy", "index/redis", _module)
 pulumi.runtime.registerResourceModule("dokploy", "index/registry", _module)
+pulumi.runtime.registerResourceModule("dokploy", "index/schedule", _module)
 pulumi.runtime.registerResourceModule("dokploy", "index/security", _module)
 pulumi.runtime.registerResourceModule("dokploy", "index/sshKey", _module)
+pulumi.runtime.registerResourceModule("dokploy", "index/vaultProvider", _module)
+pulumi.runtime.registerResourceModule("dokploy", "index/volumeBackup", _module)
 pulumi.runtime.registerResourcePackage("dokploy", {
     version: utilities.getVersion(),
     constructProvider: (name: string, type: string, urn: string): pulumi.ProviderResource => {

sdk/nodejs/libsql.ts

@@ -0,0 +1,572 @@
+// *** WARNING: this file was generated by pulumi-language-nodejs. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import * as pulumi from "@pulumi/pulumi";
+import * as utilities from "./utilities";
+
+/**
+ * A managed libSQL instance running on Dokploy.
+ *
+ * > Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+ *
+ * > Credentials are stored in Terraform state. Use a state backend with encryption at rest.
+ *
+ * libSQL runs as a `sqld` server. A `primary` node owns the data; a `replica` node follows a primary named by `sqldPrimaryUrl`.
+ */
+export class Libsql extends pulumi.CustomResource {
+    /**
+     * Get an existing Libsql resource's state with the given name, ID, and optional extra
+     * properties used to qualify the lookup.
+     *
+     * @param name The _unique_ name of the resulting resource.
+     * @param id The _unique_ provider ID of the resource to lookup.
+     * @param state Any extra arguments used during the lookup.
+     * @param opts Optional settings to control the behavior of the CustomResource.
+     */
+    public static get(name: string, id: pulumi.Input<pulumi.ID>, state?: LibsqlState, opts?: pulumi.CustomResourceOptions): Libsql {
+        return new Libsql(name, <any>state, { ...opts, id: id });
+    }
+
+    /** @internal */
+    public static readonly __pulumiType = 'dokploy:index/libsql:Libsql';
+
+    /**
+     * Returns true if the given object is an instance of Libsql.  This is designed to work even
+     * when multiple copies of the Pulumi SDK have been loaded into the same process.
+     */
+    public static isInstance(obj: any): obj is Libsql {
+        if (obj === undefined || obj === null) {
+            return false;
+        }
+        return obj['__pulumiType'] === Libsql.__pulumiType;
+    }
+
+    /**
+     * Unique Docker service name. Generated from `name` when omitted, because Dokploy's libSQL endpoint does not generate one. Changing it forces a new database.
+     */
+    declare public readonly appName: pulumi.Output<string>;
+    /**
+     * Current status reported by Dokploy: `idle`, `running`, `done` or `error`.
+     */
+    declare public /*out*/ readonly applicationStatus: pulumi.Output<string>;
+    /**
+     * Override the container entrypoint command.
+     */
+    declare public readonly command: pulumi.Output<string | undefined>;
+    /**
+     * Hard CPU limit, for example `1`.
+     */
+    declare public readonly cpuLimit: pulumi.Output<string | undefined>;
+    /**
+     * Soft CPU reservation, for example `0.5`.
+     */
+    declare public readonly cpuReservation: pulumi.Output<string | undefined>;
+    /**
+     * RFC 3339 timestamp of when the database was created.
+     */
+    declare public /*out*/ readonly createdAt: pulumi.Output<string>;
+    /**
+     * Password for the database user.
+     */
+    declare public readonly databasePassword: pulumi.Output<string>;
+    /**
+     * Database user to create.
+     */
+    declare public readonly databaseUser: pulumi.Output<string>;
+    /**
+     * Free-form description.
+     */
+    declare public readonly description: pulumi.Output<string | undefined>;
+    /**
+     * Detach the service from the shared `dokploy-network`.
+     */
+    declare public readonly detachDokployNetwork: pulumi.Output<boolean>;
+    /**
+     * libSQL server image to run, for example `ghcr.io/tursodatabase/libsql-server:latest`.
+     */
+    declare public readonly dockerImage: pulumi.Output<string>;
+    /**
+     * Serve multiple logical databases from one instance through libSQL namespaces.
+     */
+    declare public readonly enableNamespaces: pulumi.Output<boolean>;
+    /**
+     * Docker Swarm endpoint specification, as a JSON object.
+     */
+    declare public readonly endpointSpecSwarm: pulumi.Output<string | undefined>;
+    /**
+     * Environment variables in `KEY=value` format, one per line.
+     */
+    declare public readonly env: pulumi.Output<string | undefined>;
+    /**
+     * Environment this database belongs to.
+     */
+    declare public readonly environmentId: pulumi.Output<string>;
+    /**
+     * Host port exposing the admin API.
+     */
+    declare public readonly externalAdminPort: pulumi.Output<number | undefined>;
+    /**
+     * Host port exposing the gRPC replication endpoint.
+     */
+    declare public readonly externalGrpcPort: pulumi.Output<number | undefined>;
+    /**
+     * Host port exposing the HTTP API.
+     */
+    declare public readonly externalPort: pulumi.Output<number | undefined>;
+    /**
+     * Docker Swarm health check configuration, as a JSON object.
+     */
+    declare public readonly healthCheckSwarm: pulumi.Output<string | undefined>;
+    /**
+     * Docker Swarm service labels, as a JSON object.
+     */
+    declare public readonly labelsSwarm: pulumi.Output<string | undefined>;
+    /**
+     * Hard memory limit, for example `512m`.
+     */
+    declare public readonly memoryLimit: pulumi.Output<string | undefined>;
+    /**
+     * Soft memory reservation, for example `256m`.
+     */
+    declare public readonly memoryReservation: pulumi.Output<string | undefined>;
+    /**
+     * Docker Swarm service mode, as a JSON object.
+     */
+    declare public readonly modeSwarm: pulumi.Output<string | undefined>;
+    /**
+     * Display name of the database.
+     */
+    declare public readonly name: pulumi.Output<string>;
+    /**
+     * IDs of additional Docker networks to attach.
+     */
+    declare public readonly networkIds: pulumi.Output<string[]>;
+    /**
+     * Docker Swarm network attachments, as a JSON array.
+     */
+    declare public readonly networkSwarm: pulumi.Output<string | undefined>;
+    /**
+     * Docker Swarm placement constraints, as a JSON object.
+     */
+    declare public readonly placementSwarm: pulumi.Output<string | undefined>;
+    /**
+     * Number of replicas to run.
+     */
+    declare public readonly replicas: pulumi.Output<number>;
+    /**
+     * Docker Swarm restart policy, as a JSON object.
+     */
+    declare public readonly restartPolicySwarm: pulumi.Output<string | undefined>;
+    /**
+     * Docker Swarm rollback configuration, as a JSON object.
+     */
+    declare public readonly rollbackConfigSwarm: pulumi.Output<string | undefined>;
+    /**
+     * Remote server to deploy on. Omit to use the Dokploy host itself.
+     */
+    declare public readonly serverId: pulumi.Output<string | undefined>;
+    /**
+     * Role this node plays in a libSQL cluster. Valid values: `primary`, `replica`. Defaults to `primary`.
+     */
+    declare public readonly sqldNode: pulumi.Output<string>;
+    /**
+     * URL of the primary node, when `sqldNode` is `replica`.
+     */
+    declare public readonly sqldPrimaryUrl: pulumi.Output<string | undefined>;
+    /**
+     * Grace period in nanoseconds before a container is killed.
+     */
+    declare public readonly stopGracePeriodSwarm: pulumi.Output<number | undefined>;
+    /**
+     * Docker Swarm rolling update configuration, as a JSON object.
+     */
+    declare public readonly updateConfigSwarm: pulumi.Output<string | undefined>;
+
+    /**
+     * Create a Libsql resource with the given unique name, arguments, and options.
+     *
+     * @param name The _unique_ name of the resource.
+     * @param args The arguments to use to populate this resource's properties.
+     * @param opts A bag of options that control this resource's behavior.
+     */
+    constructor(name: string, args: LibsqlArgs, opts?: pulumi.CustomResourceOptions)
+    constructor(name: string, argsOrState?: LibsqlArgs | LibsqlState, opts?: pulumi.CustomResourceOptions) {
+        let resourceInputs: pulumi.Inputs = {};
+        opts = opts || {};
+        if (opts.id) {
+            const state = argsOrState as LibsqlState | undefined;
+            resourceInputs["appName"] = state?.appName;
+            resourceInputs["applicationStatus"] = state?.applicationStatus;
+            resourceInputs["command"] = state?.command;
+            resourceInputs["cpuLimit"] = state?.cpuLimit;
+            resourceInputs["cpuReservation"] = state?.cpuReservation;
+            resourceInputs["createdAt"] = state?.createdAt;
+            resourceInputs["databasePassword"] = state?.databasePassword;
+            resourceInputs["databaseUser"] = state?.databaseUser;
+            resourceInputs["description"] = state?.description;
+            resourceInputs["detachDokployNetwork"] = state?.detachDokployNetwork;
+            resourceInputs["dockerImage"] = state?.dockerImage;
+            resourceInputs["enableNamespaces"] = state?.enableNamespaces;
+            resourceInputs["endpointSpecSwarm"] = state?.endpointSpecSwarm;
+            resourceInputs["env"] = state?.env;
+            resourceInputs["environmentId"] = state?.environmentId;
+            resourceInputs["externalAdminPort"] = state?.externalAdminPort;
+            resourceInputs["externalGrpcPort"] = state?.externalGrpcPort;
+            resourceInputs["externalPort"] = state?.externalPort;
+            resourceInputs["healthCheckSwarm"] = state?.healthCheckSwarm;
+            resourceInputs["labelsSwarm"] = state?.labelsSwarm;
+            resourceInputs["memoryLimit"] = state?.memoryLimit;
+            resourceInputs["memoryReservation"] = state?.memoryReservation;
+            resourceInputs["modeSwarm"] = state?.modeSwarm;
+            resourceInputs["name"] = state?.name;
+            resourceInputs["networkIds"] = state?.networkIds;
+            resourceInputs["networkSwarm"] = state?.networkSwarm;
+            resourceInputs["placementSwarm"] = state?.placementSwarm;
+            resourceInputs["replicas"] = state?.replicas;
+            resourceInputs["restartPolicySwarm"] = state?.restartPolicySwarm;
+            resourceInputs["rollbackConfigSwarm"] = state?.rollbackConfigSwarm;
+            resourceInputs["serverId"] = state?.serverId;
+            resourceInputs["sqldNode"] = state?.sqldNode;
+            resourceInputs["sqldPrimaryUrl"] = state?.sqldPrimaryUrl;
+            resourceInputs["stopGracePeriodSwarm"] = state?.stopGracePeriodSwarm;
+            resourceInputs["updateConfigSwarm"] = state?.updateConfigSwarm;
+        } else {
+            const args = argsOrState as LibsqlArgs | undefined;
+            if (args?.databasePassword === undefined && !opts.urn) {
+                throw new Error("Missing required property 'databasePassword'");
+            }
+            if (args?.databaseUser === undefined && !opts.urn) {
+                throw new Error("Missing required property 'databaseUser'");
+            }
+            if (args?.dockerImage === undefined && !opts.urn) {
+                throw new Error("Missing required property 'dockerImage'");
+            }
+            if (args?.environmentId === undefined && !opts.urn) {
+                throw new Error("Missing required property 'environmentId'");
+            }
+            resourceInputs["appName"] = args?.appName;
+            resourceInputs["command"] = args?.command;
+            resourceInputs["cpuLimit"] = args?.cpuLimit;
+            resourceInputs["cpuReservation"] = args?.cpuReservation;
+            resourceInputs["databasePassword"] = args?.databasePassword ? pulumi.secret(args.databasePassword) : undefined;
+            resourceInputs["databaseUser"] = args?.databaseUser;
+            resourceInputs["description"] = args?.description;
+            resourceInputs["detachDokployNetwork"] = args?.detachDokployNetwork;
+            resourceInputs["dockerImage"] = args?.dockerImage;
+            resourceInputs["enableNamespaces"] = args?.enableNamespaces;
+            resourceInputs["endpointSpecSwarm"] = args?.endpointSpecSwarm;
+            resourceInputs["env"] = args?.env;
+            resourceInputs["environmentId"] = args?.environmentId;
+            resourceInputs["externalAdminPort"] = args?.externalAdminPort;
+            resourceInputs["externalGrpcPort"] = args?.externalGrpcPort;
+            resourceInputs["externalPort"] = args?.externalPort;
+            resourceInputs["healthCheckSwarm"] = args?.healthCheckSwarm;
+            resourceInputs["labelsSwarm"] = args?.labelsSwarm;
+            resourceInputs["memoryLimit"] = args?.memoryLimit;
+            resourceInputs["memoryReservation"] = args?.memoryReservation;
+            resourceInputs["modeSwarm"] = args?.modeSwarm;
+            resourceInputs["name"] = args?.name;
+            resourceInputs["networkIds"] = args?.networkIds;
+            resourceInputs["networkSwarm"] = args?.networkSwarm;
+            resourceInputs["placementSwarm"] = args?.placementSwarm;
+            resourceInputs["replicas"] = args?.replicas;
+            resourceInputs["restartPolicySwarm"] = args?.restartPolicySwarm;
+            resourceInputs["rollbackConfigSwarm"] = args?.rollbackConfigSwarm;
+            resourceInputs["serverId"] = args?.serverId;
+            resourceInputs["sqldNode"] = args?.sqldNode;
+            resourceInputs["sqldPrimaryUrl"] = args?.sqldPrimaryUrl;
+            resourceInputs["stopGracePeriodSwarm"] = args?.stopGracePeriodSwarm;
+            resourceInputs["updateConfigSwarm"] = args?.updateConfigSwarm;
+            resourceInputs["applicationStatus"] = undefined /*out*/;
+            resourceInputs["createdAt"] = undefined /*out*/;
+        }
+        opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts);
+        const secretOpts = { additionalSecretOutputs: ["databasePassword"] };
+        opts = pulumi.mergeOptions(opts, secretOpts);
+        super(Libsql.__pulumiType, name, resourceInputs, opts);
+    }
+}
+
+/**
+ * Input properties used for looking up and filtering Libsql resources.
+ */
+export interface LibsqlState {
+    /**
+     * Unique Docker service name. Generated from `name` when omitted, because Dokploy's libSQL endpoint does not generate one. Changing it forces a new database.
+     */
+    appName?: pulumi.Input<string | undefined>;
+    /**
+     * Current status reported by Dokploy: `idle`, `running`, `done` or `error`.
+     */
+    applicationStatus?: pulumi.Input<string | undefined>;
+    /**
+     * Override the container entrypoint command.
+     */
+    command?: pulumi.Input<string | undefined>;
+    /**
+     * Hard CPU limit, for example `1`.
+     */
+    cpuLimit?: pulumi.Input<string | undefined>;
+    /**
+     * Soft CPU reservation, for example `0.5`.
+     */
+    cpuReservation?: pulumi.Input<string | undefined>;
+    /**
+     * RFC 3339 timestamp of when the database was created.
+     */
+    createdAt?: pulumi.Input<string | undefined>;
+    /**
+     * Password for the database user.
+     */
+    databasePassword?: pulumi.Input<string | undefined>;
+    /**
+     * Database user to create.
+     */
+    databaseUser?: pulumi.Input<string | undefined>;
+    /**
+     * Free-form description.
+     */
+    description?: pulumi.Input<string | undefined>;
+    /**
+     * Detach the service from the shared `dokploy-network`.
+     */
+    detachDokployNetwork?: pulumi.Input<boolean | undefined>;
+    /**
+     * libSQL server image to run, for example `ghcr.io/tursodatabase/libsql-server:latest`.
+     */
+    dockerImage?: pulumi.Input<string | undefined>;
+    /**
+     * Serve multiple logical databases from one instance through libSQL namespaces.
+     */
+    enableNamespaces?: pulumi.Input<boolean | undefined>;
+    /**
+     * Docker Swarm endpoint specification, as a JSON object.
+     */
+    endpointSpecSwarm?: pulumi.Input<string | undefined>;
+    /**
+     * Environment variables in `KEY=value` format, one per line.
+     */
+    env?: pulumi.Input<string | undefined>;
+    /**
+     * Environment this database belongs to.
+     */
+    environmentId?: pulumi.Input<string | undefined>;
+    /**
+     * Host port exposing the admin API.
+     */
+    externalAdminPort?: pulumi.Input<number | undefined>;
+    /**
+     * Host port exposing the gRPC replication endpoint.
+     */
+    externalGrpcPort?: pulumi.Input<number | undefined>;
+    /**
+     * Host port exposing the HTTP API.
+     */
+    externalPort?: pulumi.Input<number | undefined>;
+    /**
+     * Docker Swarm health check configuration, as a JSON object.
+     */
+    healthCheckSwarm?: pulumi.Input<string | undefined>;
+    /**
+     * Docker Swarm service labels, as a JSON object.
+     */
+    labelsSwarm?: pulumi.Input<string | undefined>;
+    /**
+     * Hard memory limit, for example `512m`.
+     */
+    memoryLimit?: pulumi.Input<string | undefined>;
+    /**
+     * Soft memory reservation, for example `256m`.
+     */
+    memoryReservation?: pulumi.Input<string | undefined>;
+    /**
+     * Docker Swarm service mode, as a JSON object.
+     */
+    modeSwarm?: pulumi.Input<string | undefined>;
+    /**
+     * Display name of the database.
+     */
+    name?: pulumi.Input<string | undefined>;
+    /**
+     * IDs of additional Docker networks to attach.
+     */
+    networkIds?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+    /**
+     * Docker Swarm network attachments, as a JSON array.
+     */
+    networkSwarm?: pulumi.Input<string | undefined>;
+    /**
+     * Docker Swarm placement constraints, as a JSON object.
+     */
+    placementSwarm?: pulumi.Input<string | undefined>;
+    /**
+     * Number of replicas to run.
+     */
+    replicas?: pulumi.Input<number | undefined>;
+    /**
+     * Docker Swarm restart policy, as a JSON object.
+     */
+    restartPolicySwarm?: pulumi.Input<string | undefined>;
+    /**
+     * Docker Swarm rollback configuration, as a JSON object.
+     */
+    rollbackConfigSwarm?: pulumi.Input<string | undefined>;
+    /**
+     * Remote server to deploy on. Omit to use the Dokploy host itself.
+     */
+    serverId?: pulumi.Input<string | undefined>;
+    /**
+     * Role this node plays in a libSQL cluster. Valid values: `primary`, `replica`. Defaults to `primary`.
+     */
+    sqldNode?: pulumi.Input<string | undefined>;
+    /**
+     * URL of the primary node, when `sqldNode` is `replica`.
+     */
+    sqldPrimaryUrl?: pulumi.Input<string | undefined>;
+    /**
+     * Grace period in nanoseconds before a container is killed.
+     */
+    stopGracePeriodSwarm?: pulumi.Input<number | undefined>;
+    /**
+     * Docker Swarm rolling update configuration, as a JSON object.
+     */
+    updateConfigSwarm?: pulumi.Input<string | undefined>;
+}
+
+/**
+ * The set of arguments for constructing a Libsql resource.
+ */
+export interface LibsqlArgs {
+    /**
+     * Unique Docker service name. Generated from `name` when omitted, because Dokploy's libSQL endpoint does not generate one. Changing it forces a new database.
+     */
+    appName?: pulumi.Input<string | undefined>;
+    /**
+     * Override the container entrypoint command.
+     */
+    command?: pulumi.Input<string | undefined>;
+    /**
+     * Hard CPU limit, for example `1`.
+     */
+    cpuLimit?: pulumi.Input<string | undefined>;
+    /**
+     * Soft CPU reservation, for example `0.5`.
+     */
+    cpuReservation?: pulumi.Input<string | undefined>;
+    /**
+     * Password for the database user.
+     */
+    databasePassword: pulumi.Input<string>;
+    /**
+     * Database user to create.
+     */
+    databaseUser: pulumi.Input<string>;
+    /**
+     * Free-form description.
+     */
+    description?: pulumi.Input<string | undefined>;
+    /**
+     * Detach the service from the shared `dokploy-network`.
+     */
+    detachDokployNetwork?: pulumi.Input<boolean | undefined>;
+    /**
+     * libSQL server image to run, for example `ghcr.io/tursodatabase/libsql-server:latest`.
+     */
+    dockerImage: pulumi.Input<string>;
+    /**
+     * Serve multiple logical databases from one instance through libSQL namespaces.
+     */
+    enableNamespaces?: pulumi.Input<boolean | undefined>;
+    /**
+     * Docker Swarm endpoint specification, as a JSON object.
+     */
+    endpointSpecSwarm?: pulumi.Input<string | undefined>;
+    /**
+     * Environment variables in `KEY=value` format, one per line.
+     */
+    env?: pulumi.Input<string | undefined>;
+    /**
+     * Environment this database belongs to.
+     */
+    environmentId: pulumi.Input<string>;
+    /**
+     * Host port exposing the admin API.
+     */
+    externalAdminPort?: pulumi.Input<number | undefined>;
+    /**
+     * Host port exposing the gRPC replication endpoint.
+     */
+    externalGrpcPort?: pulumi.Input<number | undefined>;
+    /**
+     * Host port exposing the HTTP API.
+     */
+    externalPort?: pulumi.Input<number | undefined>;
+    /**
+     * Docker Swarm health check configuration, as a JSON object.
+     */
+    healthCheckSwarm?: pulumi.Input<string | undefined>;
+    /**
+     * Docker Swarm service labels, as a JSON object.
+     */
+    labelsSwarm?: pulumi.Input<string | undefined>;
+    /**
+     * Hard memory limit, for example `512m`.
+     */
+    memoryLimit?: pulumi.Input<string | undefined>;
+    /**
+     * Soft memory reservation, for example `256m`.
+     */
+    memoryReservation?: pulumi.Input<string | undefined>;
+    /**
+     * Docker Swarm service mode, as a JSON object.
+     */
+    modeSwarm?: pulumi.Input<string | undefined>;
+    /**
+     * Display name of the database.
+     */
+    name?: pulumi.Input<string | undefined>;
+    /**
+     * IDs of additional Docker networks to attach.
+     */
+    networkIds?: pulumi.Input<pulumi.Input<string>[] | undefined>;
+    /**
+     * Docker Swarm network attachments, as a JSON array.
+     */
+    networkSwarm?: pulumi.Input<string | undefined>;
+    /**
+     * Docker Swarm placement constraints, as a JSON object.
+     */
+    placementSwarm?: pulumi.Input<string | undefined>;
+    /**
+     * Number of replicas to run.
+     */
+    replicas?: pulumi.Input<number | undefined>;
+    /**
+     * Docker Swarm restart policy, as a JSON object.
+     */
+    restartPolicySwarm?: pulumi.Input<string | undefined>;
+    /**
+     * Docker Swarm rollback configuration, as a JSON object.
+     */
+    rollbackConfigSwarm?: pulumi.Input<string | undefined>;
+    /**
+     * Remote server to deploy on. Omit to use the Dokploy host itself.
+     */
+    serverId?: pulumi.Input<string | undefined>;
+    /**
+     * Role this node plays in a libSQL cluster. Valid values: `primary`, `replica`. Defaults to `primary`.
+     */
+    sqldNode?: pulumi.Input<string | undefined>;
+    /**
+     * URL of the primary node, when `sqldNode` is `replica`.
+     */
+    sqldPrimaryUrl?: pulumi.Input<string | undefined>;
+    /**
+     * Grace period in nanoseconds before a container is killed.
+     */
+    stopGracePeriodSwarm?: pulumi.Input<number | undefined>;
+    /**
+     * Docker Swarm rolling update configuration, as a JSON object.
+     */
+    updateConfigSwarm?: pulumi.Input<string | undefined>;
+}

sdk/nodejs/mariaDb.ts

@@ -4,6 +4,13 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * A managed MariaDB instance running on Dokploy.
+ *
+ * > Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+ *
+ * > Credentials are stored in Terraform state. Use a state backend with encryption at rest.
+ */
 export class MariaDb extends pulumi.CustomResource {
     /**
      * Get an existing MariaDb resource's state with the given name, ID, and optional extra
@@ -285,139 +292,139 @@ export interface MariaDbState {
     /**
      * Unique Docker service name. Generated by Dokploy when omitted. Changing it forces a new database.
      */
-    appName?: pulumi.Input<string>;
+    appName?: pulumi.Input<string | undefined>;
     /**
      * Current status reported by Dokploy: `idle`, `running`, `done` or `error`.
      */
-    applicationStatus?: pulumi.Input<string>;
+    applicationStatus?: pulumi.Input<string | undefined>;
     /**
      * Arguments appended to the container command.
      */
-    args?: pulumi.Input<pulumi.Input<string>[]>;
+    args?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Override the container entrypoint command.
      */
-    command?: pulumi.Input<string>;
+    command?: pulumi.Input<string | undefined>;
     /**
      * Hard CPU limit, for example `1`.
      */
-    cpuLimit?: pulumi.Input<string>;
+    cpuLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft CPU reservation, for example `0.5`.
      */
-    cpuReservation?: pulumi.Input<string>;
+    cpuReservation?: pulumi.Input<string | undefined>;
     /**
      * RFC 3339 timestamp of when the database was created.
      */
-    createdAt?: pulumi.Input<string>;
+    createdAt?: pulumi.Input<string | undefined>;
     /**
      * Name of the database to create.
      */
-    databaseName?: pulumi.Input<string>;
+    databaseName?: pulumi.Input<string | undefined>;
     /**
      * Password for the database user.
      */
-    databasePassword?: pulumi.Input<string>;
+    databasePassword?: pulumi.Input<string | undefined>;
     /**
      * Password for the MariaDB `root` user.
      */
-    databaseRootPassword?: pulumi.Input<string>;
+    databaseRootPassword?: pulumi.Input<string | undefined>;
     /**
      * Database user to create.
      */
-    databaseUser?: pulumi.Input<string>;
+    databaseUser?: pulumi.Input<string | undefined>;
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * Detach the service from the shared `dokploy-network`.
      */
-    detachDokployNetwork?: pulumi.Input<boolean>;
+    detachDokployNetwork?: pulumi.Input<boolean | undefined>;
     /**
      * MariaDB image to run, for example `mariadb:11`.
      */
-    dockerImage?: pulumi.Input<string>;
+    dockerImage?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm endpoint specification, as a JSON object.
      */
-    endpointSpecSwarm?: pulumi.Input<string>;
+    endpointSpecSwarm?: pulumi.Input<string | undefined>;
     /**
      * Environment variables in `KEY=value` format, one per line.
      */
-    env?: pulumi.Input<string>;
+    env?: pulumi.Input<string | undefined>;
     /**
      * Environment this database belongs to.
      */
-    environmentId?: pulumi.Input<string>;
+    environmentId?: pulumi.Input<string | undefined>;
     /**
      * Host port to expose the database on. Leave unset to keep the database reachable only from inside the Docker network.
      */
-    externalPort?: pulumi.Input<number>;
+    externalPort?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm health check configuration, as a JSON object.
      */
-    healthCheckSwarm?: pulumi.Input<string>;
+    healthCheckSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service labels, as a JSON object.
      */
-    labelsSwarm?: pulumi.Input<string>;
+    labelsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Hard memory limit, for example `512m`.
      */
-    memoryLimit?: pulumi.Input<string>;
+    memoryLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft memory reservation, for example `256m`.
      */
-    memoryReservation?: pulumi.Input<string>;
+    memoryReservation?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service mode, as a JSON object.
      */
-    modeSwarm?: pulumi.Input<string>;
+    modeSwarm?: pulumi.Input<string | undefined>;
     /**
      * Display name of the database.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * IDs of additional Docker networks to attach.
      */
-    networkIds?: pulumi.Input<pulumi.Input<string>[]>;
+    networkIds?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Docker Swarm network attachments, as a JSON array.
      */
-    networkSwarm?: pulumi.Input<string>;
+    networkSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm placement constraints, as a JSON object.
      */
-    placementSwarm?: pulumi.Input<string>;
+    placementSwarm?: pulumi.Input<string | undefined>;
     /**
      * Number of replicas to run.
      */
-    replicas?: pulumi.Input<number>;
+    replicas?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm restart policy, as a JSON object.
      */
-    restartPolicySwarm?: pulumi.Input<string>;
+    restartPolicySwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rollback configuration, as a JSON object.
      */
-    rollbackConfigSwarm?: pulumi.Input<string>;
+    rollbackConfigSwarm?: pulumi.Input<string | undefined>;
     /**
      * Remote server to deploy on. Omit to use the Dokploy host itself.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
     /**
      * Grace period in nanoseconds before a container is killed.
      */
-    stopGracePeriodSwarm?: pulumi.Input<number>;
+    stopGracePeriodSwarm?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm ulimits, as a JSON object.
      */
-    ulimitsSwarm?: pulumi.Input<string>;
+    ulimitsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rolling update configuration, as a JSON object.
      */
-    updateConfigSwarm?: pulumi.Input<string>;
+    updateConfigSwarm?: pulumi.Input<string | undefined>;
 }
 
 /**
@@ -427,23 +434,23 @@ export interface MariaDbArgs {
     /**
      * Unique Docker service name. Generated by Dokploy when omitted. Changing it forces a new database.
      */
-    appName?: pulumi.Input<string>;
+    appName?: pulumi.Input<string | undefined>;
     /**
      * Arguments appended to the container command.
      */
-    args?: pulumi.Input<pulumi.Input<string>[]>;
+    args?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Override the container entrypoint command.
      */
-    command?: pulumi.Input<string>;
+    command?: pulumi.Input<string | undefined>;
     /**
      * Hard CPU limit, for example `1`.
      */
-    cpuLimit?: pulumi.Input<string>;
+    cpuLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft CPU reservation, for example `0.5`.
      */
-    cpuReservation?: pulumi.Input<string>;
+    cpuReservation?: pulumi.Input<string | undefined>;
     /**
      * Name of the database to create.
      */
@@ -463,11 +470,11 @@ export interface MariaDbArgs {
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * Detach the service from the shared `dokploy-network`.
      */
-    detachDokployNetwork?: pulumi.Input<boolean>;
+    detachDokployNetwork?: pulumi.Input<boolean | undefined>;
     /**
      * MariaDB image to run, for example `mariadb:11`.
      */
@@ -475,11 +482,11 @@ export interface MariaDbArgs {
     /**
      * Docker Swarm endpoint specification, as a JSON object.
      */
-    endpointSpecSwarm?: pulumi.Input<string>;
+    endpointSpecSwarm?: pulumi.Input<string | undefined>;
     /**
      * Environment variables in `KEY=value` format, one per line.
      */
-    env?: pulumi.Input<string>;
+    env?: pulumi.Input<string | undefined>;
     /**
      * Environment this database belongs to.
      */
@@ -487,69 +494,69 @@ export interface MariaDbArgs {
     /**
      * Host port to expose the database on. Leave unset to keep the database reachable only from inside the Docker network.
      */
-    externalPort?: pulumi.Input<number>;
+    externalPort?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm health check configuration, as a JSON object.
      */
-    healthCheckSwarm?: pulumi.Input<string>;
+    healthCheckSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service labels, as a JSON object.
      */
-    labelsSwarm?: pulumi.Input<string>;
+    labelsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Hard memory limit, for example `512m`.
      */
-    memoryLimit?: pulumi.Input<string>;
+    memoryLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft memory reservation, for example `256m`.
      */
-    memoryReservation?: pulumi.Input<string>;
+    memoryReservation?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service mode, as a JSON object.
      */
-    modeSwarm?: pulumi.Input<string>;
+    modeSwarm?: pulumi.Input<string | undefined>;
     /**
      * Display name of the database.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * IDs of additional Docker networks to attach.
      */
-    networkIds?: pulumi.Input<pulumi.Input<string>[]>;
+    networkIds?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Docker Swarm network attachments, as a JSON array.
      */
-    networkSwarm?: pulumi.Input<string>;
+    networkSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm placement constraints, as a JSON object.
      */
-    placementSwarm?: pulumi.Input<string>;
+    placementSwarm?: pulumi.Input<string | undefined>;
     /**
      * Number of replicas to run.
      */
-    replicas?: pulumi.Input<number>;
+    replicas?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm restart policy, as a JSON object.
      */
-    restartPolicySwarm?: pulumi.Input<string>;
+    restartPolicySwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rollback configuration, as a JSON object.
      */
-    rollbackConfigSwarm?: pulumi.Input<string>;
+    rollbackConfigSwarm?: pulumi.Input<string | undefined>;
     /**
      * Remote server to deploy on. Omit to use the Dokploy host itself.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
     /**
      * Grace period in nanoseconds before a container is killed.
      */
-    stopGracePeriodSwarm?: pulumi.Input<number>;
+    stopGracePeriodSwarm?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm ulimits, as a JSON object.
      */
-    ulimitsSwarm?: pulumi.Input<string>;
+    ulimitsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rolling update configuration, as a JSON object.
      */
-    updateConfigSwarm?: pulumi.Input<string>;
+    updateConfigSwarm?: pulumi.Input<string | undefined>;
 }

sdk/nodejs/mongo.ts

@@ -4,6 +4,13 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * A managed MongoDB instance running on Dokploy.
+ *
+ * > Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+ *
+ * > Credentials are stored in Terraform state. Use a state backend with encryption at rest.
+ */
 export class Mongo extends pulumi.CustomResource {
     /**
      * Get an existing Mongo resource's state with the given name, ID, and optional extra
@@ -270,135 +277,135 @@ export interface MongoState {
     /**
      * Unique Docker service name. Generated by Dokploy when omitted. Changing it forces a new database.
      */
-    appName?: pulumi.Input<string>;
+    appName?: pulumi.Input<string | undefined>;
     /**
      * Current status reported by Dokploy: `idle`, `running`, `done` or `error`.
      */
-    applicationStatus?: pulumi.Input<string>;
+    applicationStatus?: pulumi.Input<string | undefined>;
     /**
      * Arguments appended to the container command.
      */
-    args?: pulumi.Input<pulumi.Input<string>[]>;
+    args?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Override the container entrypoint command.
      */
-    command?: pulumi.Input<string>;
+    command?: pulumi.Input<string | undefined>;
     /**
      * Hard CPU limit, for example `1`.
      */
-    cpuLimit?: pulumi.Input<string>;
+    cpuLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft CPU reservation, for example `0.5`.
      */
-    cpuReservation?: pulumi.Input<string>;
+    cpuReservation?: pulumi.Input<string | undefined>;
     /**
      * RFC 3339 timestamp of when the database was created.
      */
-    createdAt?: pulumi.Input<string>;
+    createdAt?: pulumi.Input<string | undefined>;
     /**
      * Password for the root user.
      */
-    databasePassword?: pulumi.Input<string>;
+    databasePassword?: pulumi.Input<string | undefined>;
     /**
      * Root username to create.
      */
-    databaseUser?: pulumi.Input<string>;
+    databaseUser?: pulumi.Input<string | undefined>;
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * Detach the service from the shared `dokploy-network`.
      */
-    detachDokployNetwork?: pulumi.Input<boolean>;
+    detachDokployNetwork?: pulumi.Input<boolean | undefined>;
     /**
      * MongoDB image to run. Defaults to `mongo:8`.
      */
-    dockerImage?: pulumi.Input<string>;
+    dockerImage?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm endpoint specification, as a JSON object.
      */
-    endpointSpecSwarm?: pulumi.Input<string>;
+    endpointSpecSwarm?: pulumi.Input<string | undefined>;
     /**
      * Environment variables in `KEY=value` format, one per line.
      */
-    env?: pulumi.Input<string>;
+    env?: pulumi.Input<string | undefined>;
     /**
      * Environment this database belongs to.
      */
-    environmentId?: pulumi.Input<string>;
+    environmentId?: pulumi.Input<string | undefined>;
     /**
      * Host port to expose the database on. Leave unset to keep the database reachable only from inside the Docker network.
      */
-    externalPort?: pulumi.Input<number>;
+    externalPort?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm health check configuration, as a JSON object.
      */
-    healthCheckSwarm?: pulumi.Input<string>;
+    healthCheckSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service labels, as a JSON object.
      */
-    labelsSwarm?: pulumi.Input<string>;
+    labelsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Hard memory limit, for example `512m`.
      */
-    memoryLimit?: pulumi.Input<string>;
+    memoryLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft memory reservation, for example `256m`.
      */
-    memoryReservation?: pulumi.Input<string>;
+    memoryReservation?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service mode, as a JSON object.
      */
-    modeSwarm?: pulumi.Input<string>;
+    modeSwarm?: pulumi.Input<string | undefined>;
     /**
      * Display name of the database.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * IDs of additional Docker networks to attach.
      */
-    networkIds?: pulumi.Input<pulumi.Input<string>[]>;
+    networkIds?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Docker Swarm network attachments, as a JSON array.
      */
-    networkSwarm?: pulumi.Input<string>;
+    networkSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm placement constraints, as a JSON object.
      */
-    placementSwarm?: pulumi.Input<string>;
+    placementSwarm?: pulumi.Input<string | undefined>;
     /**
      * Start the instance as a single-node replica set.
      */
-    replicaSets?: pulumi.Input<boolean>;
+    replicaSets?: pulumi.Input<boolean | undefined>;
     /**
      * Number of replicas to run.
      */
-    replicas?: pulumi.Input<number>;
+    replicas?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm restart policy, as a JSON object.
      */
-    restartPolicySwarm?: pulumi.Input<string>;
+    restartPolicySwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rollback configuration, as a JSON object.
      */
-    rollbackConfigSwarm?: pulumi.Input<string>;
+    rollbackConfigSwarm?: pulumi.Input<string | undefined>;
     /**
      * Remote server to deploy on. Omit to use the Dokploy host itself.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
     /**
      * Grace period in nanoseconds before a container is killed.
      */
-    stopGracePeriodSwarm?: pulumi.Input<number>;
+    stopGracePeriodSwarm?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm ulimits, as a JSON object.
      */
-    ulimitsSwarm?: pulumi.Input<string>;
+    ulimitsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rolling update configuration, as a JSON object.
      */
-    updateConfigSwarm?: pulumi.Input<string>;
+    updateConfigSwarm?: pulumi.Input<string | undefined>;
 }
 
 /**
@@ -408,23 +415,23 @@ export interface MongoArgs {
     /**
      * Unique Docker service name. Generated by Dokploy when omitted. Changing it forces a new database.
      */
-    appName?: pulumi.Input<string>;
+    appName?: pulumi.Input<string | undefined>;
     /**
      * Arguments appended to the container command.
      */
-    args?: pulumi.Input<pulumi.Input<string>[]>;
+    args?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Override the container entrypoint command.
      */
-    command?: pulumi.Input<string>;
+    command?: pulumi.Input<string | undefined>;
     /**
      * Hard CPU limit, for example `1`.
      */
-    cpuLimit?: pulumi.Input<string>;
+    cpuLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft CPU reservation, for example `0.5`.
      */
-    cpuReservation?: pulumi.Input<string>;
+    cpuReservation?: pulumi.Input<string | undefined>;
     /**
      * Password for the root user.
      */
@@ -436,23 +443,23 @@ export interface MongoArgs {
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * Detach the service from the shared `dokploy-network`.
      */
-    detachDokployNetwork?: pulumi.Input<boolean>;
+    detachDokployNetwork?: pulumi.Input<boolean | undefined>;
     /**
      * MongoDB image to run. Defaults to `mongo:8`.
      */
-    dockerImage?: pulumi.Input<string>;
+    dockerImage?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm endpoint specification, as a JSON object.
      */
-    endpointSpecSwarm?: pulumi.Input<string>;
+    endpointSpecSwarm?: pulumi.Input<string | undefined>;
     /**
      * Environment variables in `KEY=value` format, one per line.
      */
-    env?: pulumi.Input<string>;
+    env?: pulumi.Input<string | undefined>;
     /**
      * Environment this database belongs to.
      */
@@ -460,73 +467,73 @@ export interface MongoArgs {
     /**
      * Host port to expose the database on. Leave unset to keep the database reachable only from inside the Docker network.
      */
-    externalPort?: pulumi.Input<number>;
+    externalPort?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm health check configuration, as a JSON object.
      */
-    healthCheckSwarm?: pulumi.Input<string>;
+    healthCheckSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service labels, as a JSON object.
      */
-    labelsSwarm?: pulumi.Input<string>;
+    labelsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Hard memory limit, for example `512m`.
      */
-    memoryLimit?: pulumi.Input<string>;
+    memoryLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft memory reservation, for example `256m`.
      */
-    memoryReservation?: pulumi.Input<string>;
+    memoryReservation?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service mode, as a JSON object.
      */
-    modeSwarm?: pulumi.Input<string>;
+    modeSwarm?: pulumi.Input<string | undefined>;
     /**
      * Display name of the database.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * IDs of additional Docker networks to attach.
      */
-    networkIds?: pulumi.Input<pulumi.Input<string>[]>;
+    networkIds?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Docker Swarm network attachments, as a JSON array.
      */
-    networkSwarm?: pulumi.Input<string>;
+    networkSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm placement constraints, as a JSON object.
      */
-    placementSwarm?: pulumi.Input<string>;
+    placementSwarm?: pulumi.Input<string | undefined>;
     /**
      * Start the instance as a single-node replica set.
      */
-    replicaSets?: pulumi.Input<boolean>;
+    replicaSets?: pulumi.Input<boolean | undefined>;
     /**
      * Number of replicas to run.
      */
-    replicas?: pulumi.Input<number>;
+    replicas?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm restart policy, as a JSON object.
      */
-    restartPolicySwarm?: pulumi.Input<string>;
+    restartPolicySwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rollback configuration, as a JSON object.
      */
-    rollbackConfigSwarm?: pulumi.Input<string>;
+    rollbackConfigSwarm?: pulumi.Input<string | undefined>;
     /**
      * Remote server to deploy on. Omit to use the Dokploy host itself.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
     /**
      * Grace period in nanoseconds before a container is killed.
      */
-    stopGracePeriodSwarm?: pulumi.Input<number>;
+    stopGracePeriodSwarm?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm ulimits, as a JSON object.
      */
-    ulimitsSwarm?: pulumi.Input<string>;
+    ulimitsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rolling update configuration, as a JSON object.
      */
-    updateConfigSwarm?: pulumi.Input<string>;
+    updateConfigSwarm?: pulumi.Input<string | undefined>;
 }

sdk/nodejs/mount.ts

@@ -4,6 +4,15 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * A volume, bind mount, or config file attached to a Dokploy service.
+ *
+ * * `type = "volume"` — a named Docker volume; set `volumeName`.
+ * * `type = "bind"` — a path on the host; set `hostPath`.
+ * * `type = "file"` — a file rendered from `content`; set `filePath`.
+ *
+ * > **A `volume` mount must set `volumeName`.** Dokploy hands an unset name to Docker as an empty source, which creates a fresh anonymous volume on every deploy and orphans the previous one — the data never survives a redeploy. The provider rejects that combination at plan time.
+ */
 export class Mount extends pulumi.CustomResource {
     /**
      * Get an existing Mount resource's state with the given name, ID, and optional extra
@@ -53,7 +62,7 @@ export class Mount extends pulumi.CustomResource {
      */
     declare public readonly serviceId: pulumi.Output<string>;
     /**
-     * The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`.
+     * The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`, `libsql`.
      */
     declare public readonly serviceType: pulumi.Output<string>;
     /**
@@ -121,35 +130,35 @@ export interface MountState {
     /**
      * Contents of the generated file, when `type` is `file`.
      */
-    content?: pulumi.Input<string>;
+    content?: pulumi.Input<string | undefined>;
     /**
      * Path of the generated file, when `type` is `file`.
      */
-    filePath?: pulumi.Input<string>;
+    filePath?: pulumi.Input<string | undefined>;
     /**
      * Path on the host, when `type` is `bind`.
      */
-    hostPath?: pulumi.Input<string>;
+    hostPath?: pulumi.Input<string | undefined>;
     /**
      * Path inside the container where the mount appears.
      */
-    mountPath?: pulumi.Input<string>;
+    mountPath?: pulumi.Input<string | undefined>;
     /**
      * ID of the service this mount attaches to. Must match `serviceType` — an application ID, a compose ID, a postgres ID, and so on.
      */
-    serviceId?: pulumi.Input<string>;
+    serviceId?: pulumi.Input<string | undefined>;
     /**
-     * The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`.
+     * The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`, `libsql`.
      */
-    serviceType?: pulumi.Input<string>;
+    serviceType?: pulumi.Input<string | undefined>;
     /**
      * The kind of mount to create. Valid values: `bind`, `volume`, `file`.
      */
-    type?: pulumi.Input<string>;
+    type?: pulumi.Input<string | undefined>;
     /**
      * Name of the Docker volume, when `type` is `volume`.
      */
-    volumeName?: pulumi.Input<string>;
+    volumeName?: pulumi.Input<string | undefined>;
 }
 
 /**
@@ -159,15 +168,15 @@ export interface MountArgs {
     /**
      * Contents of the generated file, when `type` is `file`.
      */
-    content?: pulumi.Input<string>;
+    content?: pulumi.Input<string | undefined>;
     /**
      * Path of the generated file, when `type` is `file`.
      */
-    filePath?: pulumi.Input<string>;
+    filePath?: pulumi.Input<string | undefined>;
     /**
      * Path on the host, when `type` is `bind`.
      */
-    hostPath?: pulumi.Input<string>;
+    hostPath?: pulumi.Input<string | undefined>;
     /**
      * Path inside the container where the mount appears.
      */
@@ -177,7 +186,7 @@ export interface MountArgs {
      */
     serviceId: pulumi.Input<string>;
     /**
-     * The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`.
+     * The kind of service this mount attaches to. Valid values: `application`, `postgres`, `mysql`, `mariadb`, `mongo`, `redis`, `compose`, `libsql`.
      */
     serviceType: pulumi.Input<string>;
     /**
@@ -187,5 +196,5 @@ export interface MountArgs {
     /**
      * Name of the Docker volume, when `type` is `volume`.
      */
-    volumeName?: pulumi.Input<string>;
+    volumeName?: pulumi.Input<string | undefined>;
 }

sdk/nodejs/mySql.ts

@@ -4,6 +4,13 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * A managed MySQL instance running on Dokploy.
+ *
+ * > Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+ *
+ * > Credentials are stored in Terraform state. Use a state backend with encryption at rest.
+ */
 export class MySql extends pulumi.CustomResource {
     /**
      * Get an existing MySql resource's state with the given name, ID, and optional extra
@@ -285,139 +292,139 @@ export interface MySqlState {
     /**
      * Unique Docker service name. Generated by Dokploy when omitted. Changing it forces a new database.
      */
-    appName?: pulumi.Input<string>;
+    appName?: pulumi.Input<string | undefined>;
     /**
      * Current status reported by Dokploy: `idle`, `running`, `done` or `error`.
      */
-    applicationStatus?: pulumi.Input<string>;
+    applicationStatus?: pulumi.Input<string | undefined>;
     /**
      * Arguments appended to the container command.
      */
-    args?: pulumi.Input<pulumi.Input<string>[]>;
+    args?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Override the container entrypoint command.
      */
-    command?: pulumi.Input<string>;
+    command?: pulumi.Input<string | undefined>;
     /**
      * Hard CPU limit, for example `1`.
      */
-    cpuLimit?: pulumi.Input<string>;
+    cpuLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft CPU reservation, for example `0.5`.
      */
-    cpuReservation?: pulumi.Input<string>;
+    cpuReservation?: pulumi.Input<string | undefined>;
     /**
      * RFC 3339 timestamp of when the database was created.
      */
-    createdAt?: pulumi.Input<string>;
+    createdAt?: pulumi.Input<string | undefined>;
     /**
      * Name of the database to create.
      */
-    databaseName?: pulumi.Input<string>;
+    databaseName?: pulumi.Input<string | undefined>;
     /**
      * Password for the database user.
      */
-    databasePassword?: pulumi.Input<string>;
+    databasePassword?: pulumi.Input<string | undefined>;
     /**
      * Password for the MySQL `root` user.
      */
-    databaseRootPassword?: pulumi.Input<string>;
+    databaseRootPassword?: pulumi.Input<string | undefined>;
     /**
      * Database user to create.
      */
-    databaseUser?: pulumi.Input<string>;
+    databaseUser?: pulumi.Input<string | undefined>;
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * Detach the service from the shared `dokploy-network`.
      */
-    detachDokployNetwork?: pulumi.Input<boolean>;
+    detachDokployNetwork?: pulumi.Input<boolean | undefined>;
     /**
      * MySQL image to run, for example `mysql:8`.
      */
-    dockerImage?: pulumi.Input<string>;
+    dockerImage?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm endpoint specification, as a JSON object.
      */
-    endpointSpecSwarm?: pulumi.Input<string>;
+    endpointSpecSwarm?: pulumi.Input<string | undefined>;
     /**
      * Environment variables in `KEY=value` format, one per line.
      */
-    env?: pulumi.Input<string>;
+    env?: pulumi.Input<string | undefined>;
     /**
      * Environment this database belongs to.
      */
-    environmentId?: pulumi.Input<string>;
+    environmentId?: pulumi.Input<string | undefined>;
     /**
      * Host port to expose the database on. Leave unset to keep the database reachable only from inside the Docker network.
      */
-    externalPort?: pulumi.Input<number>;
+    externalPort?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm health check configuration, as a JSON object.
      */
-    healthCheckSwarm?: pulumi.Input<string>;
+    healthCheckSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service labels, as a JSON object.
      */
-    labelsSwarm?: pulumi.Input<string>;
+    labelsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Hard memory limit, for example `512m`.
      */
-    memoryLimit?: pulumi.Input<string>;
+    memoryLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft memory reservation, for example `256m`.
      */
-    memoryReservation?: pulumi.Input<string>;
+    memoryReservation?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service mode, as a JSON object.
      */
-    modeSwarm?: pulumi.Input<string>;
+    modeSwarm?: pulumi.Input<string | undefined>;
     /**
      * Display name of the database.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * IDs of additional Docker networks to attach.
      */
-    networkIds?: pulumi.Input<pulumi.Input<string>[]>;
+    networkIds?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Docker Swarm network attachments, as a JSON array.
      */
-    networkSwarm?: pulumi.Input<string>;
+    networkSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm placement constraints, as a JSON object.
      */
-    placementSwarm?: pulumi.Input<string>;
+    placementSwarm?: pulumi.Input<string | undefined>;
     /**
      * Number of replicas to run.
      */
-    replicas?: pulumi.Input<number>;
+    replicas?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm restart policy, as a JSON object.
      */
-    restartPolicySwarm?: pulumi.Input<string>;
+    restartPolicySwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rollback configuration, as a JSON object.
      */
-    rollbackConfigSwarm?: pulumi.Input<string>;
+    rollbackConfigSwarm?: pulumi.Input<string | undefined>;
     /**
      * Remote server to deploy on. Omit to use the Dokploy host itself.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
     /**
      * Grace period in nanoseconds before a container is killed.
      */
-    stopGracePeriodSwarm?: pulumi.Input<number>;
+    stopGracePeriodSwarm?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm ulimits, as a JSON object.
      */
-    ulimitsSwarm?: pulumi.Input<string>;
+    ulimitsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rolling update configuration, as a JSON object.
      */
-    updateConfigSwarm?: pulumi.Input<string>;
+    updateConfigSwarm?: pulumi.Input<string | undefined>;
 }
 
 /**
@@ -427,23 +434,23 @@ export interface MySqlArgs {
     /**
      * Unique Docker service name. Generated by Dokploy when omitted. Changing it forces a new database.
      */
-    appName?: pulumi.Input<string>;
+    appName?: pulumi.Input<string | undefined>;
     /**
      * Arguments appended to the container command.
      */
-    args?: pulumi.Input<pulumi.Input<string>[]>;
+    args?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Override the container entrypoint command.
      */
-    command?: pulumi.Input<string>;
+    command?: pulumi.Input<string | undefined>;
     /**
      * Hard CPU limit, for example `1`.
      */
-    cpuLimit?: pulumi.Input<string>;
+    cpuLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft CPU reservation, for example `0.5`.
      */
-    cpuReservation?: pulumi.Input<string>;
+    cpuReservation?: pulumi.Input<string | undefined>;
     /**
      * Name of the database to create.
      */
@@ -463,11 +470,11 @@ export interface MySqlArgs {
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * Detach the service from the shared `dokploy-network`.
      */
-    detachDokployNetwork?: pulumi.Input<boolean>;
+    detachDokployNetwork?: pulumi.Input<boolean | undefined>;
     /**
      * MySQL image to run, for example `mysql:8`.
      */
@@ -475,11 +482,11 @@ export interface MySqlArgs {
     /**
      * Docker Swarm endpoint specification, as a JSON object.
      */
-    endpointSpecSwarm?: pulumi.Input<string>;
+    endpointSpecSwarm?: pulumi.Input<string | undefined>;
     /**
      * Environment variables in `KEY=value` format, one per line.
      */
-    env?: pulumi.Input<string>;
+    env?: pulumi.Input<string | undefined>;
     /**
      * Environment this database belongs to.
      */
@@ -487,69 +494,69 @@ export interface MySqlArgs {
     /**
      * Host port to expose the database on. Leave unset to keep the database reachable only from inside the Docker network.
      */
-    externalPort?: pulumi.Input<number>;
+    externalPort?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm health check configuration, as a JSON object.
      */
-    healthCheckSwarm?: pulumi.Input<string>;
+    healthCheckSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service labels, as a JSON object.
      */
-    labelsSwarm?: pulumi.Input<string>;
+    labelsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Hard memory limit, for example `512m`.
      */
-    memoryLimit?: pulumi.Input<string>;
+    memoryLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft memory reservation, for example `256m`.
      */
-    memoryReservation?: pulumi.Input<string>;
+    memoryReservation?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service mode, as a JSON object.
      */
-    modeSwarm?: pulumi.Input<string>;
+    modeSwarm?: pulumi.Input<string | undefined>;
     /**
      * Display name of the database.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * IDs of additional Docker networks to attach.
      */
-    networkIds?: pulumi.Input<pulumi.Input<string>[]>;
+    networkIds?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Docker Swarm network attachments, as a JSON array.
      */
-    networkSwarm?: pulumi.Input<string>;
+    networkSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm placement constraints, as a JSON object.
      */
-    placementSwarm?: pulumi.Input<string>;
+    placementSwarm?: pulumi.Input<string | undefined>;
     /**
      * Number of replicas to run.
      */
-    replicas?: pulumi.Input<number>;
+    replicas?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm restart policy, as a JSON object.
      */
-    restartPolicySwarm?: pulumi.Input<string>;
+    restartPolicySwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rollback configuration, as a JSON object.
      */
-    rollbackConfigSwarm?: pulumi.Input<string>;
+    rollbackConfigSwarm?: pulumi.Input<string | undefined>;
     /**
      * Remote server to deploy on. Omit to use the Dokploy host itself.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
     /**
      * Grace period in nanoseconds before a container is killed.
      */
-    stopGracePeriodSwarm?: pulumi.Input<number>;
+    stopGracePeriodSwarm?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm ulimits, as a JSON object.
      */
-    ulimitsSwarm?: pulumi.Input<string>;
+    ulimitsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rolling update configuration, as a JSON object.
      */
-    updateConfigSwarm?: pulumi.Input<string>;
+    updateConfigSwarm?: pulumi.Input<string | undefined>;
 }

sdk/nodejs/network.ts

@@ -0,0 +1,220 @@
+// *** WARNING: this file was generated by pulumi-language-nodejs. ***
+// *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+import * as pulumi from "@pulumi/pulumi";
+import * as utilities from "./utilities";
+
+/**
+ * A Docker network managed by Dokploy.
+ *
+ * Attach services to it with `networkIds` on `dokploy.Application`, `dokploy.Compose` and the database resources. Every service also joins the shared `dokploy-network` unless `detachDokployNetwork` is set.
+ *
+ * > Docker networks are immutable. Dokploy has no update endpoint, so changing any attribute replaces the network — which detaches the services currently using it until they redeploy.
+ */
+export class Network extends pulumi.CustomResource {
+    /**
+     * Get an existing Network resource's state with the given name, ID, and optional extra
+     * properties used to qualify the lookup.
+     *
+     * @param name The _unique_ name of the resulting resource.
+     * @param id The _unique_ provider ID of the resource to lookup.
+     * @param state Any extra arguments used during the lookup.
+     * @param opts Optional settings to control the behavior of the CustomResource.
+     */
+    public static get(name: string, id: pulumi.Input<pulumi.ID>, state?: NetworkState, opts?: pulumi.CustomResourceOptions): Network {
+        return new Network(name, <any>state, { ...opts, id: id });
+    }
+
+    /** @internal */
+    public static readonly __pulumiType = 'dokploy:index/network:Network';
+
+    /**
+     * Returns true if the given object is an instance of Network.  This is designed to work even
+     * when multiple copies of the Pulumi SDK have been loaded into the same process.
+     */
+    public static isInstance(obj: any): obj is Network {
+        if (obj === undefined || obj === null) {
+            return false;
+        }
+        return obj['__pulumiType'] === Network.__pulumiType;
+    }
+
+    /**
+     * Allow standalone containers to attach to an overlay network.
+     */
+    declare public readonly attachable: pulumi.Output<boolean>;
+    /**
+     * RFC 3339 timestamp of when the network was created.
+     */
+    declare public /*out*/ readonly createdAt: pulumi.Output<string>;
+    /**
+     * Network driver. Use `overlay` for multi-node Swarm clusters and `bridge` for a single host. Valid values: `bridge`, `overlay`.
+     */
+    declare public readonly driver: pulumi.Output<string>;
+    /**
+     * Enable IPv4 address allocation.
+     */
+    declare public readonly enableIpv4: pulumi.Output<boolean>;
+    /**
+     * Enable IPv6 address allocation.
+     */
+    declare public readonly enableIpv6: pulumi.Output<boolean>;
+    /**
+     * Isolate the network from external access.
+     */
+    declare public readonly internal: pulumi.Output<boolean>;
+    /**
+     * Custom IP address management, as a JSON object with `subnet`, `gateway` and `ipRange` keys. Leave unset to let Docker choose a subnet.
+     */
+    declare public readonly ipam: pulumi.Output<string | undefined>;
+    /**
+     * Maximum transmission unit for the network. Leave unset to use Docker's default.
+     */
+    declare public readonly mtu: pulumi.Output<number | undefined>;
+    /**
+     * Name of the Docker network.
+     */
+    declare public readonly name: pulumi.Output<string>;
+    /**
+     * Organization that owns the network.
+     */
+    declare public /*out*/ readonly organizationId: pulumi.Output<string>;
+    /**
+     * Remote server to create the network on. Omit to use the Dokploy host itself.
+     */
+    declare public readonly serverId: pulumi.Output<string | undefined>;
+
+    /**
+     * Create a Network resource with the given unique name, arguments, and options.
+     *
+     * @param name The _unique_ name of the resource.
+     * @param args The arguments to use to populate this resource's properties.
+     * @param opts A bag of options that control this resource's behavior.
+     */
+    constructor(name: string, args?: NetworkArgs, opts?: pulumi.CustomResourceOptions)
+    constructor(name: string, argsOrState?: NetworkArgs | NetworkState, opts?: pulumi.CustomResourceOptions) {
+        let resourceInputs: pulumi.Inputs = {};
+        opts = opts || {};
+        if (opts.id) {
+            const state = argsOrState as NetworkState | undefined;
+            resourceInputs["attachable"] = state?.attachable;
+            resourceInputs["createdAt"] = state?.createdAt;
+            resourceInputs["driver"] = state?.driver;
+            resourceInputs["enableIpv4"] = state?.enableIpv4;
+            resourceInputs["enableIpv6"] = state?.enableIpv6;
+            resourceInputs["internal"] = state?.internal;
+            resourceInputs["ipam"] = state?.ipam;
+            resourceInputs["mtu"] = state?.mtu;
+            resourceInputs["name"] = state?.name;
+            resourceInputs["organizationId"] = state?.organizationId;
+            resourceInputs["serverId"] = state?.serverId;
+        } else {
+            const args = argsOrState as NetworkArgs | undefined;
+            resourceInputs["attachable"] = args?.attachable;
+            resourceInputs["driver"] = args?.driver;
+            resourceInputs["enableIpv4"] = args?.enableIpv4;
+            resourceInputs["enableIpv6"] = args?.enableIpv6;
+            resourceInputs["internal"] = args?.internal;
+            resourceInputs["ipam"] = args?.ipam;
+            resourceInputs["mtu"] = args?.mtu;
+            resourceInputs["name"] = args?.name;
+            resourceInputs["serverId"] = args?.serverId;
+            resourceInputs["createdAt"] = undefined /*out*/;
+            resourceInputs["organizationId"] = undefined /*out*/;
+        }
+        opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts);
+        super(Network.__pulumiType, name, resourceInputs, opts);
+    }
+}
+
+/**
+ * Input properties used for looking up and filtering Network resources.
+ */
+export interface NetworkState {
+    /**
+     * Allow standalone containers to attach to an overlay network.
+     */
+    attachable?: pulumi.Input<boolean | undefined>;
+    /**
+     * RFC 3339 timestamp of when the network was created.
+     */
+    createdAt?: pulumi.Input<string | undefined>;
+    /**
+     * Network driver. Use `overlay` for multi-node Swarm clusters and `bridge` for a single host. Valid values: `bridge`, `overlay`.
+     */
+    driver?: pulumi.Input<string | undefined>;
+    /**
+     * Enable IPv4 address allocation.
+     */
+    enableIpv4?: pulumi.Input<boolean | undefined>;
+    /**
+     * Enable IPv6 address allocation.
+     */
+    enableIpv6?: pulumi.Input<boolean | undefined>;
+    /**
+     * Isolate the network from external access.
+     */
+    internal?: pulumi.Input<boolean | undefined>;
+    /**
+     * Custom IP address management, as a JSON object with `subnet`, `gateway` and `ipRange` keys. Leave unset to let Docker choose a subnet.
+     */
+    ipam?: pulumi.Input<string | undefined>;
+    /**
+     * Maximum transmission unit for the network. Leave unset to use Docker's default.
+     */
+    mtu?: pulumi.Input<number | undefined>;
+    /**
+     * Name of the Docker network.
+     */
+    name?: pulumi.Input<string | undefined>;
+    /**
+     * Organization that owns the network.
+     */
+    organizationId?: pulumi.Input<string | undefined>;
+    /**
+     * Remote server to create the network on. Omit to use the Dokploy host itself.
+     */
+    serverId?: pulumi.Input<string | undefined>;
+}
+
+/**
+ * The set of arguments for constructing a Network resource.
+ */
+export interface NetworkArgs {
+    /**
+     * Allow standalone containers to attach to an overlay network.
+     */
+    attachable?: pulumi.Input<boolean | undefined>;
+    /**
+     * Network driver. Use `overlay` for multi-node Swarm clusters and `bridge` for a single host. Valid values: `bridge`, `overlay`.
+     */
+    driver?: pulumi.Input<string | undefined>;
+    /**
+     * Enable IPv4 address allocation.
+     */
+    enableIpv4?: pulumi.Input<boolean | undefined>;
+    /**
+     * Enable IPv6 address allocation.
+     */
+    enableIpv6?: pulumi.Input<boolean | undefined>;
+    /**
+     * Isolate the network from external access.
+     */
+    internal?: pulumi.Input<boolean | undefined>;
+    /**
+     * Custom IP address management, as a JSON object with `subnet`, `gateway` and `ipRange` keys. Leave unset to let Docker choose a subnet.
+     */
+    ipam?: pulumi.Input<string | undefined>;
+    /**
+     * Maximum transmission unit for the network. Leave unset to use Docker's default.
+     */
+    mtu?: pulumi.Input<number | undefined>;
+    /**
+     * Name of the Docker network.
+     */
+    name?: pulumi.Input<string | undefined>;
+    /**
+     * Remote server to create the network on. Omit to use the Dokploy host itself.
+     */
+    serverId?: pulumi.Input<string | undefined>;
+}

sdk/nodejs/package-lock.json

@@ -1,12 +1,12 @@
 {
     "name": "@maxvojtkov/pulumi-dokploy",
-    "version": "0.1.0",
+    "version": "0.2.0",
     "lockfileVersion": 3,
     "requires": true,
     "packages": {
         "": {
             "name": "@maxvojtkov/pulumi-dokploy",
-            "version": "0.1.0",
+            "version": "0.2.0",
             "license": "MPL-2.0",
             "dependencies": {
                 "@pulumi/pulumi": "^3.0.0"
@@ -858,9 +858,9 @@
             "license": "BSD-3-Clause"
         },
         "node_modules/@pulumi/pulumi": {
-            "version": "3.256.0",
+            "version": "3.259.0",
-            "resolved": "https://registry.npmjs.org/@pulumi/pulumi/-/pulumi-3.256.0.tgz",
+            "resolved": "https://registry.npmjs.org/@pulumi/pulumi/-/pulumi-3.259.0.tgz",
-            "integrity": "sha512-EK1TQieOmxTxbIpX5EKTPpC1WYappH3ASEZzN6Q9gs7rZjuZCATXI9Am8nszmlRdtPlAiVSW8NfQNKCnaNk34A==",
+            "integrity": "sha512-DRc1bDHWTofZGkKcs/bx98LujCZJNoKRkOdeEhQZNz7wPUX/obhuzmWJezew2FUCEAy1xXHtQj1CTcANHoLn3A==",
             "license": "Apache-2.0",
             "dependencies": {
                 "@grpc/grpc-js": "^1.10.1",
@@ -927,9 +927,9 @@
             }
         },
         "node_modules/@sigstore/protobuf-specs": {
-            "version": "0.5.1",
+            "version": "0.5.2",
-            "resolved": "https://registry.npmjs.org/@sigstore/protobuf-specs/-/protobuf-specs-0.5.1.tgz",
+            "resolved": "https://registry.npmjs.org/@sigstore/protobuf-specs/-/protobuf-specs-0.5.2.tgz",
-            "integrity": "sha512-/ScWUhhoFasJsSRGTVBwId1loQjjnjAfE4djL6ZhrXRpNCmPTnUKF5Jokd58ILseOMjzET3UrMOtJPS9sYeI0g==",
+            "integrity": "sha512-SQqvFMt4V78fdjcDdYX6HbiVSOR4QK3ZgwCa2KOsopAgPIHy1rU5UDUmzLl02r5oyyaYcYHR1hpwDRk/yUe+Mw==",
             "license": "Apache-2.0",
             "engines": {
                 "node": "^18.17.0 || >=20.5.0"
@@ -1144,9 +1144,9 @@
             }
         },
         "node_modules/cjs-module-lexer": {
-            "version": "2.2.0",
+            "version": "2.2.1",
-            "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-2.2.0.tgz",
+            "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-2.2.1.tgz",
-            "integrity": "sha512-4bHTS2YuzUvtoLjdy+98ykbNB5jS0+07EvFNXerqZQJ89F7DI6ET7OQo/HJuW6K0aVsKA9hj9/RVb2kQVOrPDQ==",
+            "integrity": "sha512-Ca8swihM+/4yKecYHY52kgJd300hi2lADU/a1RxNTRe+RJ9jvqQlESpbz9DnG9mowez8qwXHB8qYdIUw9e+F5Q==",
             "license": "MIT"
         },
         "node_modules/cliui": {
@@ -1199,6 +1199,19 @@
                 "node": ">= 18"
             }
         },
+        "node_modules/content-type": {
+            "version": "2.1.0",
+            "resolved": "https://registry.npmjs.org/content-type/-/content-type-2.1.0.tgz",
+            "integrity": "sha512-mj7UPXE0jaqaOsukNZRUEfEi2AcL7C/vwmwcHV0O97eO1E1pxBZuyjlZrx5seTaNBg1U6+o35wpa35Qfcc+7ag==",
+            "license": "MIT",
+            "engines": {
+                "node": ">=18"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/express"
+            }
+        },
         "node_modules/cross-spawn": {
             "version": "7.0.6",
             "resolved": "https://registry.npmjs.org/cross-spawn/-/cross-spawn-7.0.6.tgz",
@@ -1279,9 +1292,9 @@
             }
         },
         "node_modules/es-module-lexer": {
-            "version": "2.3.1",
+            "version": "2.3.2",
-            "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.3.1.tgz",
+            "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.3.2.tgz",
-            "integrity": "sha512-shc1dbU90Yl/xq1QrC7QRtfcwURZuVRfPhZbDoldJ1cn1gzDvBaBWlv0eFolj5+0znnPJz5TXLxsN77X/12KTA==",
+            "integrity": "sha512-poHGpORABojJJucnV9KbOavETW8lBVnphkW77ER5/BQ5Fz7oXSoCNek7IH3vR5nRjdsEz926ibFYX8KtLQmdyw==",
             "license": "MIT"
         },
         "node_modules/escalade": {
@@ -1507,9 +1520,9 @@
             }
         },
         "node_modules/ip-address": {
-            "version": "10.4.0",
+            "version": "10.5.0",
-            "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.4.0.tgz",
+            "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.5.0.tgz",
-            "integrity": "sha512-oSK96Grm3aP6OrS263xVxbNDGVL7rzBtYdpGqlDG8iQdoenDoTs/nkki+DflYbAEE8Xl6o5YxhxlrKvI3nqKXQ==",
+            "integrity": "sha512-R5SnVLJmgYYvf2F2ZgwSBnelz5G4q5AxIC277GDfUaNbrZKNANcBC7RHqYYePlszf4kBolVkJauG0ZjHHFh55g==",
             "license": "MIT",
             "engines": {
                 "node": ">= 12"
@@ -1824,12 +1837,19 @@
             "license": "MIT"
         },
         "node_modules/negotiator": {
-            "version": "1.0.0",
+            "version": "1.1.0",
-            "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz",
+            "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.1.0.tgz",
-            "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==",
+            "integrity": "sha512-NMPBRMJgiQHjbd8phG3Vebdx4kZ1H121rbl5IkMqeOsahptB9BKo/d7oJ3zTXqTgagn2bWlNSXkh0QUGM31RYg==",
             "license": "MIT",
+            "dependencies": {
+                "content-type": "^2.1.0"
+            },
             "engines": {
-                "node": ">= 0.6"
+                "node": ">=18"
+            },
+            "funding": {
+                "type": "opencollective",
+                "url": "https://opencollective.com/express"
             }
         },
         "node_modules/node-gyp": {
@@ -2108,9 +2128,9 @@
             }
         },
         "node_modules/picomatch": {
-            "version": "4.0.5",
+            "version": "4.0.7",
-            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz",
+            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.7.tgz",
-            "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==",
+            "integrity": "sha512-qcJu88Q2IWqJsDD529JKMdwGm/dvInW4HvQnRwiH9JtihJvzGOscDtHE3x1pBKeUOTysQ8kVmLnJ2kJu7yhcGA==",
             "license": "MIT",
             "engines": {
                 "node": ">=12"

sdk/nodejs/package.json

@@ -1,7 +1,7 @@
 {
     "name": "@maxvojtkov/pulumi-dokploy",
-    "version": "0.1.0",
+    "version": "0.2.0",
-    "description": "A Pulumi package for creating and managing Dokploy resources. Based on terraform-provider-dokploy: version v0.1.0",
+    "description": "A Pulumi package for creating and managing Dokploy resources. Based on terraform-provider-dokploy: version v0.2.0",
     "keywords": [
         "pulumi",
         "dokploy",
@@ -27,7 +27,7 @@
     "pulumi": {
         "resource": true,
         "name": "dokploy",
-        "version": "0.1.0",
+        "version": "0.2.0",
         "server": "https://gitea.coolify.vojtkov.dev/usr_unknown/pulumi-dokploy/releases/download/v${VERSION}"
     }
 }

sdk/nodejs/port.ts

@@ -4,6 +4,9 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * A published port that exposes an application directly on the host, bypassing Traefik.
+ */
 export class Port extends pulumi.CustomResource {
     /**
      * Get an existing Port resource's state with the given name, ID, and optional extra
@@ -103,23 +106,23 @@ export interface PortState {
     /**
      * Application this port belongs to.
      */
-    applicationId?: pulumi.Input<string>;
+    applicationId?: pulumi.Input<string | undefined>;
     /**
      * Transport protocol. Valid values: `tcp`, `udp`.
      */
-    protocol?: pulumi.Input<string>;
+    protocol?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm publish mode. `host` binds directly to the node; `ingress` uses the swarm routing mesh. Valid values: `ingress`, `host`.
      */
-    publishMode?: pulumi.Input<string>;
+    publishMode?: pulumi.Input<string | undefined>;
     /**
      * Port exposed on the host.
      */
-    publishedPort?: pulumi.Input<number>;
+    publishedPort?: pulumi.Input<number | undefined>;
     /**
      * Port the container listens on.
      */
-    targetPort?: pulumi.Input<number>;
+    targetPort?: pulumi.Input<number | undefined>;
 }
 
 /**
@@ -137,7 +140,7 @@ export interface PortArgs {
     /**
      * Docker Swarm publish mode. `host` binds directly to the node; `ingress` uses the swarm routing mesh. Valid values: `ingress`, `host`.
      */
-    publishMode?: pulumi.Input<string>;
+    publishMode?: pulumi.Input<string | undefined>;
     /**
      * Port exposed on the host.
      */

sdk/nodejs/postgres.ts

@@ -4,6 +4,13 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * A managed PostgreSQL instance running on Dokploy.
+ *
+ * > Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+ *
+ * > Credentials are stored in Terraform state. Use a state backend with encryption at rest.
+ */
 export class Postgres extends pulumi.CustomResource {
     /**
      * Get an existing Postgres resource's state with the given name, ID, and optional extra
@@ -276,135 +283,135 @@ export interface PostgresState {
     /**
      * Unique Docker service name. Generated by Dokploy when omitted. Changing it forces a new database.
      */
-    appName?: pulumi.Input<string>;
+    appName?: pulumi.Input<string | undefined>;
     /**
      * Current status reported by Dokploy: `idle`, `running`, `done` or `error`.
      */
-    applicationStatus?: pulumi.Input<string>;
+    applicationStatus?: pulumi.Input<string | undefined>;
     /**
      * Arguments appended to the container command.
      */
-    args?: pulumi.Input<pulumi.Input<string>[]>;
+    args?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Override the container entrypoint command.
      */
-    command?: pulumi.Input<string>;
+    command?: pulumi.Input<string | undefined>;
     /**
      * Hard CPU limit, for example `1`.
      */
-    cpuLimit?: pulumi.Input<string>;
+    cpuLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft CPU reservation, for example `0.5`.
      */
-    cpuReservation?: pulumi.Input<string>;
+    cpuReservation?: pulumi.Input<string | undefined>;
     /**
      * RFC 3339 timestamp of when the database was created.
      */
-    createdAt?: pulumi.Input<string>;
+    createdAt?: pulumi.Input<string | undefined>;
     /**
      * Name of the database to create.
      */
-    databaseName?: pulumi.Input<string>;
+    databaseName?: pulumi.Input<string | undefined>;
     /**
      * Password for the database user.
      */
-    databasePassword?: pulumi.Input<string>;
+    databasePassword?: pulumi.Input<string | undefined>;
     /**
      * Database user to create.
      */
-    databaseUser?: pulumi.Input<string>;
+    databaseUser?: pulumi.Input<string | undefined>;
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * Detach the service from the shared `dokploy-network`.
      */
-    detachDokployNetwork?: pulumi.Input<boolean>;
+    detachDokployNetwork?: pulumi.Input<boolean | undefined>;
     /**
      * PostgreSQL image to run, for example `postgres:16`.
      */
-    dockerImage?: pulumi.Input<string>;
+    dockerImage?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm endpoint specification, as a JSON object.
      */
-    endpointSpecSwarm?: pulumi.Input<string>;
+    endpointSpecSwarm?: pulumi.Input<string | undefined>;
     /**
      * Environment variables in `KEY=value` format, one per line.
      */
-    env?: pulumi.Input<string>;
+    env?: pulumi.Input<string | undefined>;
     /**
      * Environment this database belongs to.
      */
-    environmentId?: pulumi.Input<string>;
+    environmentId?: pulumi.Input<string | undefined>;
     /**
      * Host port to expose the database on. Leave unset to keep the database reachable only from inside the Docker network.
      */
-    externalPort?: pulumi.Input<number>;
+    externalPort?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm health check configuration, as a JSON object.
      */
-    healthCheckSwarm?: pulumi.Input<string>;
+    healthCheckSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service labels, as a JSON object.
      */
-    labelsSwarm?: pulumi.Input<string>;
+    labelsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Hard memory limit, for example `512m`.
      */
-    memoryLimit?: pulumi.Input<string>;
+    memoryLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft memory reservation, for example `256m`.
      */
-    memoryReservation?: pulumi.Input<string>;
+    memoryReservation?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service mode, as a JSON object.
      */
-    modeSwarm?: pulumi.Input<string>;
+    modeSwarm?: pulumi.Input<string | undefined>;
     /**
      * Display name of the database.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * IDs of additional Docker networks to attach.
      */
-    networkIds?: pulumi.Input<pulumi.Input<string>[]>;
+    networkIds?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Docker Swarm network attachments, as a JSON array.
      */
-    networkSwarm?: pulumi.Input<string>;
+    networkSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm placement constraints, as a JSON object.
      */
-    placementSwarm?: pulumi.Input<string>;
+    placementSwarm?: pulumi.Input<string | undefined>;
     /**
      * Number of replicas to run.
      */
-    replicas?: pulumi.Input<number>;
+    replicas?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm restart policy, as a JSON object.
      */
-    restartPolicySwarm?: pulumi.Input<string>;
+    restartPolicySwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rollback configuration, as a JSON object.
      */
-    rollbackConfigSwarm?: pulumi.Input<string>;
+    rollbackConfigSwarm?: pulumi.Input<string | undefined>;
     /**
      * Remote server to deploy on. Omit to use the Dokploy host itself.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
     /**
      * Grace period in nanoseconds before a container is killed.
      */
-    stopGracePeriodSwarm?: pulumi.Input<number>;
+    stopGracePeriodSwarm?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm ulimits, as a JSON object.
      */
-    ulimitsSwarm?: pulumi.Input<string>;
+    ulimitsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rolling update configuration, as a JSON object.
      */
-    updateConfigSwarm?: pulumi.Input<string>;
+    updateConfigSwarm?: pulumi.Input<string | undefined>;
 }
 
 /**
@@ -414,23 +421,23 @@ export interface PostgresArgs {
     /**
      * Unique Docker service name. Generated by Dokploy when omitted. Changing it forces a new database.
      */
-    appName?: pulumi.Input<string>;
+    appName?: pulumi.Input<string | undefined>;
     /**
      * Arguments appended to the container command.
      */
-    args?: pulumi.Input<pulumi.Input<string>[]>;
+    args?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Override the container entrypoint command.
      */
-    command?: pulumi.Input<string>;
+    command?: pulumi.Input<string | undefined>;
     /**
      * Hard CPU limit, for example `1`.
      */
-    cpuLimit?: pulumi.Input<string>;
+    cpuLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft CPU reservation, for example `0.5`.
      */
-    cpuReservation?: pulumi.Input<string>;
+    cpuReservation?: pulumi.Input<string | undefined>;
     /**
      * Name of the database to create.
      */
@@ -446,11 +453,11 @@ export interface PostgresArgs {
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * Detach the service from the shared `dokploy-network`.
      */
-    detachDokployNetwork?: pulumi.Input<boolean>;
+    detachDokployNetwork?: pulumi.Input<boolean | undefined>;
     /**
      * PostgreSQL image to run, for example `postgres:16`.
      */
@@ -458,11 +465,11 @@ export interface PostgresArgs {
     /**
      * Docker Swarm endpoint specification, as a JSON object.
      */
-    endpointSpecSwarm?: pulumi.Input<string>;
+    endpointSpecSwarm?: pulumi.Input<string | undefined>;
     /**
      * Environment variables in `KEY=value` format, one per line.
      */
-    env?: pulumi.Input<string>;
+    env?: pulumi.Input<string | undefined>;
     /**
      * Environment this database belongs to.
      */
@@ -470,69 +477,69 @@ export interface PostgresArgs {
     /**
      * Host port to expose the database on. Leave unset to keep the database reachable only from inside the Docker network.
      */
-    externalPort?: pulumi.Input<number>;
+    externalPort?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm health check configuration, as a JSON object.
      */
-    healthCheckSwarm?: pulumi.Input<string>;
+    healthCheckSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service labels, as a JSON object.
      */
-    labelsSwarm?: pulumi.Input<string>;
+    labelsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Hard memory limit, for example `512m`.
      */
-    memoryLimit?: pulumi.Input<string>;
+    memoryLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft memory reservation, for example `256m`.
      */
-    memoryReservation?: pulumi.Input<string>;
+    memoryReservation?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service mode, as a JSON object.
      */
-    modeSwarm?: pulumi.Input<string>;
+    modeSwarm?: pulumi.Input<string | undefined>;
     /**
      * Display name of the database.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * IDs of additional Docker networks to attach.
      */
-    networkIds?: pulumi.Input<pulumi.Input<string>[]>;
+    networkIds?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Docker Swarm network attachments, as a JSON array.
      */
-    networkSwarm?: pulumi.Input<string>;
+    networkSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm placement constraints, as a JSON object.
      */
-    placementSwarm?: pulumi.Input<string>;
+    placementSwarm?: pulumi.Input<string | undefined>;
     /**
      * Number of replicas to run.
      */
-    replicas?: pulumi.Input<number>;
+    replicas?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm restart policy, as a JSON object.
      */
-    restartPolicySwarm?: pulumi.Input<string>;
+    restartPolicySwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rollback configuration, as a JSON object.
      */
-    rollbackConfigSwarm?: pulumi.Input<string>;
+    rollbackConfigSwarm?: pulumi.Input<string | undefined>;
     /**
      * Remote server to deploy on. Omit to use the Dokploy host itself.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
     /**
      * Grace period in nanoseconds before a container is killed.
      */
-    stopGracePeriodSwarm?: pulumi.Input<number>;
+    stopGracePeriodSwarm?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm ulimits, as a JSON object.
      */
-    ulimitsSwarm?: pulumi.Input<string>;
+    ulimitsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rolling update configuration, as a JSON object.
      */
-    updateConfigSwarm?: pulumi.Input<string>;
+    updateConfigSwarm?: pulumi.Input<string | undefined>;
 }

sdk/nodejs/project.ts

@@ -4,6 +4,11 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * A Dokploy project: the top-level container for environments and services.
+ *
+ * Creating a project automatically creates a default `production` environment. Its ID is exposed as `defaultEnvironmentId`, so services can be attached without declaring a separate `dokploy.Environment` resource.
+ */
 export class Project extends pulumi.CustomResource {
     /**
      * Get an existing Project resource's state with the given name, ID, and optional extra
@@ -97,27 +102,27 @@ export interface ProjectState {
     /**
      * RFC 3339 timestamp of when the project was created.
      */
-    createdAt?: pulumi.Input<string>;
+    createdAt?: pulumi.Input<string | undefined>;
     /**
      * ID of the `production` environment that Dokploy creates automatically with the project.
      */
-    defaultEnvironmentId?: pulumi.Input<string>;
+    defaultEnvironmentId?: pulumi.Input<string | undefined>;
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * Project-wide environment variables in `KEY=value` format, one per line. These are shared with every service in the project.
      */
-    env?: pulumi.Input<string>;
+    env?: pulumi.Input<string | undefined>;
     /**
      * Display name of the project.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * Organization that owns the project.
      */
-    organizationId?: pulumi.Input<string>;
+    organizationId?: pulumi.Input<string | undefined>;
 }
 
 /**
@@ -127,13 +132,13 @@ export interface ProjectArgs {
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * Project-wide environment variables in `KEY=value` format, one per line. These are shared with every service in the project.
      */
-    env?: pulumi.Input<string>;
+    env?: pulumi.Input<string | undefined>;
     /**
      * Display name of the project.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
 }

sdk/nodejs/provider.ts

@@ -73,19 +73,19 @@ export interface ProviderArgs {
     /**
      * API token generated in Dokploy under *Settings > Profile > API/CLI*. May also be set with the `DOKPLOY_API_KEY` environment variable.
      */
-    apiKey?: pulumi.Input<string>;
+    apiKey?: pulumi.Input<string | undefined>;
     /**
      * Base URL of the Dokploy instance, for example `https://dokploy.example.com`. A trailing `/api` is optional. May also be set with the `DOKPLOY_HOST` environment variable.
      */
-    host?: pulumi.Input<string>;
+    host?: pulumi.Input<string | undefined>;
     /**
      * Skip TLS certificate verification. Only use this for instances behind a self-signed certificate. Defaults to `false`.
      */
-    insecureSkipVerify?: pulumi.Input<boolean>;
+    insecureSkipVerify?: pulumi.Input<boolean | undefined>;
     /**
      * Per-request timeout in seconds. Defaults to `60`. May also be set with the `DOKPLOY_TIMEOUT_SECONDS` environment variable.
      */
-    timeoutSeconds?: pulumi.Input<number>;
+    timeoutSeconds?: pulumi.Input<number | undefined>;
 }
 
 export namespace Provider {

sdk/nodejs/redirect.ts

@@ -4,6 +4,9 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * A Traefik redirect rule attached to an application.
+ */
 export class Redirect extends pulumi.CustomResource {
     /**
      * Get an existing Redirect resource's state with the given name, ID, and optional extra
@@ -100,23 +103,23 @@ export interface RedirectState {
     /**
      * Application this redirect belongs to.
      */
-    applicationId?: pulumi.Input<string>;
+    applicationId?: pulumi.Input<string | undefined>;
     /**
      * RFC 3339 timestamp of when the redirect was created.
      */
-    createdAt?: pulumi.Input<string>;
+    createdAt?: pulumi.Input<string | undefined>;
     /**
      * Issue a permanent (301) redirect instead of a temporary (302) one.
      */
-    permanent?: pulumi.Input<boolean>;
+    permanent?: pulumi.Input<boolean | undefined>;
     /**
      * Regular expression matched against the incoming URL.
      */
-    regex?: pulumi.Input<string>;
+    regex?: pulumi.Input<string | undefined>;
     /**
      * Replacement URL, which may reference capture groups such as `${1}`.
      */
-    replacement?: pulumi.Input<string>;
+    replacement?: pulumi.Input<string | undefined>;
 }
 
 /**
@@ -130,7 +133,7 @@ export interface RedirectArgs {
     /**
      * Issue a permanent (301) redirect instead of a temporary (302) one.
      */
-    permanent?: pulumi.Input<boolean>;
+    permanent?: pulumi.Input<boolean | undefined>;
     /**
      * Regular expression matched against the incoming URL.
      */

sdk/nodejs/redis.ts

@@ -4,6 +4,13 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * A managed Redis instance running on Dokploy.
+ *
+ * > Creating this resource provisions the service definition but does **not** start a deployment. Deploy it from the Dokploy UI or CLI.
+ *
+ * > Credentials are stored in Terraform state. Use a state backend with encryption at rest.
+ */
 export class Redis extends pulumi.CustomResource {
     /**
      * Get an existing Redis resource's state with the given name, ID, and optional extra
@@ -258,127 +265,127 @@ export interface RedisState {
     /**
      * Unique Docker service name. Generated by Dokploy when omitted. Changing it forces a new database.
      */
-    appName?: pulumi.Input<string>;
+    appName?: pulumi.Input<string | undefined>;
     /**
      * Current status reported by Dokploy: `idle`, `running`, `done` or `error`.
      */
-    applicationStatus?: pulumi.Input<string>;
+    applicationStatus?: pulumi.Input<string | undefined>;
     /**
      * Arguments appended to the container command.
      */
-    args?: pulumi.Input<pulumi.Input<string>[]>;
+    args?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Override the container entrypoint command.
      */
-    command?: pulumi.Input<string>;
+    command?: pulumi.Input<string | undefined>;
     /**
      * Hard CPU limit, for example `1`.
      */
-    cpuLimit?: pulumi.Input<string>;
+    cpuLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft CPU reservation, for example `0.5`.
      */
-    cpuReservation?: pulumi.Input<string>;
+    cpuReservation?: pulumi.Input<string | undefined>;
     /**
      * RFC 3339 timestamp of when the database was created.
      */
-    createdAt?: pulumi.Input<string>;
+    createdAt?: pulumi.Input<string | undefined>;
     /**
      * Password used to authenticate to Redis.
      */
-    databasePassword?: pulumi.Input<string>;
+    databasePassword?: pulumi.Input<string | undefined>;
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * Detach the service from the shared `dokploy-network`.
      */
-    detachDokployNetwork?: pulumi.Input<boolean>;
+    detachDokployNetwork?: pulumi.Input<boolean | undefined>;
     /**
      * Redis image to run, for example `redis:7`.
      */
-    dockerImage?: pulumi.Input<string>;
+    dockerImage?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm endpoint specification, as a JSON object.
      */
-    endpointSpecSwarm?: pulumi.Input<string>;
+    endpointSpecSwarm?: pulumi.Input<string | undefined>;
     /**
      * Environment variables in `KEY=value` format, one per line.
      */
-    env?: pulumi.Input<string>;
+    env?: pulumi.Input<string | undefined>;
     /**
      * Environment this database belongs to.
      */
-    environmentId?: pulumi.Input<string>;
+    environmentId?: pulumi.Input<string | undefined>;
     /**
      * Host port to expose the database on. Leave unset to keep the database reachable only from inside the Docker network.
      */
-    externalPort?: pulumi.Input<number>;
+    externalPort?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm health check configuration, as a JSON object.
      */
-    healthCheckSwarm?: pulumi.Input<string>;
+    healthCheckSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service labels, as a JSON object.
      */
-    labelsSwarm?: pulumi.Input<string>;
+    labelsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Hard memory limit, for example `512m`.
      */
-    memoryLimit?: pulumi.Input<string>;
+    memoryLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft memory reservation, for example `256m`.
      */
-    memoryReservation?: pulumi.Input<string>;
+    memoryReservation?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service mode, as a JSON object.
      */
-    modeSwarm?: pulumi.Input<string>;
+    modeSwarm?: pulumi.Input<string | undefined>;
     /**
      * Display name of the database.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * IDs of additional Docker networks to attach.
      */
-    networkIds?: pulumi.Input<pulumi.Input<string>[]>;
+    networkIds?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Docker Swarm network attachments, as a JSON array.
      */
-    networkSwarm?: pulumi.Input<string>;
+    networkSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm placement constraints, as a JSON object.
      */
-    placementSwarm?: pulumi.Input<string>;
+    placementSwarm?: pulumi.Input<string | undefined>;
     /**
      * Number of replicas to run.
      */
-    replicas?: pulumi.Input<number>;
+    replicas?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm restart policy, as a JSON object.
      */
-    restartPolicySwarm?: pulumi.Input<string>;
+    restartPolicySwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rollback configuration, as a JSON object.
      */
-    rollbackConfigSwarm?: pulumi.Input<string>;
+    rollbackConfigSwarm?: pulumi.Input<string | undefined>;
     /**
      * Remote server to deploy on. Omit to use the Dokploy host itself.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
     /**
      * Grace period in nanoseconds before a container is killed.
      */
-    stopGracePeriodSwarm?: pulumi.Input<number>;
+    stopGracePeriodSwarm?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm ulimits, as a JSON object.
      */
-    ulimitsSwarm?: pulumi.Input<string>;
+    ulimitsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rolling update configuration, as a JSON object.
      */
-    updateConfigSwarm?: pulumi.Input<string>;
+    updateConfigSwarm?: pulumi.Input<string | undefined>;
 }
 
 /**
@@ -388,23 +395,23 @@ export interface RedisArgs {
     /**
      * Unique Docker service name. Generated by Dokploy when omitted. Changing it forces a new database.
      */
-    appName?: pulumi.Input<string>;
+    appName?: pulumi.Input<string | undefined>;
     /**
      * Arguments appended to the container command.
      */
-    args?: pulumi.Input<pulumi.Input<string>[]>;
+    args?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Override the container entrypoint command.
      */
-    command?: pulumi.Input<string>;
+    command?: pulumi.Input<string | undefined>;
     /**
      * Hard CPU limit, for example `1`.
      */
-    cpuLimit?: pulumi.Input<string>;
+    cpuLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft CPU reservation, for example `0.5`.
      */
-    cpuReservation?: pulumi.Input<string>;
+    cpuReservation?: pulumi.Input<string | undefined>;
     /**
      * Password used to authenticate to Redis.
      */
@@ -412,11 +419,11 @@ export interface RedisArgs {
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * Detach the service from the shared `dokploy-network`.
      */
-    detachDokployNetwork?: pulumi.Input<boolean>;
+    detachDokployNetwork?: pulumi.Input<boolean | undefined>;
     /**
      * Redis image to run, for example `redis:7`.
      */
@@ -424,11 +431,11 @@ export interface RedisArgs {
     /**
      * Docker Swarm endpoint specification, as a JSON object.
      */
-    endpointSpecSwarm?: pulumi.Input<string>;
+    endpointSpecSwarm?: pulumi.Input<string | undefined>;
     /**
      * Environment variables in `KEY=value` format, one per line.
      */
-    env?: pulumi.Input<string>;
+    env?: pulumi.Input<string | undefined>;
     /**
      * Environment this database belongs to.
      */
@@ -436,69 +443,69 @@ export interface RedisArgs {
     /**
      * Host port to expose the database on. Leave unset to keep the database reachable only from inside the Docker network.
      */
-    externalPort?: pulumi.Input<number>;
+    externalPort?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm health check configuration, as a JSON object.
      */
-    healthCheckSwarm?: pulumi.Input<string>;
+    healthCheckSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service labels, as a JSON object.
      */
-    labelsSwarm?: pulumi.Input<string>;
+    labelsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Hard memory limit, for example `512m`.
      */
-    memoryLimit?: pulumi.Input<string>;
+    memoryLimit?: pulumi.Input<string | undefined>;
     /**
      * Soft memory reservation, for example `256m`.
      */
-    memoryReservation?: pulumi.Input<string>;
+    memoryReservation?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm service mode, as a JSON object.
      */
-    modeSwarm?: pulumi.Input<string>;
+    modeSwarm?: pulumi.Input<string | undefined>;
     /**
      * Display name of the database.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * IDs of additional Docker networks to attach.
      */
-    networkIds?: pulumi.Input<pulumi.Input<string>[]>;
+    networkIds?: pulumi.Input<pulumi.Input<string>[] | undefined>;
     /**
      * Docker Swarm network attachments, as a JSON array.
      */
-    networkSwarm?: pulumi.Input<string>;
+    networkSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm placement constraints, as a JSON object.
      */
-    placementSwarm?: pulumi.Input<string>;
+    placementSwarm?: pulumi.Input<string | undefined>;
     /**
      * Number of replicas to run.
      */
-    replicas?: pulumi.Input<number>;
+    replicas?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm restart policy, as a JSON object.
      */
-    restartPolicySwarm?: pulumi.Input<string>;
+    restartPolicySwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rollback configuration, as a JSON object.
      */
-    rollbackConfigSwarm?: pulumi.Input<string>;
+    rollbackConfigSwarm?: pulumi.Input<string | undefined>;
     /**
      * Remote server to deploy on. Omit to use the Dokploy host itself.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
     /**
      * Grace period in nanoseconds before a container is killed.
      */
-    stopGracePeriodSwarm?: pulumi.Input<number>;
+    stopGracePeriodSwarm?: pulumi.Input<number | undefined>;
     /**
      * Docker Swarm ulimits, as a JSON object.
      */
-    ulimitsSwarm?: pulumi.Input<string>;
+    ulimitsSwarm?: pulumi.Input<string | undefined>;
     /**
      * Docker Swarm rolling update configuration, as a JSON object.
      */
-    updateConfigSwarm?: pulumi.Input<string>;
+    updateConfigSwarm?: pulumi.Input<string | undefined>;
 }