Bridge what Dokploy v0.30 added, and let the docs through

Six new resources from terraform-provider-dokploy v0.2.0 -- Network,
DnsProvider, VaultProvider, Schedule, VolumeBackup and Libsql -- plus the new
properties on Domain (`enabled`), Compose (`serviceNetworks`, `createEnvFile`,
`icon`) and Application. Verified with `pulumi up` against a live v0.30.2
instance: create, preview-clean, and destroy.

The upstream provider also now refuses a volume Mount with no `volumeName`,
which Dokploy would otherwise turn into an anonymous Docker volume recreated
on every deploy. That surfaces here at preview time, before anything exists.

Two things made that fix nearly invisible to Pulumi users, so this commit
fixes the second one: the bridge resolves the upstream `docs/` through the Go
module cache, where a locally `replace`d dependency never lands, so tfgen was
emitting every resource with no description at all. UpstreamRepoPath now
points at the checkout and all 445 inputs carry documentation -- with names
rendered per language, so Python readers see `volume_name` where TypeScript
readers see `volumeName`.

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

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`                           |
-| Networking   | `Domain`, `Mount`, `Port`, `Redirect`, `Security`                          |
+| Databases    | `Postgres`, `MySql`, `MariaDb`, `Mongo`, `Redis`, `Libsql`                 |
+| 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"`
-	CreatedAt         string `pulumi:"createdAt"`
-	Description       string `pulumi:"description"`
-	EnvironmentId     string `pulumi:"environmentId"`
-	Id                string `pulumi:"id"`
-	Name              string `pulumi:"name"`
-	SourceType        string `pulumi:"sourceType"`
+	// Build strategy.
+	BuildType string `pulumi:"buildType"`
+	// Creation timestamp.
+	CreatedAt string `pulumi:"createdAt"`
+	// Application description.
+	Description string `pulumi:"description"`
+	// 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"`
-	Id          string `pulumi:"id"`
-	IsDefault   bool   `pulumi:"isDefault"`
-	Name        string `pulumi:"name"`
-	ProjectId   string `pulumi:"projectId"`
+	// Environment-wide variables.
+	Env string `pulumi:"env"`
+	// Environment identifier.
+	Id string `pulumi:"id"`
+	// 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"`
-	DefaultEnvironmentId string                  `pulumi:"defaultEnvironmentId"`
-	Description          string                  `pulumi:"description"`
-	Env                  string                  `pulumi:"env"`
-	Environments         []GetProjectEnvironment `pulumi:"environments"`
-	Id                   string                  `pulumi:"id"`
-	Name                 string                  `pulumi:"name"`
-	OrganizationId       string                  `pulumi:"organizationId"`
+	// Creation timestamp.
+	CreatedAt string `pulumi:"createdAt"`
+	// ID of the project's default environment.
+	DefaultEnvironmentId string `pulumi:"defaultEnvironmentId"`
+	// Project description.
+	Description string `pulumi:"description"`
+	// Project-wide environment variables.
+	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",
-            "resolved": "https://registry.npmjs.org/@pulumi/pulumi/-/pulumi-3.256.0.tgz",
-            "integrity": "sha512-EK1TQieOmxTxbIpX5EKTPpC1WYappH3ASEZzN6Q9gs7rZjuZCATXI9Am8nszmlRdtPlAiVSW8NfQNKCnaNk34A==",
+            "version": "3.259.0",
+            "resolved": "https://registry.npmjs.org/@pulumi/pulumi/-/pulumi-3.259.0.tgz",
+            "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",
-            "resolved": "https://registry.npmjs.org/@sigstore/protobuf-specs/-/protobuf-specs-0.5.1.tgz",
-            "integrity": "sha512-/ScWUhhoFasJsSRGTVBwId1loQjjnjAfE4djL6ZhrXRpNCmPTnUKF5Jokd58ILseOMjzET3UrMOtJPS9sYeI0g==",
+            "version": "0.5.2",
+            "resolved": "https://registry.npmjs.org/@sigstore/protobuf-specs/-/protobuf-specs-0.5.2.tgz",
+            "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",
-            "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-2.2.0.tgz",
-            "integrity": "sha512-4bHTS2YuzUvtoLjdy+98ykbNB5jS0+07EvFNXerqZQJ89F7DI6ET7OQo/HJuW6K0aVsKA9hj9/RVb2kQVOrPDQ==",
+            "version": "2.2.1",
+            "resolved": "https://registry.npmjs.org/cjs-module-lexer/-/cjs-module-lexer-2.2.1.tgz",
+            "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",
-            "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.3.1.tgz",
-            "integrity": "sha512-shc1dbU90Yl/xq1QrC7QRtfcwURZuVRfPhZbDoldJ1cn1gzDvBaBWlv0eFolj5+0znnPJz5TXLxsN77X/12KTA==",
+            "version": "2.3.2",
+            "resolved": "https://registry.npmjs.org/es-module-lexer/-/es-module-lexer-2.3.2.tgz",
+            "integrity": "sha512-poHGpORABojJJucnV9KbOavETW8lBVnphkW77ER5/BQ5Fz7oXSoCNek7IH3vR5nRjdsEz926ibFYX8KtLQmdyw==",
             "license": "MIT"
         },
         "node_modules/escalade": {
@@ -1507,9 +1520,9 @@
             }
         },
         "node_modules/ip-address": {
-            "version": "10.4.0",
-            "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.4.0.tgz",
-            "integrity": "sha512-oSK96Grm3aP6OrS263xVxbNDGVL7rzBtYdpGqlDG8iQdoenDoTs/nkki+DflYbAEE8Xl6o5YxhxlrKvI3nqKXQ==",
+            "version": "10.5.0",
+            "resolved": "https://registry.npmjs.org/ip-address/-/ip-address-10.5.0.tgz",
+            "integrity": "sha512-R5SnVLJmgYYvf2F2ZgwSBnelz5G4q5AxIC277GDfUaNbrZKNANcBC7RHqYYePlszf4kBolVkJauG0ZjHHFh55g==",
             "license": "MIT",
             "engines": {
                 "node": ">= 12"
@@ -1824,12 +1837,19 @@
             "license": "MIT"
         },
         "node_modules/negotiator": {
-            "version": "1.0.0",
-            "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.0.0.tgz",
-            "integrity": "sha512-8Ofs/AUQh8MaEcrlq5xOX0CQ9ypTF5dl78mjlMNfOK08fzpgTHQRQPBxcPlEtIw0yRpws+Zo/3r+5WRby7u3Gg==",
+            "version": "1.1.0",
+            "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-1.1.0.tgz",
+            "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",
-            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.5.tgz",
-            "integrity": "sha512-RvwwcruNjI1ncT5xRakeyS9Lf8lcItv34KD+aif+VH9kduAyfYBipGh12274xtenIPZ119/R9BdTBa8gAwSh0A==",
+            "version": "4.0.7",
+            "resolved": "https://registry.npmjs.org/picomatch/-/picomatch-4.0.7.tgz",
+            "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",
-    "description": "A Pulumi package for creating and managing Dokploy resources. Based on terraform-provider-dokploy: version v0.1.0",
+    "version": "0.2.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>;
 }

sdk/nodejs/registry.ts

@@ -4,6 +4,9 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * A container registry that Dokploy pushes built images to and pulls them from.
+ */
 export class Registry extends pulumi.CustomResource {
     /**
      * Get an existing Registry resource's state with the given name, ID, and optional extra
@@ -123,35 +126,35 @@ export interface RegistryState {
     /**
      * RFC 3339 timestamp of when the registry was created.
      */
-    createdAt?: pulumi.Input<string>;
+    createdAt?: pulumi.Input<string | undefined>;
     /**
      * Prefix prepended to pushed image names, for example an organization or namespace.
      */
-    imagePrefix?: pulumi.Input<string>;
+    imagePrefix?: pulumi.Input<string | undefined>;
     /**
      * Password or access token used to authenticate.
      */
-    password?: pulumi.Input<string>;
+    password?: pulumi.Input<string | undefined>;
     /**
      * Display name of the registry.
      */
-    registryName?: pulumi.Input<string>;
+    registryName?: pulumi.Input<string | undefined>;
     /**
      * Registry kind. Dokploy currently accepts only `cloud`. Valid values: `cloud`. Defaults to `cloud`.
      */
-    registryType?: pulumi.Input<string>;
+    registryType?: pulumi.Input<string | undefined>;
     /**
      * Registry hostname, for example `ghcr.io`.
      */
-    registryUrl?: pulumi.Input<string>;
+    registryUrl?: pulumi.Input<string | undefined>;
     /**
      * Server this registry is scoped to.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
     /**
      * Username used to authenticate to the registry.
      */
-    username?: pulumi.Input<string>;
+    username?: pulumi.Input<string | undefined>;
 }
 
 /**
@@ -161,7 +164,7 @@ export interface RegistryArgs {
     /**
      * Prefix prepended to pushed image names, for example an organization or namespace.
      */
-    imagePrefix?: pulumi.Input<string>;
+    imagePrefix?: pulumi.Input<string | undefined>;
     /**
      * Password or access token used to authenticate.
      */
@@ -173,7 +176,7 @@ export interface RegistryArgs {
     /**
      * Registry kind. Dokploy currently accepts only `cloud`. Valid values: `cloud`. Defaults to `cloud`.
      */
-    registryType?: pulumi.Input<string>;
+    registryType?: pulumi.Input<string | undefined>;
     /**
      * Registry hostname, for example `ghcr.io`.
      */
@@ -181,7 +184,7 @@ export interface RegistryArgs {
     /**
      * Server this registry is scoped to.
      */
-    serverId?: pulumi.Input<string>;
+    serverId?: pulumi.Input<string | undefined>;
     /**
      * Username used to authenticate to the registry.
      */

sdk/nodejs/schedule.ts

@@ -0,0 +1,291 @@
+// *** 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 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.
+ */
+export class Schedule extends pulumi.CustomResource {
+    /**
+     * Get an existing Schedule 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?: ScheduleState, opts?: pulumi.CustomResourceOptions): Schedule {
+        return new Schedule(name, <any>state, { ...opts, id: id });
+    }
+
+    /** @internal */
+    public static readonly __pulumiType = 'dokploy:index/schedule:Schedule';
+
+    /**
+     * Returns true if the given object is an instance of Schedule.  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 Schedule {
+        if (obj === undefined || obj === null) {
+            return false;
+        }
+        return obj['__pulumiType'] === Schedule.__pulumiType;
+    }
+
+    /**
+     * Docker service name the schedule targets. Derived by Dokploy when omitted.
+     */
+    declare public readonly appName: pulumi.Output<string>;
+    /**
+     * Application this schedule belongs to.
+     */
+    declare public readonly applicationId: pulumi.Output<string | undefined>;
+    /**
+     * Command to run.
+     */
+    declare public readonly command: pulumi.Output<string>;
+    /**
+     * Compose stack this schedule belongs to.
+     */
+    declare public readonly composeId: pulumi.Output<string | undefined>;
+    /**
+     * RFC 3339 timestamp of when the schedule was created.
+     */
+    declare public /*out*/ readonly createdAt: pulumi.Output<string>;
+    /**
+     * Standard five-field cron expression, for example `0 3 * * *`.
+     */
+    declare public readonly cronExpression: pulumi.Output<string>;
+    /**
+     * Free-form description.
+     */
+    declare public readonly description: pulumi.Output<string | undefined>;
+    /**
+     * Whether the schedule is active.
+     */
+    declare public readonly enabled: pulumi.Output<boolean>;
+    /**
+     * Display name of the schedule.
+     */
+    declare public readonly name: pulumi.Output<string>;
+    /**
+     * Where the command runs. Valid values: `application`, `compose`, `server`, `dokploy-server`. Defaults to `application`.
+     */
+    declare public readonly scheduleType: pulumi.Output<string>;
+    /**
+     * Multi-line script to run instead of a single command.
+     */
+    declare public readonly script: pulumi.Output<string | undefined>;
+    /**
+     * Server this schedule runs on.
+     */
+    declare public readonly serverId: pulumi.Output<string | undefined>;
+    /**
+     * Service inside a Compose stack to run the command in.
+     */
+    declare public readonly serviceName: pulumi.Output<string | undefined>;
+    /**
+     * Shell used to interpret the command. Valid values: `bash`, `sh`. Defaults to `bash`.
+     */
+    declare public readonly shellType: pulumi.Output<string>;
+    /**
+     * IANA timezone the cron expression is evaluated in, for example `Europe/Berlin`.
+     */
+    declare public readonly timezone: pulumi.Output<string | undefined>;
+
+    /**
+     * Create a Schedule 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: ScheduleArgs, opts?: pulumi.CustomResourceOptions)
+    constructor(name: string, argsOrState?: ScheduleArgs | ScheduleState, opts?: pulumi.CustomResourceOptions) {
+        let resourceInputs: pulumi.Inputs = {};
+        opts = opts || {};
+        if (opts.id) {
+            const state = argsOrState as ScheduleState | undefined;
+            resourceInputs["appName"] = state?.appName;
+            resourceInputs["applicationId"] = state?.applicationId;
+            resourceInputs["command"] = state?.command;
+            resourceInputs["composeId"] = state?.composeId;
+            resourceInputs["createdAt"] = state?.createdAt;
+            resourceInputs["cronExpression"] = state?.cronExpression;
+            resourceInputs["description"] = state?.description;
+            resourceInputs["enabled"] = state?.enabled;
+            resourceInputs["name"] = state?.name;
+            resourceInputs["scheduleType"] = state?.scheduleType;
+            resourceInputs["script"] = state?.script;
+            resourceInputs["serverId"] = state?.serverId;
+            resourceInputs["serviceName"] = state?.serviceName;
+            resourceInputs["shellType"] = state?.shellType;
+            resourceInputs["timezone"] = state?.timezone;
+        } else {
+            const args = argsOrState as ScheduleArgs | undefined;
+            if (args?.command === undefined && !opts.urn) {
+                throw new Error("Missing required property 'command'");
+            }
+            if (args?.cronExpression === undefined && !opts.urn) {
+                throw new Error("Missing required property 'cronExpression'");
+            }
+            resourceInputs["appName"] = args?.appName;
+            resourceInputs["applicationId"] = args?.applicationId;
+            resourceInputs["command"] = args?.command;
+            resourceInputs["composeId"] = args?.composeId;
+            resourceInputs["cronExpression"] = args?.cronExpression;
+            resourceInputs["description"] = args?.description;
+            resourceInputs["enabled"] = args?.enabled;
+            resourceInputs["name"] = args?.name;
+            resourceInputs["scheduleType"] = args?.scheduleType;
+            resourceInputs["script"] = args?.script;
+            resourceInputs["serverId"] = args?.serverId;
+            resourceInputs["serviceName"] = args?.serviceName;
+            resourceInputs["shellType"] = args?.shellType;
+            resourceInputs["timezone"] = args?.timezone;
+            resourceInputs["createdAt"] = undefined /*out*/;
+        }
+        opts = pulumi.mergeOptions(utilities.resourceOptsDefaults(), opts);
+        super(Schedule.__pulumiType, name, resourceInputs, opts);
+    }
+}
+
+/**
+ * Input properties used for looking up and filtering Schedule resources.
+ */
+export interface ScheduleState {
+    /**
+     * Docker service name the schedule targets. Derived by Dokploy when omitted.
+     */
+    appName?: pulumi.Input<string | undefined>;
+    /**
+     * Application this schedule belongs to.
+     */
+    applicationId?: pulumi.Input<string | undefined>;
+    /**
+     * Command to run.
+     */
+    command?: pulumi.Input<string | undefined>;
+    /**
+     * Compose stack this schedule belongs to.
+     */
+    composeId?: pulumi.Input<string | undefined>;
+    /**
+     * RFC 3339 timestamp of when the schedule was created.
+     */
+    createdAt?: pulumi.Input<string | undefined>;
+    /**
+     * Standard five-field cron expression, for example `0 3 * * *`.
+     */
+    cronExpression?: pulumi.Input<string | undefined>;
+    /**
+     * Free-form description.
+     */
+    description?: pulumi.Input<string | undefined>;
+    /**
+     * Whether the schedule is active.
+     */
+    enabled?: pulumi.Input<boolean | undefined>;
+    /**
+     * Display name of the schedule.
+     */
+    name?: pulumi.Input<string | undefined>;
+    /**
+     * Where the command runs. Valid values: `application`, `compose`, `server`, `dokploy-server`. Defaults to `application`.
+     */
+    scheduleType?: pulumi.Input<string | undefined>;
+    /**
+     * Multi-line script to run instead of a single command.
+     */
+    script?: pulumi.Input<string | undefined>;
+    /**
+     * Server this schedule runs on.
+     */
+    serverId?: pulumi.Input<string | undefined>;
+    /**
+     * Service inside a Compose stack to run the command in.
+     */
+    serviceName?: pulumi.Input<string | undefined>;
+    /**
+     * Shell used to interpret the command. Valid values: `bash`, `sh`. Defaults to `bash`.
+     */
+    shellType?: pulumi.Input<string | undefined>;
+    /**
+     * IANA timezone the cron expression is evaluated in, for example `Europe/Berlin`.
+     */
+    timezone?: pulumi.Input<string | undefined>;
+}
+
+/**
+ * The set of arguments for constructing a Schedule resource.
+ */
+export interface ScheduleArgs {
+    /**
+     * Docker service name the schedule targets. Derived by Dokploy when omitted.
+     */
+    appName?: pulumi.Input<string | undefined>;
+    /**
+     * Application this schedule belongs to.
+     */
+    applicationId?: pulumi.Input<string | undefined>;
+    /**
+     * Command to run.
+     */
+    command: pulumi.Input<string>;
+    /**
+     * Compose stack this schedule belongs to.
+     */
+    composeId?: pulumi.Input<string | undefined>;
+    /**
+     * Standard five-field cron expression, for example `0 3 * * *`.
+     */
+    cronExpression: pulumi.Input<string>;
+    /**
+     * Free-form description.
+     */
+    description?: pulumi.Input<string | undefined>;
+    /**
+     * Whether the schedule is active.
+     */
+    enabled?: pulumi.Input<boolean | undefined>;
+    /**
+     * Display name of the schedule.
+     */
+    name?: pulumi.Input<string | undefined>;
+    /**
+     * Where the command runs. Valid values: `application`, `compose`, `server`, `dokploy-server`. Defaults to `application`.
+     */
+    scheduleType?: pulumi.Input<string | undefined>;
+    /**
+     * Multi-line script to run instead of a single command.
+     */
+    script?: pulumi.Input<string | undefined>;
+    /**
+     * Server this schedule runs on.
+     */
+    serverId?: pulumi.Input<string | undefined>;
+    /**
+     * Service inside a Compose stack to run the command in.
+     */
+    serviceName?: pulumi.Input<string | undefined>;
+    /**
+     * Shell used to interpret the command. Valid values: `bash`, `sh`. Defaults to `bash`.
+     */
+    shellType?: pulumi.Input<string | undefined>;
+    /**
+     * IANA timezone the cron expression is evaluated in, for example `Europe/Berlin`.
+     */
+    timezone?: pulumi.Input<string | undefined>;
+}

sdk/nodejs/security.ts

@@ -4,6 +4,11 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * 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.
+ */
 export class Security extends pulumi.CustomResource {
     /**
      * Get an existing Security resource's state with the given name, ID, and optional extra
@@ -96,19 +101,19 @@ export interface SecurityState {
     /**
      * Application these credentials protect.
      */
-    applicationId?: pulumi.Input<string>;
+    applicationId?: pulumi.Input<string | undefined>;
     /**
      * RFC 3339 timestamp of when the credentials were created.
      */
-    createdAt?: pulumi.Input<string>;
+    createdAt?: pulumi.Input<string | undefined>;
     /**
      * Basic auth password.
      */
-    password?: pulumi.Input<string>;
+    password?: pulumi.Input<string | undefined>;
     /**
      * Basic auth username.
      */
-    username?: pulumi.Input<string>;
+    username?: pulumi.Input<string | undefined>;
 }
 
 /**

sdk/nodejs/sshKey.ts

@@ -4,6 +4,13 @@
 import * as pulumi from "@pulumi/pulumi";
 import * as utilities from "./utilities";
 
+/**
+ * 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.
+ */
 export class SshKey extends pulumi.CustomResource {
     /**
      * Get an existing SshKey resource's state with the given name, ID, and optional extra
@@ -105,27 +112,27 @@ export interface SshKeyState {
     /**
      * RFC 3339 timestamp of when the key was created.
      */
-    createdAt?: pulumi.Input<string>;
+    createdAt?: pulumi.Input<string | undefined>;
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * RFC 3339 timestamp of when the key was last used, if ever.
      */
-    lastUsedAt?: pulumi.Input<string>;
+    lastUsedAt?: pulumi.Input<string | undefined>;
     /**
      * Display name of the key pair.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * PEM-encoded private key.
      */
-    privateKey?: pulumi.Input<string>;
+    privateKey?: pulumi.Input<string | undefined>;
     /**
      * OpenSSH-formatted public key.
      */
-    publicKey?: pulumi.Input<string>;
+    publicKey?: pulumi.Input<string | undefined>;
 }
 
 /**
@@ -135,11 +142,11 @@ export interface SshKeyArgs {
     /**
      * Free-form description.
      */
-    description?: pulumi.Input<string>;
+    description?: pulumi.Input<string | undefined>;
     /**
      * Display name of the key pair.
      */
-    name?: pulumi.Input<string>;
+    name?: pulumi.Input<string | undefined>;
     /**
      * PEM-encoded private key.
      */