pulumi-docker 4.8.0a1750226298__py3-none-any.whl → 4.8.1__py3-none-any.whl

pulumi_docker/outputs.py

@@ -2,8 +2,7 @@
 # *** WARNING: this file was generated by pulumi-language-python. ***
 # *** Do not edit by hand unless you're certain you know what you are doing! ***
 
-import builtins
-import copy
+import builtins as _builtins
 import warnings
 import sys
 import pulumi
@@ -18,6 +17,12 @@ from . import outputs
 from ._enums import *
 
 __all__ = [
+    'BuildxBuilderDockerContainer',
+    'BuildxBuilderKubernetes',
+    'BuildxBuilderKubernetesLimits',
+    'BuildxBuilderKubernetesQemu',
+    'BuildxBuilderKubernetesRequests',
+    'BuildxBuilderRemote',
     'ContainerCapabilities',
     'ContainerDevice',
     'ContainerHealthcheck',
@@ -83,31 +88,678 @@ __all__ = [
     'GetRegistryImageManifestsManifestResult',
 ]
 
+@pulumi.output_type
+class BuildxBuilderDockerContainer(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "cgroupParent":
+            suggest = "cgroup_parent"
+        elif key == "cpuPeriod":
+            suggest = "cpu_period"
+        elif key == "cpuQuota":
+            suggest = "cpu_quota"
+        elif key == "cpuShares":
+            suggest = "cpu_shares"
+        elif key == "cpusetCpus":
+            suggest = "cpuset_cpus"
+        elif key == "cpusetMems":
+            suggest = "cpuset_mems"
+        elif key == "defaultLoad":
+            suggest = "default_load"
+        elif key == "memorySwap":
+            suggest = "memory_swap"
+        elif key == "restartPolicy":
+            suggest = "restart_policy"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BuildxBuilderDockerContainer. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BuildxBuilderDockerContainer.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BuildxBuilderDockerContainer.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 cgroup_parent: Optional[_builtins.str] = None,
+                 cpu_period: Optional[_builtins.str] = None,
+                 cpu_quota: Optional[_builtins.str] = None,
+                 cpu_shares: Optional[_builtins.str] = None,
+                 cpuset_cpus: Optional[_builtins.str] = None,
+                 cpuset_mems: Optional[_builtins.str] = None,
+                 default_load: Optional[_builtins.bool] = None,
+                 env: Optional[Mapping[str, _builtins.str]] = None,
+                 image: Optional[_builtins.str] = None,
+                 memory: Optional[_builtins.str] = None,
+                 memory_swap: Optional[_builtins.str] = None,
+                 network: Optional[_builtins.str] = None,
+                 restart_policy: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str cgroup_parent: Sets the cgroup parent of the container if Docker is using the "cgroupfs" driver.
+        :param _builtins.str cpu_period: Sets the CPU CFS scheduler period for the container.
+        :param _builtins.str cpu_quota: Imposes a CPU CFS quota on the container.
+        :param _builtins.str cpu_shares: Configures CPU shares (relative weight) of the container.
+        :param _builtins.str cpuset_cpus: Limits the set of CPU cores the container can use.
+        :param _builtins.str cpuset_mems: Limits the set of CPU memory nodes the container can use.
+        :param _builtins.bool default_load: Automatically load images to the Docker Engine image store. Defaults to `false`
+        :param Mapping[str, _builtins.str] env: Sets environment variables in the container.
+        :param _builtins.str image: Sets the BuildKit image to use for the container.
+        :param _builtins.str memory: Sets the amount of memory the container can use.
+        :param _builtins.str memory_swap: Sets the memory swap limit for the container.
+        :param _builtins.str network: Sets the network mode for the container.
+        :param _builtins.str restart_policy: Sets the container's restart policy.
+        """
+        if cgroup_parent is not None:
+            pulumi.set(__self__, "cgroup_parent", cgroup_parent)
+        if cpu_period is not None:
+            pulumi.set(__self__, "cpu_period", cpu_period)
+        if cpu_quota is not None:
+            pulumi.set(__self__, "cpu_quota", cpu_quota)
+        if cpu_shares is not None:
+            pulumi.set(__self__, "cpu_shares", cpu_shares)
+        if cpuset_cpus is not None:
+            pulumi.set(__self__, "cpuset_cpus", cpuset_cpus)
+        if cpuset_mems is not None:
+            pulumi.set(__self__, "cpuset_mems", cpuset_mems)
+        if default_load is not None:
+            pulumi.set(__self__, "default_load", default_load)
+        if env is not None:
+            pulumi.set(__self__, "env", env)
+        if image is not None:
+            pulumi.set(__self__, "image", image)
+        if memory is not None:
+            pulumi.set(__self__, "memory", memory)
+        if memory_swap is not None:
+            pulumi.set(__self__, "memory_swap", memory_swap)
+        if network is not None:
+            pulumi.set(__self__, "network", network)
+        if restart_policy is not None:
+            pulumi.set(__self__, "restart_policy", restart_policy)
+
+    @_builtins.property
+    @pulumi.getter(name="cgroupParent")
+    def cgroup_parent(self) -> Optional[_builtins.str]:
+        """
+        Sets the cgroup parent of the container if Docker is using the "cgroupfs" driver.
+        """
+        return pulumi.get(self, "cgroup_parent")
+
+    @_builtins.property
+    @pulumi.getter(name="cpuPeriod")
+    def cpu_period(self) -> Optional[_builtins.str]:
+        """
+        Sets the CPU CFS scheduler period for the container.
+        """
+        return pulumi.get(self, "cpu_period")
+
+    @_builtins.property
+    @pulumi.getter(name="cpuQuota")
+    def cpu_quota(self) -> Optional[_builtins.str]:
+        """
+        Imposes a CPU CFS quota on the container.
+        """
+        return pulumi.get(self, "cpu_quota")
+
+    @_builtins.property
+    @pulumi.getter(name="cpuShares")
+    def cpu_shares(self) -> Optional[_builtins.str]:
+        """
+        Configures CPU shares (relative weight) of the container.
+        """
+        return pulumi.get(self, "cpu_shares")
+
+    @_builtins.property
+    @pulumi.getter(name="cpusetCpus")
+    def cpuset_cpus(self) -> Optional[_builtins.str]:
+        """
+        Limits the set of CPU cores the container can use.
+        """
+        return pulumi.get(self, "cpuset_cpus")
+
+    @_builtins.property
+    @pulumi.getter(name="cpusetMems")
+    def cpuset_mems(self) -> Optional[_builtins.str]:
+        """
+        Limits the set of CPU memory nodes the container can use.
+        """
+        return pulumi.get(self, "cpuset_mems")
+
+    @_builtins.property
+    @pulumi.getter(name="defaultLoad")
+    def default_load(self) -> Optional[_builtins.bool]:
+        """
+        Automatically load images to the Docker Engine image store. Defaults to `false`
+        """
+        return pulumi.get(self, "default_load")
+
+    @_builtins.property
+    @pulumi.getter
+    def env(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        Sets environment variables in the container.
+        """
+        return pulumi.get(self, "env")
+
+    @_builtins.property
+    @pulumi.getter
+    def image(self) -> Optional[_builtins.str]:
+        """
+        Sets the BuildKit image to use for the container.
+        """
+        return pulumi.get(self, "image")
+
+    @_builtins.property
+    @pulumi.getter
+    def memory(self) -> Optional[_builtins.str]:
+        """
+        Sets the amount of memory the container can use.
+        """
+        return pulumi.get(self, "memory")
+
+    @_builtins.property
+    @pulumi.getter(name="memorySwap")
+    def memory_swap(self) -> Optional[_builtins.str]:
+        """
+        Sets the memory swap limit for the container.
+        """
+        return pulumi.get(self, "memory_swap")
+
+    @_builtins.property
+    @pulumi.getter
+    def network(self) -> Optional[_builtins.str]:
+        """
+        Sets the network mode for the container.
+        """
+        return pulumi.get(self, "network")
+
+    @_builtins.property
+    @pulumi.getter(name="restartPolicy")
+    def restart_policy(self) -> Optional[_builtins.str]:
+        """
+        Sets the container's restart policy.
+        """
+        return pulumi.get(self, "restart_policy")
+
+
+@pulumi.output_type
+class BuildxBuilderKubernetes(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "defaultLoad":
+            suggest = "default_load"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BuildxBuilderKubernetes. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BuildxBuilderKubernetes.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BuildxBuilderKubernetes.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 annotations: Optional[_builtins.str] = None,
+                 default_load: Optional[_builtins.bool] = None,
+                 image: Optional[_builtins.str] = None,
+                 labels: Optional[_builtins.str] = None,
+                 limits: Optional['outputs.BuildxBuilderKubernetesLimits'] = None,
+                 loadbalance: Optional[_builtins.str] = None,
+                 namespace: Optional[_builtins.str] = None,
+                 nodeselector: Optional[_builtins.str] = None,
+                 qemu: Optional['outputs.BuildxBuilderKubernetesQemu'] = None,
+                 replicas: Optional[_builtins.int] = None,
+                 requests: Optional['outputs.BuildxBuilderKubernetesRequests'] = None,
+                 rootless: Optional[_builtins.bool] = None,
+                 schedulername: Optional[_builtins.str] = None,
+                 serviceaccount: Optional[_builtins.str] = None,
+                 timeout: Optional[_builtins.str] = None,
+                 tolerations: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str annotations: Sets additional annotations on the deployments and pods.
+        :param _builtins.bool default_load: Automatically load images to the Docker Engine image store. Defaults to `false`
+        :param _builtins.str image: Sets the image to use for running BuildKit.
+        :param _builtins.str labels: Sets additional labels on the deployments and pods.
+        :param 'BuildxBuilderKubernetesLimitsArgs' limits: Resource limits for CPU, memory, and ephemeral storage.
+        :param _builtins.str loadbalance: Load-balancing strategy (sticky or random).
+        :param _builtins.str namespace: Sets the Kubernetes namespace.
+        :param _builtins.str nodeselector: Sets the pod's nodeSelector label(s).
+        :param 'BuildxBuilderKubernetesQemuArgs' qemu: QEMU emulation configuration.
+        :param _builtins.int replicas: Sets the number of Pod replicas to create.
+        :param 'BuildxBuilderKubernetesRequestsArgs' requests: Resource requests for CPU, memory, and ephemeral storage.
+        :param _builtins.bool rootless: Run the container as a non-root user.
+        :param _builtins.str schedulername: Sets the scheduler responsible for scheduling the pod.
+        :param _builtins.str serviceaccount: Sets the pod's serviceAccountName.
+        :param _builtins.str timeout: Set the timeout limit for pod provisioning.
+        :param _builtins.str tolerations: Configures the pod's taint toleration.
+        """
+        if annotations is not None:
+            pulumi.set(__self__, "annotations", annotations)
+        if default_load is not None:
+            pulumi.set(__self__, "default_load", default_load)
+        if image is not None:
+            pulumi.set(__self__, "image", image)
+        if labels is not None:
+            pulumi.set(__self__, "labels", labels)
+        if limits is not None:
+            pulumi.set(__self__, "limits", limits)
+        if loadbalance is not None:
+            pulumi.set(__self__, "loadbalance", loadbalance)
+        if namespace is not None:
+            pulumi.set(__self__, "namespace", namespace)
+        if nodeselector is not None:
+            pulumi.set(__self__, "nodeselector", nodeselector)
+        if qemu is not None:
+            pulumi.set(__self__, "qemu", qemu)
+        if replicas is not None:
+            pulumi.set(__self__, "replicas", replicas)
+        if requests is not None:
+            pulumi.set(__self__, "requests", requests)
+        if rootless is not None:
+            pulumi.set(__self__, "rootless", rootless)
+        if schedulername is not None:
+            pulumi.set(__self__, "schedulername", schedulername)
+        if serviceaccount is not None:
+            pulumi.set(__self__, "serviceaccount", serviceaccount)
+        if timeout is not None:
+            pulumi.set(__self__, "timeout", timeout)
+        if tolerations is not None:
+            pulumi.set(__self__, "tolerations", tolerations)
+
+    @_builtins.property
+    @pulumi.getter
+    def annotations(self) -> Optional[_builtins.str]:
+        """
+        Sets additional annotations on the deployments and pods.
+        """
+        return pulumi.get(self, "annotations")
+
+    @_builtins.property
+    @pulumi.getter(name="defaultLoad")
+    def default_load(self) -> Optional[_builtins.bool]:
+        """
+        Automatically load images to the Docker Engine image store. Defaults to `false`
+        """
+        return pulumi.get(self, "default_load")
+
+    @_builtins.property
+    @pulumi.getter
+    def image(self) -> Optional[_builtins.str]:
+        """
+        Sets the image to use for running BuildKit.
+        """
+        return pulumi.get(self, "image")
+
+    @_builtins.property
+    @pulumi.getter
+    def labels(self) -> Optional[_builtins.str]:
+        """
+        Sets additional labels on the deployments and pods.
+        """
+        return pulumi.get(self, "labels")
+
+    @_builtins.property
+    @pulumi.getter
+    def limits(self) -> Optional['outputs.BuildxBuilderKubernetesLimits']:
+        """
+        Resource limits for CPU, memory, and ephemeral storage.
+        """
+        return pulumi.get(self, "limits")
+
+    @_builtins.property
+    @pulumi.getter
+    def loadbalance(self) -> Optional[_builtins.str]:
+        """
+        Load-balancing strategy (sticky or random).
+        """
+        return pulumi.get(self, "loadbalance")
+
+    @_builtins.property
+    @pulumi.getter
+    def namespace(self) -> Optional[_builtins.str]:
+        """
+        Sets the Kubernetes namespace.
+        """
+        return pulumi.get(self, "namespace")
+
+    @_builtins.property
+    @pulumi.getter
+    def nodeselector(self) -> Optional[_builtins.str]:
+        """
+        Sets the pod's nodeSelector label(s).
+        """
+        return pulumi.get(self, "nodeselector")
+
+    @_builtins.property
+    @pulumi.getter
+    def qemu(self) -> Optional['outputs.BuildxBuilderKubernetesQemu']:
+        """
+        QEMU emulation configuration.
+        """
+        return pulumi.get(self, "qemu")
+
+    @_builtins.property
+    @pulumi.getter
+    def replicas(self) -> Optional[_builtins.int]:
+        """
+        Sets the number of Pod replicas to create.
+        """
+        return pulumi.get(self, "replicas")
+
+    @_builtins.property
+    @pulumi.getter
+    def requests(self) -> Optional['outputs.BuildxBuilderKubernetesRequests']:
+        """
+        Resource requests for CPU, memory, and ephemeral storage.
+        """
+        return pulumi.get(self, "requests")
+
+    @_builtins.property
+    @pulumi.getter
+    def rootless(self) -> Optional[_builtins.bool]:
+        """
+        Run the container as a non-root user.
+        """
+        return pulumi.get(self, "rootless")
+
+    @_builtins.property
+    @pulumi.getter
+    def schedulername(self) -> Optional[_builtins.str]:
+        """
+        Sets the scheduler responsible for scheduling the pod.
+        """
+        return pulumi.get(self, "schedulername")
+
+    @_builtins.property
+    @pulumi.getter
+    def serviceaccount(self) -> Optional[_builtins.str]:
+        """
+        Sets the pod's serviceAccountName.
+        """
+        return pulumi.get(self, "serviceaccount")
+
+    @_builtins.property
+    @pulumi.getter
+    def timeout(self) -> Optional[_builtins.str]:
+        """
+        Set the timeout limit for pod provisioning.
+        """
+        return pulumi.get(self, "timeout")
+
+    @_builtins.property
+    @pulumi.getter
+    def tolerations(self) -> Optional[_builtins.str]:
+        """
+        Configures the pod's taint toleration.
+        """
+        return pulumi.get(self, "tolerations")
+
+
+@pulumi.output_type
+class BuildxBuilderKubernetesLimits(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "ephemeralStorage":
+            suggest = "ephemeral_storage"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BuildxBuilderKubernetesLimits. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BuildxBuilderKubernetesLimits.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BuildxBuilderKubernetesLimits.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 cpu: Optional[_builtins.str] = None,
+                 ephemeral_storage: Optional[_builtins.str] = None,
+                 memory: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str cpu: CPU limit for the Kubernetes pod.
+        :param _builtins.str ephemeral_storage: Ephemeral storage limit for the Kubernetes pod.
+        :param _builtins.str memory: Memory limit for the Kubernetes pod.
+        """
+        if cpu is not None:
+            pulumi.set(__self__, "cpu", cpu)
+        if ephemeral_storage is not None:
+            pulumi.set(__self__, "ephemeral_storage", ephemeral_storage)
+        if memory is not None:
+            pulumi.set(__self__, "memory", memory)
+
+    @_builtins.property
+    @pulumi.getter
+    def cpu(self) -> Optional[_builtins.str]:
+        """
+        CPU limit for the Kubernetes pod.
+        """
+        return pulumi.get(self, "cpu")
+
+    @_builtins.property
+    @pulumi.getter(name="ephemeralStorage")
+    def ephemeral_storage(self) -> Optional[_builtins.str]:
+        """
+        Ephemeral storage limit for the Kubernetes pod.
+        """
+        return pulumi.get(self, "ephemeral_storage")
+
+    @_builtins.property
+    @pulumi.getter
+    def memory(self) -> Optional[_builtins.str]:
+        """
+        Memory limit for the Kubernetes pod.
+        """
+        return pulumi.get(self, "memory")
+
+
+@pulumi.output_type
+class BuildxBuilderKubernetesQemu(dict):
+    def __init__(__self__, *,
+                 image: Optional[_builtins.str] = None,
+                 install: Optional[_builtins.bool] = None):
+        """
+        :param _builtins.str image: Sets the QEMU emulation image.
+        :param _builtins.bool install: Install QEMU emulation for multi-platform support.
+        """
+        if image is not None:
+            pulumi.set(__self__, "image", image)
+        if install is not None:
+            pulumi.set(__self__, "install", install)
+
+    @_builtins.property
+    @pulumi.getter
+    def image(self) -> Optional[_builtins.str]:
+        """
+        Sets the QEMU emulation image.
+        """
+        return pulumi.get(self, "image")
+
+    @_builtins.property
+    @pulumi.getter
+    def install(self) -> Optional[_builtins.bool]:
+        """
+        Install QEMU emulation for multi-platform support.
+        """
+        return pulumi.get(self, "install")
+
+
+@pulumi.output_type
+class BuildxBuilderKubernetesRequests(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "ephemeralStorage":
+            suggest = "ephemeral_storage"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BuildxBuilderKubernetesRequests. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BuildxBuilderKubernetesRequests.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BuildxBuilderKubernetesRequests.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 cpu: Optional[_builtins.str] = None,
+                 ephemeral_storage: Optional[_builtins.str] = None,
+                 memory: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str cpu: CPU limit for the Kubernetes pod.
+        :param _builtins.str ephemeral_storage: Ephemeral storage limit for the Kubernetes pod.
+        :param _builtins.str memory: Memory limit for the Kubernetes pod.
+        """
+        if cpu is not None:
+            pulumi.set(__self__, "cpu", cpu)
+        if ephemeral_storage is not None:
+            pulumi.set(__self__, "ephemeral_storage", ephemeral_storage)
+        if memory is not None:
+            pulumi.set(__self__, "memory", memory)
+
+    @_builtins.property
+    @pulumi.getter
+    def cpu(self) -> Optional[_builtins.str]:
+        """
+        CPU limit for the Kubernetes pod.
+        """
+        return pulumi.get(self, "cpu")
+
+    @_builtins.property
+    @pulumi.getter(name="ephemeralStorage")
+    def ephemeral_storage(self) -> Optional[_builtins.str]:
+        """
+        Ephemeral storage limit for the Kubernetes pod.
+        """
+        return pulumi.get(self, "ephemeral_storage")
+
+    @_builtins.property
+    @pulumi.getter
+    def memory(self) -> Optional[_builtins.str]:
+        """
+        Memory limit for the Kubernetes pod.
+        """
+        return pulumi.get(self, "memory")
+
+
+@pulumi.output_type
+class BuildxBuilderRemote(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "defaultLoad":
+            suggest = "default_load"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in BuildxBuilderRemote. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        BuildxBuilderRemote.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        BuildxBuilderRemote.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 cacert: Optional[_builtins.str] = None,
+                 cert: Optional[_builtins.str] = None,
+                 default_load: Optional[_builtins.bool] = None,
+                 key: Optional[_builtins.str] = None,
+                 servername: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str cacert: Absolute path to the TLS certificate authority used for validation.
+        :param _builtins.str cert: Absolute path to the TLS client certificate to present to buildkitd.
+        :param _builtins.bool default_load: Automatically load images to the Docker Engine image store. Defaults to `false`
+        :param _builtins.str key: Sets the TLS client key.
+        :param _builtins.str servername: TLS server name used in requests.
+        """
+        if cacert is not None:
+            pulumi.set(__self__, "cacert", cacert)
+        if cert is not None:
+            pulumi.set(__self__, "cert", cert)
+        if default_load is not None:
+            pulumi.set(__self__, "default_load", default_load)
+        if key is not None:
+            pulumi.set(__self__, "key", key)
+        if servername is not None:
+            pulumi.set(__self__, "servername", servername)
+
+    @_builtins.property
+    @pulumi.getter
+    def cacert(self) -> Optional[_builtins.str]:
+        """
+        Absolute path to the TLS certificate authority used for validation.
+        """
+        return pulumi.get(self, "cacert")
+
+    @_builtins.property
+    @pulumi.getter
+    def cert(self) -> Optional[_builtins.str]:
+        """
+        Absolute path to the TLS client certificate to present to buildkitd.
+        """
+        return pulumi.get(self, "cert")
+
+    @_builtins.property
+    @pulumi.getter(name="defaultLoad")
+    def default_load(self) -> Optional[_builtins.bool]:
+        """
+        Automatically load images to the Docker Engine image store. Defaults to `false`
+        """
+        return pulumi.get(self, "default_load")
+
+    @_builtins.property
+    @pulumi.getter
+    def key(self) -> Optional[_builtins.str]:
+        """
+        Sets the TLS client key.
+        """
+        return pulumi.get(self, "key")
+
+    @_builtins.property
+    @pulumi.getter
+    def servername(self) -> Optional[_builtins.str]:
+        """
+        TLS server name used in requests.
+        """
+        return pulumi.get(self, "servername")
+
+
 @pulumi.output_type
 class ContainerCapabilities(dict):
     def __init__(__self__, *,
-                 adds: Optional[Sequence[builtins.str]] = None,
-                 drops: Optional[Sequence[builtins.str]] = None):
+                 adds: Optional[Sequence[_builtins.str]] = None,
+                 drops: Optional[Sequence[_builtins.str]] = None):
         """
-        :param Sequence[builtins.str] adds: List of linux capabilities to add.
-        :param Sequence[builtins.str] drops: List of linux capabilities to drop.
+        :param Sequence[_builtins.str] adds: List of linux capabilities to add.
+        :param Sequence[_builtins.str] drops: List of linux capabilities to drop.
         """
         if adds is not None:
             pulumi.set(__self__, "adds", adds)
         if drops is not None:
             pulumi.set(__self__, "drops", drops)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def adds(self) -> Optional[Sequence[builtins.str]]:
+    def adds(self) -> Optional[Sequence[_builtins.str]]:
         """
         List of linux capabilities to add.
         """
         return pulumi.get(self, "adds")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def drops(self) -> Optional[Sequence[builtins.str]]:
+    def drops(self) -> Optional[Sequence[_builtins.str]]:
         """
         List of linux capabilities to drop.
         """
@@ -136,13 +788,13 @@ class ContainerDevice(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 host_path: builtins.str,
-                 container_path: Optional[builtins.str] = None,
-                 permissions: Optional[builtins.str] = None):
+                 host_path: _builtins.str,
+                 container_path: Optional[_builtins.str] = None,
+                 permissions: Optional[_builtins.str] = None):
         """
-        :param builtins.str host_path: The path on the host where the device is located.
-        :param builtins.str container_path: The path in the container where the device will be bound.
-        :param builtins.str permissions: The cgroup permissions given to the container to access the device. Defaults to `rwm`.
+        :param _builtins.str host_path: The path on the host where the device is located.
+        :param _builtins.str container_path: The path in the container where the device will be bound.
+        :param _builtins.str permissions: The cgroup permissions given to the container to access the device. Defaults to `rwm`.
         """
         pulumi.set(__self__, "host_path", host_path)
         if container_path is not None:
@@ -150,25 +802,25 @@ class ContainerDevice(dict):
         if permissions is not None:
             pulumi.set(__self__, "permissions", permissions)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="hostPath")
-    def host_path(self) -> builtins.str:
+    def host_path(self) -> _builtins.str:
         """
         The path on the host where the device is located.
         """
         return pulumi.get(self, "host_path")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="containerPath")
-    def container_path(self) -> Optional[builtins.str]:
+    def container_path(self) -> Optional[_builtins.str]:
         """
         The path in the container where the device will be bound.
         """
         return pulumi.get(self, "container_path")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def permissions(self) -> Optional[builtins.str]:
+    def permissions(self) -> Optional[_builtins.str]:
         """
         The cgroup permissions given to the container to access the device. Defaults to `rwm`.
         """
@@ -197,19 +849,19 @@ class ContainerHealthcheck(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 tests: Sequence[builtins.str],
-                 interval: Optional[builtins.str] = None,
-                 retries: Optional[builtins.int] = None,
-                 start_interval: Optional[builtins.str] = None,
-                 start_period: Optional[builtins.str] = None,
-                 timeout: Optional[builtins.str] = None):
-        """
-        :param Sequence[builtins.str] tests: Command to run to check health. For example, to run `curl -f localhost/health` set the command to be `["CMD", "curl", "-f", "localhost/health"]`.
-        :param builtins.str interval: Time between running the check (ms|s|m|h). Defaults to `0s`.
-        :param builtins.int retries: Consecutive failures needed to report unhealthy. Defaults to `0`.
-        :param builtins.str start_interval: Interval before the healthcheck starts (ms|s|m|h). Defaults to `0s`.
-        :param builtins.str start_period: Start period for the container to initialize before counting retries towards unstable (ms|s|m|h). Defaults to `0s`.
-        :param builtins.str timeout: Maximum time to allow one check to run (ms|s|m|h). Defaults to `0s`.
+                 tests: Sequence[_builtins.str],
+                 interval: Optional[_builtins.str] = None,
+                 retries: Optional[_builtins.int] = None,
+                 start_interval: Optional[_builtins.str] = None,
+                 start_period: Optional[_builtins.str] = None,
+                 timeout: Optional[_builtins.str] = None):
+        """
+        :param Sequence[_builtins.str] tests: Command to run to check health. For example, to run `curl -f localhost/health` set the command to be `["CMD", "curl", "-f", "localhost/health"]`.
+        :param _builtins.str interval: Time between running the check (ms|s|m|h). Defaults to `0s`.
+        :param _builtins.int retries: Consecutive failures needed to report unhealthy. Defaults to `0`.
+        :param _builtins.str start_interval: Interval before the healthcheck starts (ms|s|m|h). Defaults to `0s`.
+        :param _builtins.str start_period: Start period for the container to initialize before counting retries towards unstable (ms|s|m|h). Defaults to `0s`.
+        :param _builtins.str timeout: Maximum time to allow one check to run (ms|s|m|h). Defaults to `0s`.
         """
         pulumi.set(__self__, "tests", tests)
         if interval is not None:
@@ -223,49 +875,49 @@ class ContainerHealthcheck(dict):
         if timeout is not None:
             pulumi.set(__self__, "timeout", timeout)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def tests(self) -> Sequence[builtins.str]:
+    def tests(self) -> Sequence[_builtins.str]:
         """
         Command to run to check health. For example, to run `curl -f localhost/health` set the command to be `["CMD", "curl", "-f", "localhost/health"]`.
         """
         return pulumi.get(self, "tests")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def interval(self) -> Optional[builtins.str]:
+    def interval(self) -> Optional[_builtins.str]:
         """
         Time between running the check (ms|s|m|h). Defaults to `0s`.
         """
         return pulumi.get(self, "interval")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def retries(self) -> Optional[builtins.int]:
+    def retries(self) -> Optional[_builtins.int]:
         """
         Consecutive failures needed to report unhealthy. Defaults to `0`.
         """
         return pulumi.get(self, "retries")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="startInterval")
-    def start_interval(self) -> Optional[builtins.str]:
+    def start_interval(self) -> Optional[_builtins.str]:
         """
         Interval before the healthcheck starts (ms|s|m|h). Defaults to `0s`.
         """
         return pulumi.get(self, "start_interval")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="startPeriod")
-    def start_period(self) -> Optional[builtins.str]:
+    def start_period(self) -> Optional[_builtins.str]:
         """
         Start period for the container to initialize before counting retries towards unstable (ms|s|m|h). Defaults to `0s`.
         """
         return pulumi.get(self, "start_period")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def timeout(self) -> Optional[builtins.str]:
+    def timeout(self) -> Optional[_builtins.str]:
         """
         Maximum time to allow one check to run (ms|s|m|h). Defaults to `0s`.
         """
@@ -275,26 +927,26 @@ class ContainerHealthcheck(dict):
 @pulumi.output_type
 class ContainerHost(dict):
     def __init__(__self__, *,
-                 host: builtins.str,
-                 ip: builtins.str):
+                 host: _builtins.str,
+                 ip: _builtins.str):
         """
-        :param builtins.str host: Hostname to add
-        :param builtins.str ip: IP address this hostname should resolve to.
+        :param _builtins.str host: Hostname to add
+        :param _builtins.str ip: IP address this hostname should resolve to.
         """
         pulumi.set(__self__, "host", host)
         pulumi.set(__self__, "ip", ip)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def host(self) -> builtins.str:
+    def host(self) -> _builtins.str:
         """
         Hostname to add
         """
         return pulumi.get(self, "host")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def ip(self) -> builtins.str:
+    def ip(self) -> _builtins.str:
         """
         IP address this hostname should resolve to.
         """
@@ -304,26 +956,26 @@ class ContainerHost(dict):
 @pulumi.output_type
 class ContainerLabel(dict):
     def __init__(__self__, *,
-                 label: builtins.str,
-                 value: builtins.str):
+                 label: _builtins.str,
+                 value: _builtins.str):
         """
-        :param builtins.str label: Name of the label
-        :param builtins.str value: Value of the label
+        :param _builtins.str label: Name of the label
+        :param _builtins.str value: Value of the label
         """
         pulumi.set(__self__, "label", label)
         pulumi.set(__self__, "value", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def label(self) -> builtins.str:
+    def label(self) -> _builtins.str:
         """
         Name of the label
         """
         return pulumi.get(self, "label")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> builtins.str:
+    def value(self) -> _builtins.str:
         """
         Value of the label
         """
@@ -356,19 +1008,19 @@ class ContainerMount(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 target: builtins.str,
-                 type: builtins.str,
+                 target: _builtins.str,
+                 type: _builtins.str,
                  bind_options: Optional['outputs.ContainerMountBindOptions'] = None,
-                 read_only: Optional[builtins.bool] = None,
-                 source: Optional[builtins.str] = None,
+                 read_only: Optional[_builtins.bool] = None,
+                 source: Optional[_builtins.str] = None,
                  tmpfs_options: Optional['outputs.ContainerMountTmpfsOptions'] = None,
                  volume_options: Optional['outputs.ContainerMountVolumeOptions'] = None):
         """
-        :param builtins.str target: Container path
-        :param builtins.str type: The mount type
+        :param _builtins.str target: Container path
+        :param _builtins.str type: The mount type
         :param 'ContainerMountBindOptionsArgs' bind_options: Optional configuration for the bind type.
-        :param builtins.bool read_only: Whether the mount should be read-only.
-        :param builtins.str source: Mount source (e.g. a volume name, a host path).
+        :param _builtins.bool read_only: Whether the mount should be read-only.
+        :param _builtins.str source: Mount source (e.g. a volume name, a host path).
         :param 'ContainerMountTmpfsOptionsArgs' tmpfs_options: Optional configuration for the tmpfs type.
         :param 'ContainerMountVolumeOptionsArgs' volume_options: Optional configuration for the volume type.
         """
@@ -385,23 +1037,23 @@ class ContainerMount(dict):
         if volume_options is not None:
             pulumi.set(__self__, "volume_options", volume_options)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def target(self) -> builtins.str:
+    def target(self) -> _builtins.str:
         """
         Container path
         """
         return pulumi.get(self, "target")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> builtins.str:
+    def type(self) -> _builtins.str:
         """
         The mount type
         """
         return pulumi.get(self, "type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="bindOptions")
     def bind_options(self) -> Optional['outputs.ContainerMountBindOptions']:
         """
@@ -409,23 +1061,23 @@ class ContainerMount(dict):
         """
         return pulumi.get(self, "bind_options")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="readOnly")
-    def read_only(self) -> Optional[builtins.bool]:
+    def read_only(self) -> Optional[_builtins.bool]:
         """
         Whether the mount should be read-only.
         """
         return pulumi.get(self, "read_only")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def source(self) -> Optional[builtins.str]:
+    def source(self) -> Optional[_builtins.str]:
         """
         Mount source (e.g. a volume name, a host path).
         """
         return pulumi.get(self, "source")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="tmpfsOptions")
     def tmpfs_options(self) -> Optional['outputs.ContainerMountTmpfsOptions']:
         """
@@ -433,7 +1085,7 @@ class ContainerMount(dict):
         """
         return pulumi.get(self, "tmpfs_options")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="volumeOptions")
     def volume_options(self) -> Optional['outputs.ContainerMountVolumeOptions']:
         """
@@ -445,16 +1097,16 @@ class ContainerMount(dict):
 @pulumi.output_type
 class ContainerMountBindOptions(dict):
     def __init__(__self__, *,
-                 propagation: Optional[builtins.str] = None):
+                 propagation: Optional[_builtins.str] = None):
         """
-        :param builtins.str propagation: A propagation mode with the value.
+        :param _builtins.str propagation: A propagation mode with the value.
         """
         if propagation is not None:
             pulumi.set(__self__, "propagation", propagation)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def propagation(self) -> Optional[builtins.str]:
+    def propagation(self) -> Optional[_builtins.str]:
         """
         A propagation mode with the value.
         """
@@ -481,28 +1133,28 @@ class ContainerMountTmpfsOptions(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 mode: Optional[builtins.int] = None,
-                 size_bytes: Optional[builtins.int] = None):
+                 mode: Optional[_builtins.int] = None,
+                 size_bytes: Optional[_builtins.int] = None):
         """
-        :param builtins.int mode: The permission mode for the tmpfs mount in an integer.
-        :param builtins.int size_bytes: The size for the tmpfs mount in bytes.
+        :param _builtins.int mode: The permission mode for the tmpfs mount in an integer.
+        :param _builtins.int size_bytes: The size for the tmpfs mount in bytes.
         """
         if mode is not None:
             pulumi.set(__self__, "mode", mode)
         if size_bytes is not None:
             pulumi.set(__self__, "size_bytes", size_bytes)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def mode(self) -> Optional[builtins.int]:
+    def mode(self) -> Optional[_builtins.int]:
         """
         The permission mode for the tmpfs mount in an integer.
         """
         return pulumi.get(self, "mode")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="sizeBytes")
-    def size_bytes(self) -> Optional[builtins.int]:
+    def size_bytes(self) -> Optional[_builtins.int]:
         """
         The size for the tmpfs mount in bytes.
         """
@@ -533,17 +1185,17 @@ class ContainerMountVolumeOptions(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 driver_name: Optional[builtins.str] = None,
-                 driver_options: Optional[Mapping[str, builtins.str]] = None,
+                 driver_name: Optional[_builtins.str] = None,
+                 driver_options: Optional[Mapping[str, _builtins.str]] = None,
                  labels: Optional[Sequence['outputs.ContainerMountVolumeOptionsLabel']] = None,
-                 no_copy: Optional[builtins.bool] = None,
-                 subpath: Optional[builtins.str] = None):
+                 no_copy: Optional[_builtins.bool] = None,
+                 subpath: Optional[_builtins.str] = None):
         """
-        :param builtins.str driver_name: Name of the driver to use to create the volume.
-        :param Mapping[str, builtins.str] driver_options: key/value map of driver specific options.
+        :param _builtins.str driver_name: Name of the driver to use to create the volume.
+        :param Mapping[str, _builtins.str] driver_options: key/value map of driver specific options.
         :param Sequence['ContainerMountVolumeOptionsLabelArgs'] labels: User-defined key/value metadata.
-        :param builtins.bool no_copy: Populate volume with data from the target.
-        :param builtins.str subpath: Path within the volume to mount. Requires docker server version 1.45 or higher.
+        :param _builtins.bool no_copy: Populate volume with data from the target.
+        :param _builtins.str subpath: Path within the volume to mount. Requires docker server version 1.45 or higher.
         """
         if driver_name is not None:
             pulumi.set(__self__, "driver_name", driver_name)
@@ -556,23 +1208,23 @@ class ContainerMountVolumeOptions(dict):
         if subpath is not None:
             pulumi.set(__self__, "subpath", subpath)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="driverName")
-    def driver_name(self) -> Optional[builtins.str]:
+    def driver_name(self) -> Optional[_builtins.str]:
         """
         Name of the driver to use to create the volume.
         """
         return pulumi.get(self, "driver_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="driverOptions")
-    def driver_options(self) -> Optional[Mapping[str, builtins.str]]:
+    def driver_options(self) -> Optional[Mapping[str, _builtins.str]]:
         """
         key/value map of driver specific options.
         """
         return pulumi.get(self, "driver_options")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def labels(self) -> Optional[Sequence['outputs.ContainerMountVolumeOptionsLabel']]:
         """
@@ -580,17 +1232,17 @@ class ContainerMountVolumeOptions(dict):
         """
         return pulumi.get(self, "labels")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="noCopy")
-    def no_copy(self) -> Optional[builtins.bool]:
+    def no_copy(self) -> Optional[_builtins.bool]:
         """
         Populate volume with data from the target.
         """
         return pulumi.get(self, "no_copy")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def subpath(self) -> Optional[builtins.str]:
+    def subpath(self) -> Optional[_builtins.str]:
         """
         Path within the volume to mount. Requires docker server version 1.45 or higher.
         """
@@ -600,26 +1252,26 @@ class ContainerMountVolumeOptions(dict):
 @pulumi.output_type
 class ContainerMountVolumeOptionsLabel(dict):
     def __init__(__self__, *,
-                 label: builtins.str,
-                 value: builtins.str):
+                 label: _builtins.str,
+                 value: _builtins.str):
         """
-        :param builtins.str label: Name of the label
-        :param builtins.str value: Value of the label
+        :param _builtins.str label: Name of the label
+        :param _builtins.str value: Value of the label
         """
         pulumi.set(__self__, "label", label)
         pulumi.set(__self__, "value", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def label(self) -> builtins.str:
+    def label(self) -> _builtins.str:
         """
         Name of the label
         """
         return pulumi.get(self, "label")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> builtins.str:
+    def value(self) -> _builtins.str:
         """
         Value of the label
         """
@@ -658,23 +1310,23 @@ class ContainerNetworkData(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 gateway: Optional[builtins.str] = None,
-                 global_ipv6_address: Optional[builtins.str] = None,
-                 global_ipv6_prefix_length: Optional[builtins.int] = None,
-                 ip_address: Optional[builtins.str] = None,
-                 ip_prefix_length: Optional[builtins.int] = None,
-                 ipv6_gateway: Optional[builtins.str] = None,
-                 mac_address: Optional[builtins.str] = None,
-                 network_name: Optional[builtins.str] = None):
-        """
-        :param builtins.str gateway: The network gateway of the container.
-        :param builtins.str global_ipv6_address: The IPV6 address of the container.
-        :param builtins.int global_ipv6_prefix_length: The IPV6 prefix length address of the container.
-        :param builtins.str ip_address: The IP address of the container.
-        :param builtins.int ip_prefix_length: The IP prefix length of the container.
-        :param builtins.str ipv6_gateway: The IPV6 gateway of the container.
-        :param builtins.str mac_address: The MAC address of the container.
-        :param builtins.str network_name: The name of the network
+                 gateway: Optional[_builtins.str] = None,
+                 global_ipv6_address: Optional[_builtins.str] = None,
+                 global_ipv6_prefix_length: Optional[_builtins.int] = None,
+                 ip_address: Optional[_builtins.str] = None,
+                 ip_prefix_length: Optional[_builtins.int] = None,
+                 ipv6_gateway: Optional[_builtins.str] = None,
+                 mac_address: Optional[_builtins.str] = None,
+                 network_name: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str gateway: The network gateway of the container.
+        :param _builtins.str global_ipv6_address: The IPV6 address of the container.
+        :param _builtins.int global_ipv6_prefix_length: The IPV6 prefix length address of the container.
+        :param _builtins.str ip_address: The IP address of the container.
+        :param _builtins.int ip_prefix_length: The IP prefix length of the container.
+        :param _builtins.str ipv6_gateway: The IPV6 gateway of the container.
+        :param _builtins.str mac_address: The MAC address of the container.
+        :param _builtins.str network_name: The name of the network
         """
         if gateway is not None:
             pulumi.set(__self__, "gateway", gateway)
@@ -693,65 +1345,65 @@ class ContainerNetworkData(dict):
         if network_name is not None:
             pulumi.set(__self__, "network_name", network_name)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def gateway(self) -> Optional[builtins.str]:
+    def gateway(self) -> Optional[_builtins.str]:
         """
         The network gateway of the container.
         """
         return pulumi.get(self, "gateway")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="globalIpv6Address")
-    def global_ipv6_address(self) -> Optional[builtins.str]:
+    def global_ipv6_address(self) -> Optional[_builtins.str]:
         """
         The IPV6 address of the container.
         """
         return pulumi.get(self, "global_ipv6_address")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="globalIpv6PrefixLength")
-    def global_ipv6_prefix_length(self) -> Optional[builtins.int]:
+    def global_ipv6_prefix_length(self) -> Optional[_builtins.int]:
         """
         The IPV6 prefix length address of the container.
         """
         return pulumi.get(self, "global_ipv6_prefix_length")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipAddress")
-    def ip_address(self) -> Optional[builtins.str]:
+    def ip_address(self) -> Optional[_builtins.str]:
         """
         The IP address of the container.
         """
         return pulumi.get(self, "ip_address")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipPrefixLength")
-    def ip_prefix_length(self) -> Optional[builtins.int]:
+    def ip_prefix_length(self) -> Optional[_builtins.int]:
         """
         The IP prefix length of the container.
         """
         return pulumi.get(self, "ip_prefix_length")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipv6Gateway")
-    def ipv6_gateway(self) -> Optional[builtins.str]:
+    def ipv6_gateway(self) -> Optional[_builtins.str]:
         """
         The IPV6 gateway of the container.
         """
         return pulumi.get(self, "ipv6_gateway")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="macAddress")
-    def mac_address(self) -> Optional[builtins.str]:
+    def mac_address(self) -> Optional[_builtins.str]:
         """
         The MAC address of the container.
         """
         return pulumi.get(self, "mac_address")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="networkName")
-    def network_name(self) -> Optional[builtins.str]:
+    def network_name(self) -> Optional[_builtins.str]:
         """
         The name of the network
         """
@@ -780,15 +1432,15 @@ class ContainerNetworksAdvanced(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 name: builtins.str,
-                 aliases: Optional[Sequence[builtins.str]] = None,
-                 ipv4_address: Optional[builtins.str] = None,
-                 ipv6_address: Optional[builtins.str] = None):
+                 name: _builtins.str,
+                 aliases: Optional[Sequence[_builtins.str]] = None,
+                 ipv4_address: Optional[_builtins.str] = None,
+                 ipv6_address: Optional[_builtins.str] = None):
         """
-        :param builtins.str name: The name or id of the network to use. You can use `name` or `id` attribute from a `Network` resource.
-        :param Sequence[builtins.str] aliases: The network aliases of the container in the specific network.
-        :param builtins.str ipv4_address: The IPV4 address of the container in the specific network.
-        :param builtins.str ipv6_address: The IPV6 address of the container in the specific network.
+        :param _builtins.str name: The name or id of the network to use. You can use `name` or `id` attribute from a `Network` resource.
+        :param Sequence[_builtins.str] aliases: The network aliases of the container in the specific network.
+        :param _builtins.str ipv4_address: The IPV4 address of the container in the specific network.
+        :param _builtins.str ipv6_address: The IPV6 address of the container in the specific network.
         """
         pulumi.set(__self__, "name", name)
         if aliases is not None:
@@ -798,33 +1450,33 @@ class ContainerNetworksAdvanced(dict):
         if ipv6_address is not None:
             pulumi.set(__self__, "ipv6_address", ipv6_address)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         The name or id of the network to use. You can use `name` or `id` attribute from a `Network` resource.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def aliases(self) -> Optional[Sequence[builtins.str]]:
+    def aliases(self) -> Optional[Sequence[_builtins.str]]:
         """
         The network aliases of the container in the specific network.
         """
         return pulumi.get(self, "aliases")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipv4Address")
-    def ipv4_address(self) -> Optional[builtins.str]:
+    def ipv4_address(self) -> Optional[_builtins.str]:
         """
         The IPV4 address of the container in the specific network.
         """
         return pulumi.get(self, "ipv4_address")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipv6Address")
-    def ipv6_address(self) -> Optional[builtins.str]:
+    def ipv6_address(self) -> Optional[_builtins.str]:
         """
         The IPV6 address of the container in the specific network.
         """
@@ -834,15 +1486,15 @@ class ContainerNetworksAdvanced(dict):
 @pulumi.output_type
 class ContainerPort(dict):
     def __init__(__self__, *,
-                 internal: builtins.int,
-                 external: Optional[builtins.int] = None,
-                 ip: Optional[builtins.str] = None,
-                 protocol: Optional[builtins.str] = None):
+                 internal: _builtins.int,
+                 external: Optional[_builtins.int] = None,
+                 ip: Optional[_builtins.str] = None,
+                 protocol: Optional[_builtins.str] = None):
         """
-        :param builtins.int internal: Port within the container.
-        :param builtins.int external: Port exposed out of the container. If not given a free random port `>= 32768` will be used.
-        :param builtins.str ip: IP address/mask that can access this port. Defaults to `0.0.0.0`.
-        :param builtins.str protocol: Protocol that can be used over this port. Defaults to `tcp`.
+        :param _builtins.int internal: Port within the container.
+        :param _builtins.int external: Port exposed out of the container. If not given a free random port `>= 32768` will be used.
+        :param _builtins.str ip: IP address/mask that can access this port. Defaults to `0.0.0.0`.
+        :param _builtins.str protocol: Protocol that can be used over this port. Defaults to `tcp`.
         """
         pulumi.set(__self__, "internal", internal)
         if external is not None:
@@ -852,33 +1504,33 @@ class ContainerPort(dict):
         if protocol is not None:
             pulumi.set(__self__, "protocol", protocol)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def internal(self) -> builtins.int:
+    def internal(self) -> _builtins.int:
         """
         Port within the container.
         """
         return pulumi.get(self, "internal")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def external(self) -> Optional[builtins.int]:
+    def external(self) -> Optional[_builtins.int]:
         """
         Port exposed out of the container. If not given a free random port `>= 32768` will be used.
         """
         return pulumi.get(self, "external")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def ip(self) -> Optional[builtins.str]:
+    def ip(self) -> Optional[_builtins.str]:
         """
         IP address/mask that can access this port. Defaults to `0.0.0.0`.
         """
         return pulumi.get(self, "ip")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def protocol(self) -> Optional[builtins.str]:
+    def protocol(self) -> Optional[_builtins.str]:
         """
         Protocol that can be used over this port. Defaults to `tcp`.
         """
@@ -888,37 +1540,37 @@ class ContainerPort(dict):
 @pulumi.output_type
 class ContainerUlimit(dict):
     def __init__(__self__, *,
-                 hard: builtins.int,
-                 name: builtins.str,
-                 soft: builtins.int):
+                 hard: _builtins.int,
+                 name: _builtins.str,
+                 soft: _builtins.int):
         """
-        :param builtins.int hard: The hard limit
-        :param builtins.str name: The name of the ulimit
-        :param builtins.int soft: The soft limit
+        :param _builtins.int hard: The hard limit
+        :param _builtins.str name: The name of the ulimit
+        :param _builtins.int soft: The soft limit
         """
         pulumi.set(__self__, "hard", hard)
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "soft", soft)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def hard(self) -> builtins.int:
+    def hard(self) -> _builtins.int:
         """
         The hard limit
         """
         return pulumi.get(self, "hard")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         The name of the ulimit
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def soft(self) -> builtins.int:
+    def soft(self) -> _builtins.int:
         """
         The soft limit
         """
@@ -947,21 +1599,21 @@ class ContainerUpload(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 file: builtins.str,
-                 content: Optional[builtins.str] = None,
-                 content_base64: Optional[builtins.str] = None,
-                 executable: Optional[builtins.bool] = None,
-                 permissions: Optional[builtins.str] = None,
-                 source: Optional[builtins.str] = None,
-                 source_hash: Optional[builtins.str] = None):
-        """
-        :param builtins.str file: Path to the file in the container where is upload goes to
-        :param builtins.str content: Literal string value to use as the object content, which will be uploaded as UTF-8-encoded text. Conflicts with `content_base64` & `source`
-        :param builtins.str content_base64: Base64-encoded data that will be decoded and uploaded as raw bytes for the object content. This allows safely uploading non-UTF8 binary data, but is recommended only for larger binary content such as the result of the `base64encode` interpolation function. See here for the reason. Conflicts with `content` & `source`
-        :param builtins.bool executable: If `true`, the file will be uploaded with user executable permission. Defaults to `false`.
-        :param builtins.str permissions: The permission mode for the file in the container. Has precedence over `executable`.
-        :param builtins.str source: A filename that references a file which will be uploaded as the object content. This allows for large file uploads that do not get stored in state. Conflicts with `content` & `content_base64`
-        :param builtins.str source_hash: If using `source`, this will force an update if the file content has updated but the filename has not.
+                 file: _builtins.str,
+                 content: Optional[_builtins.str] = None,
+                 content_base64: Optional[_builtins.str] = None,
+                 executable: Optional[_builtins.bool] = None,
+                 permissions: Optional[_builtins.str] = None,
+                 source: Optional[_builtins.str] = None,
+                 source_hash: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str file: Path to the file in the container where is upload goes to
+        :param _builtins.str content: Literal string value to use as the object content, which will be uploaded as UTF-8-encoded text. Conflicts with `content_base64` & `source`
+        :param _builtins.str content_base64: Base64-encoded data that will be decoded and uploaded as raw bytes for the object content. This allows safely uploading non-UTF8 binary data, but is recommended only for larger binary content such as the result of the `base64encode` interpolation function. See here for the reason. Conflicts with `content` & `source`
+        :param _builtins.bool executable: If `true`, the file will be uploaded with user executable permission. Defaults to `false`.
+        :param _builtins.str permissions: The permission mode for the file in the container. Has precedence over `executable`.
+        :param _builtins.str source: A filename that references a file which will be uploaded as the object content. This allows for large file uploads that do not get stored in state. Conflicts with `content` & `content_base64`
+        :param _builtins.str source_hash: If using `source`, this will force an update if the file content has updated but the filename has not.
         """
         pulumi.set(__self__, "file", file)
         if content is not None:
@@ -977,57 +1629,57 @@ class ContainerUpload(dict):
         if source_hash is not None:
             pulumi.set(__self__, "source_hash", source_hash)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def file(self) -> builtins.str:
+    def file(self) -> _builtins.str:
         """
         Path to the file in the container where is upload goes to
         """
         return pulumi.get(self, "file")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def content(self) -> Optional[builtins.str]:
+    def content(self) -> Optional[_builtins.str]:
         """
         Literal string value to use as the object content, which will be uploaded as UTF-8-encoded text. Conflicts with `content_base64` & `source`
         """
         return pulumi.get(self, "content")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="contentBase64")
-    def content_base64(self) -> Optional[builtins.str]:
+    def content_base64(self) -> Optional[_builtins.str]:
         """
         Base64-encoded data that will be decoded and uploaded as raw bytes for the object content. This allows safely uploading non-UTF8 binary data, but is recommended only for larger binary content such as the result of the `base64encode` interpolation function. See here for the reason. Conflicts with `content` & `source`
         """
         return pulumi.get(self, "content_base64")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def executable(self) -> Optional[builtins.bool]:
+    def executable(self) -> Optional[_builtins.bool]:
         """
         If `true`, the file will be uploaded with user executable permission. Defaults to `false`.
         """
         return pulumi.get(self, "executable")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def permissions(self) -> Optional[builtins.str]:
+    def permissions(self) -> Optional[_builtins.str]:
         """
         The permission mode for the file in the container. Has precedence over `executable`.
         """
         return pulumi.get(self, "permissions")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def source(self) -> Optional[builtins.str]:
+    def source(self) -> Optional[_builtins.str]:
         """
         A filename that references a file which will be uploaded as the object content. This allows for large file uploads that do not get stored in state. Conflicts with `content` & `content_base64`
         """
         return pulumi.get(self, "source")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="sourceHash")
-    def source_hash(self) -> Optional[builtins.str]:
+    def source_hash(self) -> Optional[_builtins.str]:
         """
         If using `source`, this will force an update if the file content has updated but the filename has not.
         """
@@ -1062,17 +1714,17 @@ class ContainerVolume(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 container_path: Optional[builtins.str] = None,
-                 from_container: Optional[builtins.str] = None,
-                 host_path: Optional[builtins.str] = None,
-                 read_only: Optional[builtins.bool] = None,
-                 volume_name: Optional[builtins.str] = None):
-        """
-        :param builtins.str container_path: The path in the container where the volume will be mounted.
-        :param builtins.str from_container: The container where the volume is coming from.
-        :param builtins.str host_path: The path on the host where the volume is coming from.
-        :param builtins.bool read_only: If `true`, this volume will be readonly. Defaults to `false`.
-        :param builtins.str volume_name: The name of the docker volume which should be mounted.
+                 container_path: Optional[_builtins.str] = None,
+                 from_container: Optional[_builtins.str] = None,
+                 host_path: Optional[_builtins.str] = None,
+                 read_only: Optional[_builtins.bool] = None,
+                 volume_name: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str container_path: The path in the container where the volume will be mounted.
+        :param _builtins.str from_container: The container where the volume is coming from.
+        :param _builtins.str host_path: The path on the host where the volume is coming from.
+        :param _builtins.bool read_only: If `true`, this volume will be readonly. Defaults to `false`.
+        :param _builtins.str volume_name: The name of the docker volume which should be mounted.
         """
         if container_path is not None:
             pulumi.set(__self__, "container_path", container_path)
@@ -1085,41 +1737,41 @@ class ContainerVolume(dict):
         if volume_name is not None:
             pulumi.set(__self__, "volume_name", volume_name)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="containerPath")
-    def container_path(self) -> Optional[builtins.str]:
+    def container_path(self) -> Optional[_builtins.str]:
         """
         The path in the container where the volume will be mounted.
         """
         return pulumi.get(self, "container_path")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="fromContainer")
-    def from_container(self) -> Optional[builtins.str]:
+    def from_container(self) -> Optional[_builtins.str]:
         """
         The container where the volume is coming from.
         """
         return pulumi.get(self, "from_container")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="hostPath")
-    def host_path(self) -> Optional[builtins.str]:
+    def host_path(self) -> Optional[_builtins.str]:
         """
         The path on the host where the volume is coming from.
         """
         return pulumi.get(self, "host_path")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="readOnly")
-    def read_only(self) -> Optional[builtins.bool]:
+    def read_only(self) -> Optional[_builtins.bool]:
         """
         If `true`, this volume will be readonly. Defaults to `false`.
         """
         return pulumi.get(self, "read_only")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="volumeName")
-    def volume_name(self) -> Optional[builtins.str]:
+    def volume_name(self) -> Optional[_builtins.str]:
         """
         The name of the docker volume which should be mounted.
         """
@@ -1148,15 +1800,15 @@ class NetworkIpamConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 aux_address: Optional[Mapping[str, builtins.str]] = None,
-                 gateway: Optional[builtins.str] = None,
-                 ip_range: Optional[builtins.str] = None,
-                 subnet: Optional[builtins.str] = None):
+                 aux_address: Optional[Mapping[str, _builtins.str]] = None,
+                 gateway: Optional[_builtins.str] = None,
+                 ip_range: Optional[_builtins.str] = None,
+                 subnet: Optional[_builtins.str] = None):
         """
-        :param Mapping[str, builtins.str] aux_address: Auxiliary IPv4 or IPv6 addresses used by Network driver
-        :param builtins.str gateway: The IP address of the gateway
-        :param builtins.str ip_range: The ip range in CIDR form
-        :param builtins.str subnet: The subnet in CIDR form
+        :param Mapping[str, _builtins.str] aux_address: Auxiliary IPv4 or IPv6 addresses used by Network driver
+        :param _builtins.str gateway: The IP address of the gateway
+        :param _builtins.str ip_range: The ip range in CIDR form
+        :param _builtins.str subnet: The subnet in CIDR form
         """
         if aux_address is not None:
             pulumi.set(__self__, "aux_address", aux_address)
@@ -1167,33 +1819,33 @@ class NetworkIpamConfig(dict):
         if subnet is not None:
             pulumi.set(__self__, "subnet", subnet)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="auxAddress")
-    def aux_address(self) -> Optional[Mapping[str, builtins.str]]:
+    def aux_address(self) -> Optional[Mapping[str, _builtins.str]]:
         """
         Auxiliary IPv4 or IPv6 addresses used by Network driver
         """
         return pulumi.get(self, "aux_address")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def gateway(self) -> Optional[builtins.str]:
+    def gateway(self) -> Optional[_builtins.str]:
         """
         The IP address of the gateway
         """
         return pulumi.get(self, "gateway")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipRange")
-    def ip_range(self) -> Optional[builtins.str]:
+    def ip_range(self) -> Optional[_builtins.str]:
         """
         The ip range in CIDR form
         """
         return pulumi.get(self, "ip_range")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def subnet(self) -> Optional[builtins.str]:
+    def subnet(self) -> Optional[_builtins.str]:
         """
         The subnet in CIDR form
         """
@@ -1203,26 +1855,26 @@ class NetworkIpamConfig(dict):
 @pulumi.output_type
 class NetworkLabel(dict):
     def __init__(__self__, *,
-                 label: builtins.str,
-                 value: builtins.str):
+                 label: _builtins.str,
+                 value: _builtins.str):
         """
-        :param builtins.str label: Name of the label
-        :param builtins.str value: Value of the label
+        :param _builtins.str label: Name of the label
+        :param _builtins.str value: Value of the label
         """
         pulumi.set(__self__, "label", label)
         pulumi.set(__self__, "value", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def label(self) -> builtins.str:
+    def label(self) -> _builtins.str:
         """
         Name of the label
         """
         return pulumi.get(self, "label")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> builtins.str:
+    def value(self) -> _builtins.str:
         """
         Value of the label
         """
@@ -1232,26 +1884,26 @@ class NetworkLabel(dict):
 @pulumi.output_type
 class PluginGrantPermission(dict):
     def __init__(__self__, *,
-                 name: builtins.str,
-                 values: Sequence[builtins.str]):
+                 name: _builtins.str,
+                 values: Sequence[_builtins.str]):
         """
-        :param builtins.str name: The name of the permission
-        :param Sequence[builtins.str] values: The value of the permission
+        :param _builtins.str name: The name of the permission
+        :param Sequence[_builtins.str] values: The value of the permission
         """
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "values", values)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         The name of the permission
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def values(self) -> Sequence[builtins.str]:
+    def values(self) -> Sequence[_builtins.str]:
         """
         The value of the permission
         """
@@ -1261,37 +1913,37 @@ class PluginGrantPermission(dict):
 @pulumi.output_type
 class RegistryImageAuthConfig(dict):
     def __init__(__self__, *,
-                 address: builtins.str,
-                 password: builtins.str,
-                 username: builtins.str):
+                 address: _builtins.str,
+                 password: _builtins.str,
+                 username: _builtins.str):
         """
-        :param builtins.str address: The address of the Docker registry.
-        :param builtins.str password: The password for the Docker registry.
-        :param builtins.str username: The username for the Docker registry.
+        :param _builtins.str address: The address of the Docker registry.
+        :param _builtins.str password: The password for the Docker registry.
+        :param _builtins.str username: The username for the Docker registry.
         """
         pulumi.set(__self__, "address", address)
         pulumi.set(__self__, "password", password)
         pulumi.set(__self__, "username", username)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def address(self) -> builtins.str:
+    def address(self) -> _builtins.str:
         """
         The address of the Docker registry.
         """
         return pulumi.get(self, "address")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def password(self) -> builtins.str:
+    def password(self) -> _builtins.str:
         """
         The password for the Docker registry.
         """
         return pulumi.get(self, "password")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def username(self) -> builtins.str:
+    def username(self) -> _builtins.str:
         """
         The username for the Docker registry.
         """
@@ -1360,81 +2012,81 @@ class RemoteImageBuild(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 context: builtins.str,
+                 context: _builtins.str,
                  auth_configs: Optional[Sequence['outputs.RemoteImageBuildAuthConfig']] = None,
-                 build_args: Optional[Mapping[str, builtins.str]] = None,
-                 build_id: Optional[builtins.str] = None,
-                 build_log_file: Optional[builtins.str] = None,
-                 builder: Optional[builtins.str] = None,
-                 cache_froms: Optional[Sequence[builtins.str]] = None,
-                 cgroup_parent: Optional[builtins.str] = None,
-                 cpu_period: Optional[builtins.int] = None,
-                 cpu_quota: Optional[builtins.int] = None,
-                 cpu_set_cpus: Optional[builtins.str] = None,
-                 cpu_set_mems: Optional[builtins.str] = None,
-                 cpu_shares: Optional[builtins.int] = None,
-                 dockerfile: Optional[builtins.str] = None,
-                 extra_hosts: Optional[Sequence[builtins.str]] = None,
-                 force_remove: Optional[builtins.bool] = None,
-                 isolation: Optional[builtins.str] = None,
-                 label: Optional[Mapping[str, builtins.str]] = None,
-                 labels: Optional[Mapping[str, builtins.str]] = None,
-                 memory: Optional[builtins.int] = None,
-                 memory_swap: Optional[builtins.int] = None,
-                 network_mode: Optional[builtins.str] = None,
-                 no_cache: Optional[builtins.bool] = None,
-                 platform: Optional[builtins.str] = None,
-                 pull_parent: Optional[builtins.bool] = None,
-                 remote_context: Optional[builtins.str] = None,
-                 remove: Optional[builtins.bool] = None,
+                 build_args: Optional[Mapping[str, _builtins.str]] = None,
+                 build_id: Optional[_builtins.str] = None,
+                 build_log_file: Optional[_builtins.str] = None,
+                 builder: Optional[_builtins.str] = None,
+                 cache_froms: Optional[Sequence[_builtins.str]] = None,
+                 cgroup_parent: Optional[_builtins.str] = None,
+                 cpu_period: Optional[_builtins.int] = None,
+                 cpu_quota: Optional[_builtins.int] = None,
+                 cpu_set_cpus: Optional[_builtins.str] = None,
+                 cpu_set_mems: Optional[_builtins.str] = None,
+                 cpu_shares: Optional[_builtins.int] = None,
+                 dockerfile: Optional[_builtins.str] = None,
+                 extra_hosts: Optional[Sequence[_builtins.str]] = None,
+                 force_remove: Optional[_builtins.bool] = None,
+                 isolation: Optional[_builtins.str] = None,
+                 label: Optional[Mapping[str, _builtins.str]] = None,
+                 labels: Optional[Mapping[str, _builtins.str]] = None,
+                 memory: Optional[_builtins.int] = None,
+                 memory_swap: Optional[_builtins.int] = None,
+                 network_mode: Optional[_builtins.str] = None,
+                 no_cache: Optional[_builtins.bool] = None,
+                 platform: Optional[_builtins.str] = None,
+                 pull_parent: Optional[_builtins.bool] = None,
+                 remote_context: Optional[_builtins.str] = None,
+                 remove: Optional[_builtins.bool] = None,
                  secrets: Optional[Sequence['outputs.RemoteImageBuildSecret']] = None,
-                 security_opts: Optional[Sequence[builtins.str]] = None,
-                 session_id: Optional[builtins.str] = None,
-                 shm_size: Optional[builtins.int] = None,
-                 squash: Optional[builtins.bool] = None,
-                 suppress_output: Optional[builtins.bool] = None,
-                 tags: Optional[Sequence[builtins.str]] = None,
-                 target: Optional[builtins.str] = None,
+                 security_opts: Optional[Sequence[_builtins.str]] = None,
+                 session_id: Optional[_builtins.str] = None,
+                 shm_size: Optional[_builtins.int] = None,
+                 squash: Optional[_builtins.bool] = None,
+                 suppress_output: Optional[_builtins.bool] = None,
+                 tags: Optional[Sequence[_builtins.str]] = None,
+                 target: Optional[_builtins.str] = None,
                  ulimits: Optional[Sequence['outputs.RemoteImageBuildUlimit']] = None,
-                 version: Optional[builtins.str] = None):
+                 version: Optional[_builtins.str] = None):
         """
-        :param builtins.str context: Value to specify the build context. Currently, only a `PATH` context is supported. You can use the helper function '${path.cwd}/context-dir'. This always refers to the local working directory, even when building images on remote hosts. Please see https://docs.docker.com/build/building/context/ for more information about build contexts.
+        :param _builtins.str context: Value to specify the build context. Currently, only a `PATH` context is supported. You can use the helper function '${path.cwd}/context-dir'. This always refers to the local working directory, even when building images on remote hosts. Please see https://docs.docker.com/build/building/context/ for more information about build contexts.
         :param Sequence['RemoteImageBuildAuthConfigArgs'] auth_configs: The configuration for the authentication
-        :param Mapping[str, builtins.str] build_args: Pairs for build-time variables in the form of `ENDPOINT : "https://example.com"`
-        :param builtins.str build_id: BuildID is an optional identifier that can be passed together with the build request. The same identifier can be used to gracefully cancel the build with the cancel request.
-        :param builtins.str build_log_file: Path to a file where the buildx log are written to. Only available when `builder` is set. If not set, no logs are available. The path is taken as is, so make sure to use a path that is available.
-        :param builtins.str builder: Set the name of the buildx builder to use. If not set or empty, the legacy builder will be used.
-        :param Sequence[builtins.str] cache_froms: Images to consider as cache sources
-        :param builtins.str cgroup_parent: Optional parent cgroup for the container
-        :param builtins.int cpu_period: The length of a CPU period in microseconds
-        :param builtins.int cpu_quota: Microseconds of CPU time that the container can get in a CPU period
-        :param builtins.str cpu_set_cpus: CPUs in which to allow execution (e.g., `0-3`, `0`, `1`)
-        :param builtins.str cpu_set_mems: MEMs in which to allow execution (`0-3`, `0`, `1`)
-        :param builtins.int cpu_shares: CPU shares (relative weight)
-        :param builtins.str dockerfile: Name of the Dockerfile. Defaults to `Dockerfile`.
-        :param Sequence[builtins.str] extra_hosts: A list of hostnames/IP mappings to add to the container’s /etc/hosts file. Specified in the form ["hostname:IP"]
-        :param builtins.bool force_remove: Always remove intermediate containers
-        :param builtins.str isolation: Isolation represents the isolation technology of a container. The supported values are
-        :param Mapping[str, builtins.str] label: Set metadata for an image
-        :param Mapping[str, builtins.str] labels: User-defined key/value metadata
-        :param builtins.int memory: Set memory limit for build
-        :param builtins.int memory_swap: Total memory (memory + swap), -1 to enable unlimited swap
-        :param builtins.str network_mode: Set the networking mode for the RUN instructions during build
-        :param builtins.bool no_cache: Do not use the cache when building the image
-        :param builtins.str platform: Set platform if server is multi-platform capable
-        :param builtins.bool pull_parent: Attempt to pull the image even if an older image exists locally
-        :param builtins.str remote_context: A Git repository URI or HTTP/HTTPS context URI. Will be ignored if `builder` is set.
-        :param builtins.bool remove: Remove intermediate containers after a successful build. Defaults to `true`.
+        :param Mapping[str, _builtins.str] build_args: Pairs for build-time variables in the form of `ENDPOINT : "https://example.com"`
+        :param _builtins.str build_id: BuildID is an optional identifier that can be passed together with the build request. The same identifier can be used to gracefully cancel the build with the cancel request.
+        :param _builtins.str build_log_file: Path to a file where the buildx log are written to. Only available when `builder` is set. If not set, no logs are available. The path is taken as is, so make sure to use a path that is available.
+        :param _builtins.str builder: Set the name of the buildx builder to use. If not set, the legacy builder is used.
+        :param Sequence[_builtins.str] cache_froms: Images to consider as cache sources
+        :param _builtins.str cgroup_parent: Optional parent cgroup for the container
+        :param _builtins.int cpu_period: The length of a CPU period in microseconds
+        :param _builtins.int cpu_quota: Microseconds of CPU time that the container can get in a CPU period
+        :param _builtins.str cpu_set_cpus: CPUs in which to allow execution (e.g., `0-3`, `0`, `1`)
+        :param _builtins.str cpu_set_mems: MEMs in which to allow execution (`0-3`, `0`, `1`)
+        :param _builtins.int cpu_shares: CPU shares (relative weight)
+        :param _builtins.str dockerfile: Name of the Dockerfile. Defaults to `Dockerfile`.
+        :param Sequence[_builtins.str] extra_hosts: A list of hostnames/IP mappings to add to the container’s /etc/hosts file. Specified in the form ["hostname:IP"]
+        :param _builtins.bool force_remove: Always remove intermediate containers
+        :param _builtins.str isolation: Isolation represents the isolation technology of a container. The supported values are
+        :param Mapping[str, _builtins.str] label: Set metadata for an image
+        :param Mapping[str, _builtins.str] labels: User-defined key/value metadata
+        :param _builtins.int memory: Set memory limit for build
+        :param _builtins.int memory_swap: Total memory (memory + swap), -1 to enable unlimited swap
+        :param _builtins.str network_mode: Set the networking mode for the RUN instructions during build
+        :param _builtins.bool no_cache: Do not use the cache when building the image
+        :param _builtins.str platform: Set the target platform for the build. Defaults to `GOOS/GOARCH`. For more information see the [docker documentation](https://github.com/docker/buildx/blob/master/docs/reference/buildx.md#-set-the-target-platforms-for-the-build---platform)
+        :param _builtins.bool pull_parent: Attempt to pull the image even if an older image exists locally
+        :param _builtins.str remote_context: A Git repository URI or HTTP/HTTPS context URI. Will be ignored if `builder` is set.
+        :param _builtins.bool remove: Remove intermediate containers after a successful build. Defaults to `true`.
         :param Sequence['RemoteImageBuildSecretArgs'] secrets: Set build-time secrets. Only available when you use a buildx builder.
-        :param Sequence[builtins.str] security_opts: The security options
-        :param builtins.str session_id: Set an ID for the build session
-        :param builtins.int shm_size: Size of /dev/shm in bytes. The size must be greater than 0
-        :param builtins.bool squash: If true the new layers are squashed into a new image with a single new layer
-        :param builtins.bool suppress_output: Suppress the build output and print image ID on success
-        :param Sequence[builtins.str] tags: Name and optionally a tag in the 'name:tag' format
-        :param builtins.str target: Set the target build stage to build
+        :param Sequence[_builtins.str] security_opts: The security options
+        :param _builtins.str session_id: Set an ID for the build session
+        :param _builtins.int shm_size: Size of /dev/shm in bytes. The size must be greater than 0
+        :param _builtins.bool squash: If true the new layers are squashed into a new image with a single new layer
+        :param _builtins.bool suppress_output: Suppress the build output and print image ID on success
+        :param Sequence[_builtins.str] tags: Name and optionally a tag in the 'name:tag' format
+        :param _builtins.str target: Set the target build stage to build
         :param Sequence['RemoteImageBuildUlimitArgs'] ulimits: Configuration for ulimits
-        :param builtins.str version: Version of the underlying builder to use
+        :param _builtins.str version: Version of the underlying builder to use
         """
         pulumi.set(__self__, "context", context)
         if auth_configs is not None:
@@ -1510,15 +2162,15 @@ class RemoteImageBuild(dict):
         if version is not None:
             pulumi.set(__self__, "version", version)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def context(self) -> builtins.str:
+    def context(self) -> _builtins.str:
         """
         Value to specify the build context. Currently, only a `PATH` context is supported. You can use the helper function '${path.cwd}/context-dir'. This always refers to the local working directory, even when building images on remote hosts. Please see https://docs.docker.com/build/building/context/ for more information about build contexts.
         """
         return pulumi.get(self, "context")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="authConfigs")
     def auth_configs(self) -> Optional[Sequence['outputs.RemoteImageBuildAuthConfig']]:
         """
@@ -1526,207 +2178,207 @@ class RemoteImageBuild(dict):
         """
         return pulumi.get(self, "auth_configs")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="buildArgs")
-    def build_args(self) -> Optional[Mapping[str, builtins.str]]:
+    def build_args(self) -> Optional[Mapping[str, _builtins.str]]:
         """
         Pairs for build-time variables in the form of `ENDPOINT : "https://example.com"`
         """
         return pulumi.get(self, "build_args")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="buildId")
-    def build_id(self) -> Optional[builtins.str]:
+    def build_id(self) -> Optional[_builtins.str]:
         """
         BuildID is an optional identifier that can be passed together with the build request. The same identifier can be used to gracefully cancel the build with the cancel request.
         """
         return pulumi.get(self, "build_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="buildLogFile")
-    def build_log_file(self) -> Optional[builtins.str]:
+    def build_log_file(self) -> Optional[_builtins.str]:
         """
         Path to a file where the buildx log are written to. Only available when `builder` is set. If not set, no logs are available. The path is taken as is, so make sure to use a path that is available.
         """
         return pulumi.get(self, "build_log_file")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def builder(self) -> Optional[builtins.str]:
+    def builder(self) -> Optional[_builtins.str]:
         """
-        Set the name of the buildx builder to use. If not set or empty, the legacy builder will be used.
+        Set the name of the buildx builder to use. If not set, the legacy builder is used.
         """
         return pulumi.get(self, "builder")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="cacheFroms")
-    def cache_froms(self) -> Optional[Sequence[builtins.str]]:
+    def cache_froms(self) -> Optional[Sequence[_builtins.str]]:
         """
         Images to consider as cache sources
         """
         return pulumi.get(self, "cache_froms")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="cgroupParent")
-    def cgroup_parent(self) -> Optional[builtins.str]:
+    def cgroup_parent(self) -> Optional[_builtins.str]:
         """
         Optional parent cgroup for the container
         """
         return pulumi.get(self, "cgroup_parent")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="cpuPeriod")
-    def cpu_period(self) -> Optional[builtins.int]:
+    def cpu_period(self) -> Optional[_builtins.int]:
         """
         The length of a CPU period in microseconds
         """
         return pulumi.get(self, "cpu_period")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="cpuQuota")
-    def cpu_quota(self) -> Optional[builtins.int]:
+    def cpu_quota(self) -> Optional[_builtins.int]:
         """
         Microseconds of CPU time that the container can get in a CPU period
         """
         return pulumi.get(self, "cpu_quota")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="cpuSetCpus")
-    def cpu_set_cpus(self) -> Optional[builtins.str]:
+    def cpu_set_cpus(self) -> Optional[_builtins.str]:
         """
         CPUs in which to allow execution (e.g., `0-3`, `0`, `1`)
         """
         return pulumi.get(self, "cpu_set_cpus")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="cpuSetMems")
-    def cpu_set_mems(self) -> Optional[builtins.str]:
+    def cpu_set_mems(self) -> Optional[_builtins.str]:
         """
         MEMs in which to allow execution (`0-3`, `0`, `1`)
         """
         return pulumi.get(self, "cpu_set_mems")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="cpuShares")
-    def cpu_shares(self) -> Optional[builtins.int]:
+    def cpu_shares(self) -> Optional[_builtins.int]:
         """
         CPU shares (relative weight)
         """
         return pulumi.get(self, "cpu_shares")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def dockerfile(self) -> Optional[builtins.str]:
+    def dockerfile(self) -> Optional[_builtins.str]:
         """
         Name of the Dockerfile. Defaults to `Dockerfile`.
         """
         return pulumi.get(self, "dockerfile")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="extraHosts")
-    def extra_hosts(self) -> Optional[Sequence[builtins.str]]:
+    def extra_hosts(self) -> Optional[Sequence[_builtins.str]]:
         """
         A list of hostnames/IP mappings to add to the container’s /etc/hosts file. Specified in the form ["hostname:IP"]
         """
         return pulumi.get(self, "extra_hosts")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="forceRemove")
-    def force_remove(self) -> Optional[builtins.bool]:
+    def force_remove(self) -> Optional[_builtins.bool]:
         """
         Always remove intermediate containers
         """
         return pulumi.get(self, "force_remove")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def isolation(self) -> Optional[builtins.str]:
+    def isolation(self) -> Optional[_builtins.str]:
         """
         Isolation represents the isolation technology of a container. The supported values are
         """
         return pulumi.get(self, "isolation")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def label(self) -> Optional[Mapping[str, builtins.str]]:
+    def label(self) -> Optional[Mapping[str, _builtins.str]]:
         """
         Set metadata for an image
         """
         return pulumi.get(self, "label")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def labels(self) -> Optional[Mapping[str, builtins.str]]:
+    def labels(self) -> Optional[Mapping[str, _builtins.str]]:
         """
         User-defined key/value metadata
         """
         return pulumi.get(self, "labels")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def memory(self) -> Optional[builtins.int]:
+    def memory(self) -> Optional[_builtins.int]:
         """
         Set memory limit for build
         """
         return pulumi.get(self, "memory")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="memorySwap")
-    def memory_swap(self) -> Optional[builtins.int]:
+    def memory_swap(self) -> Optional[_builtins.int]:
         """
         Total memory (memory + swap), -1 to enable unlimited swap
         """
         return pulumi.get(self, "memory_swap")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="networkMode")
-    def network_mode(self) -> Optional[builtins.str]:
+    def network_mode(self) -> Optional[_builtins.str]:
         """
         Set the networking mode for the RUN instructions during build
         """
         return pulumi.get(self, "network_mode")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="noCache")
-    def no_cache(self) -> Optional[builtins.bool]:
+    def no_cache(self) -> Optional[_builtins.bool]:
         """
         Do not use the cache when building the image
         """
         return pulumi.get(self, "no_cache")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def platform(self) -> Optional[builtins.str]:
+    def platform(self) -> Optional[_builtins.str]:
         """
-        Set platform if server is multi-platform capable
+        Set the target platform for the build. Defaults to `GOOS/GOARCH`. For more information see the [docker documentation](https://github.com/docker/buildx/blob/master/docs/reference/buildx.md#-set-the-target-platforms-for-the-build---platform)
         """
         return pulumi.get(self, "platform")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="pullParent")
-    def pull_parent(self) -> Optional[builtins.bool]:
+    def pull_parent(self) -> Optional[_builtins.bool]:
         """
         Attempt to pull the image even if an older image exists locally
         """
         return pulumi.get(self, "pull_parent")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="remoteContext")
-    def remote_context(self) -> Optional[builtins.str]:
+    def remote_context(self) -> Optional[_builtins.str]:
         """
         A Git repository URI or HTTP/HTTPS context URI. Will be ignored if `builder` is set.
         """
         return pulumi.get(self, "remote_context")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def remove(self) -> Optional[builtins.bool]:
+    def remove(self) -> Optional[_builtins.bool]:
         """
         Remove intermediate containers after a successful build. Defaults to `true`.
         """
         return pulumi.get(self, "remove")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def secrets(self) -> Optional[Sequence['outputs.RemoteImageBuildSecret']]:
         """
@@ -1734,63 +2386,63 @@ class RemoteImageBuild(dict):
         """
         return pulumi.get(self, "secrets")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="securityOpts")
-    def security_opts(self) -> Optional[Sequence[builtins.str]]:
+    def security_opts(self) -> Optional[Sequence[_builtins.str]]:
         """
         The security options
         """
         return pulumi.get(self, "security_opts")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="sessionId")
-    def session_id(self) -> Optional[builtins.str]:
+    def session_id(self) -> Optional[_builtins.str]:
         """
         Set an ID for the build session
         """
         return pulumi.get(self, "session_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="shmSize")
-    def shm_size(self) -> Optional[builtins.int]:
+    def shm_size(self) -> Optional[_builtins.int]:
         """
         Size of /dev/shm in bytes. The size must be greater than 0
         """
         return pulumi.get(self, "shm_size")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def squash(self) -> Optional[builtins.bool]:
+    def squash(self) -> Optional[_builtins.bool]:
         """
         If true the new layers are squashed into a new image with a single new layer
         """
         return pulumi.get(self, "squash")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="suppressOutput")
-    def suppress_output(self) -> Optional[builtins.bool]:
+    def suppress_output(self) -> Optional[_builtins.bool]:
         """
         Suppress the build output and print image ID on success
         """
         return pulumi.get(self, "suppress_output")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def tags(self) -> Optional[Sequence[builtins.str]]:
+    def tags(self) -> Optional[Sequence[_builtins.str]]:
         """
         Name and optionally a tag in the 'name:tag' format
         """
         return pulumi.get(self, "tags")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def target(self) -> Optional[builtins.str]:
+    def target(self) -> Optional[_builtins.str]:
         """
         Set the target build stage to build
         """
         return pulumi.get(self, "target")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def ulimits(self) -> Optional[Sequence['outputs.RemoteImageBuildUlimit']]:
         """
@@ -1798,9 +2450,9 @@ class RemoteImageBuild(dict):
         """
         return pulumi.get(self, "ulimits")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def version(self) -> Optional[builtins.str]:
+    def version(self) -> Optional[_builtins.str]:
         """
         Version of the underlying builder to use
         """
@@ -1835,23 +2487,23 @@ class RemoteImageBuildAuthConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 host_name: builtins.str,
-                 auth: Optional[builtins.str] = None,
-                 email: Optional[builtins.str] = None,
-                 identity_token: Optional[builtins.str] = None,
-                 password: Optional[builtins.str] = None,
-                 registry_token: Optional[builtins.str] = None,
-                 server_address: Optional[builtins.str] = None,
-                 user_name: Optional[builtins.str] = None):
-        """
-        :param builtins.str host_name: hostname of the registry
-        :param builtins.str auth: the auth token
-        :param builtins.str email: the user emal
-        :param builtins.str identity_token: the identity token
-        :param builtins.str password: the registry password
-        :param builtins.str registry_token: the registry token
-        :param builtins.str server_address: the server address
-        :param builtins.str user_name: the registry user name
+                 host_name: _builtins.str,
+                 auth: Optional[_builtins.str] = None,
+                 email: Optional[_builtins.str] = None,
+                 identity_token: Optional[_builtins.str] = None,
+                 password: Optional[_builtins.str] = None,
+                 registry_token: Optional[_builtins.str] = None,
+                 server_address: Optional[_builtins.str] = None,
+                 user_name: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str host_name: hostname of the registry
+        :param _builtins.str auth: the auth token
+        :param _builtins.str email: the user emal
+        :param _builtins.str identity_token: the identity token
+        :param _builtins.str password: the registry password
+        :param _builtins.str registry_token: the registry token
+        :param _builtins.str server_address: the server address
+        :param _builtins.str user_name: the registry user name
         """
         pulumi.set(__self__, "host_name", host_name)
         if auth is not None:
@@ -1869,65 +2521,65 @@ class RemoteImageBuildAuthConfig(dict):
         if user_name is not None:
             pulumi.set(__self__, "user_name", user_name)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="hostName")
-    def host_name(self) -> builtins.str:
+    def host_name(self) -> _builtins.str:
         """
         hostname of the registry
         """
         return pulumi.get(self, "host_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def auth(self) -> Optional[builtins.str]:
+    def auth(self) -> Optional[_builtins.str]:
         """
         the auth token
         """
         return pulumi.get(self, "auth")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def email(self) -> Optional[builtins.str]:
+    def email(self) -> Optional[_builtins.str]:
         """
         the user emal
         """
         return pulumi.get(self, "email")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="identityToken")
-    def identity_token(self) -> Optional[builtins.str]:
+    def identity_token(self) -> Optional[_builtins.str]:
         """
         the identity token
         """
         return pulumi.get(self, "identity_token")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def password(self) -> Optional[builtins.str]:
+    def password(self) -> Optional[_builtins.str]:
         """
         the registry password
         """
         return pulumi.get(self, "password")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="registryToken")
-    def registry_token(self) -> Optional[builtins.str]:
+    def registry_token(self) -> Optional[_builtins.str]:
         """
         the registry token
         """
         return pulumi.get(self, "registry_token")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="serverAddress")
-    def server_address(self) -> Optional[builtins.str]:
+    def server_address(self) -> Optional[_builtins.str]:
         """
         the server address
         """
         return pulumi.get(self, "server_address")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="userName")
-    def user_name(self) -> Optional[builtins.str]:
+    def user_name(self) -> Optional[_builtins.str]:
         """
         the registry user name
         """
@@ -1937,13 +2589,13 @@ class RemoteImageBuildAuthConfig(dict):
 @pulumi.output_type
 class RemoteImageBuildSecret(dict):
     def __init__(__self__, *,
-                 id: builtins.str,
-                 env: Optional[builtins.str] = None,
-                 src: Optional[builtins.str] = None):
+                 id: _builtins.str,
+                 env: Optional[_builtins.str] = None,
+                 src: Optional[_builtins.str] = None):
         """
-        :param builtins.str id: ID of the secret. By default, secrets are mounted to /run/secrets/\\n\\n
-        :param builtins.str env: Environment variable source of the secret
-        :param builtins.str src: File source of the secret. Takes precedence over `env`
+        :param _builtins.str id: ID of the secret. By default, secrets are mounted to /run/secrets/\\n\\n
+        :param _builtins.str env: Environment variable source of the secret
+        :param _builtins.str src: File source of the secret. Takes precedence over `env`
         """
         pulumi.set(__self__, "id", id)
         if env is not None:
@@ -1951,25 +2603,25 @@ class RemoteImageBuildSecret(dict):
         if src is not None:
             pulumi.set(__self__, "src", src)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> builtins.str:
+    def id(self) -> _builtins.str:
         """
         ID of the secret. By default, secrets are mounted to /run/secrets/\\n\\n
         """
         return pulumi.get(self, "id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def env(self) -> Optional[builtins.str]:
+    def env(self) -> Optional[_builtins.str]:
         """
         Environment variable source of the secret
         """
         return pulumi.get(self, "env")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def src(self) -> Optional[builtins.str]:
+    def src(self) -> Optional[_builtins.str]:
         """
         File source of the secret. Takes precedence over `env`
         """
@@ -1979,37 +2631,37 @@ class RemoteImageBuildSecret(dict):
 @pulumi.output_type
 class RemoteImageBuildUlimit(dict):
     def __init__(__self__, *,
-                 hard: builtins.int,
-                 name: builtins.str,
-                 soft: builtins.int):
+                 hard: _builtins.int,
+                 name: _builtins.str,
+                 soft: _builtins.int):
         """
-        :param builtins.int hard: soft limit
-        :param builtins.str name: type of ulimit, e.g. `nofile`
-        :param builtins.int soft: hard limit
+        :param _builtins.int hard: soft limit
+        :param _builtins.str name: type of ulimit, e.g. `nofile`
+        :param _builtins.int soft: hard limit
         """
         pulumi.set(__self__, "hard", hard)
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "soft", soft)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def hard(self) -> builtins.int:
+    def hard(self) -> _builtins.int:
         """
         soft limit
         """
         return pulumi.get(self, "hard")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         type of ulimit, e.g. `nofile`
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def soft(self) -> builtins.int:
+    def soft(self) -> _builtins.int:
         """
         hard limit
         """
@@ -2019,26 +2671,26 @@ class RemoteImageBuildUlimit(dict):
 @pulumi.output_type
 class SecretLabel(dict):
     def __init__(__self__, *,
-                 label: builtins.str,
-                 value: builtins.str):
+                 label: _builtins.str,
+                 value: _builtins.str):
         """
-        :param builtins.str label: Name of the label
-        :param builtins.str value: Value of the label
+        :param _builtins.str label: Name of the label
+        :param _builtins.str value: Value of the label
         """
         pulumi.set(__self__, "label", label)
         pulumi.set(__self__, "value", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def label(self) -> builtins.str:
+    def label(self) -> _builtins.str:
         """
         Name of the label
         """
         return pulumi.get(self, "label")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> builtins.str:
+    def value(self) -> _builtins.str:
         """
         Value of the label
         """
@@ -2065,13 +2717,13 @@ class ServiceAuth(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 server_address: builtins.str,
-                 password: Optional[builtins.str] = None,
-                 username: Optional[builtins.str] = None):
+                 server_address: _builtins.str,
+                 password: Optional[_builtins.str] = None,
+                 username: Optional[_builtins.str] = None):
         """
-        :param builtins.str server_address: The address of the server for the authentication
-        :param builtins.str password: The password
-        :param builtins.str username: The username
+        :param _builtins.str server_address: The address of the server for the authentication
+        :param _builtins.str password: The password
+        :param _builtins.str username: The username
         """
         pulumi.set(__self__, "server_address", server_address)
         if password is not None:
@@ -2079,25 +2731,25 @@ class ServiceAuth(dict):
         if username is not None:
             pulumi.set(__self__, "username", username)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="serverAddress")
-    def server_address(self) -> builtins.str:
+    def server_address(self) -> _builtins.str:
         """
         The address of the server for the authentication
         """
         return pulumi.get(self, "server_address")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def password(self) -> Optional[builtins.str]:
+    def password(self) -> Optional[_builtins.str]:
         """
         The password
         """
         return pulumi.get(self, "password")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def username(self) -> Optional[builtins.str]:
+    def username(self) -> Optional[_builtins.str]:
         """
         The username
         """
@@ -2107,28 +2759,28 @@ class ServiceAuth(dict):
 @pulumi.output_type
 class ServiceConvergeConfig(dict):
     def __init__(__self__, *,
-                 delay: Optional[builtins.str] = None,
-                 timeout: Optional[builtins.str] = None):
+                 delay: Optional[_builtins.str] = None,
+                 timeout: Optional[_builtins.str] = None):
         """
-        :param builtins.str delay: The interval to check if the desired state is reached `(ms|s)`. Defaults to `7s`.
-        :param builtins.str timeout: The timeout of the service to reach the desired state `(s|m)`. Defaults to `3m`
+        :param _builtins.str delay: The interval to check if the desired state is reached `(ms|s)`. Defaults to `7s`.
+        :param _builtins.str timeout: The timeout of the service to reach the desired state `(s|m)`. Defaults to `3m`
         """
         if delay is not None:
             pulumi.set(__self__, "delay", delay)
         if timeout is not None:
             pulumi.set(__self__, "timeout", timeout)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def delay(self) -> Optional[builtins.str]:
+    def delay(self) -> Optional[_builtins.str]:
         """
         The interval to check if the desired state is reached `(ms|s)`. Defaults to `7s`.
         """
         return pulumi.get(self, "delay")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def timeout(self) -> Optional[builtins.str]:
+    def timeout(self) -> Optional[_builtins.str]:
         """
         The timeout of the service to reach the desired state `(s|m)`. Defaults to `3m`
         """
@@ -2138,10 +2790,10 @@ class ServiceConvergeConfig(dict):
 @pulumi.output_type
 class ServiceEndpointSpec(dict):
     def __init__(__self__, *,
-                 mode: Optional[builtins.str] = None,
+                 mode: Optional[_builtins.str] = None,
                  ports: Optional[Sequence['outputs.ServiceEndpointSpecPort']] = None):
         """
-        :param builtins.str mode: The mode of resolution to use for internal load balancing between tasks
+        :param _builtins.str mode: The mode of resolution to use for internal load balancing between tasks
         :param Sequence['ServiceEndpointSpecPortArgs'] ports: List of exposed ports that this service is accessible on from the outside. Ports can only be provided if 'vip' resolution mode is used
         """
         if mode is not None:
@@ -2149,15 +2801,15 @@ class ServiceEndpointSpec(dict):
         if ports is not None:
             pulumi.set(__self__, "ports", ports)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def mode(self) -> Optional[builtins.str]:
+    def mode(self) -> Optional[_builtins.str]:
         """
         The mode of resolution to use for internal load balancing between tasks
         """
         return pulumi.get(self, "mode")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def ports(self) -> Optional[Sequence['outputs.ServiceEndpointSpecPort']]:
         """
@@ -2190,17 +2842,17 @@ class ServiceEndpointSpecPort(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 target_port: builtins.int,
-                 name: Optional[builtins.str] = None,
-                 protocol: Optional[builtins.str] = None,
-                 publish_mode: Optional[builtins.str] = None,
-                 published_port: Optional[builtins.int] = None):
-        """
-        :param builtins.int target_port: The port inside the container
-        :param builtins.str name: A random name for the port
-        :param builtins.str protocol: Rrepresents the protocol of a port: `tcp`, `udp` or `sctp`. Defaults to `tcp`.
-        :param builtins.str publish_mode: Represents the mode in which the port is to be published: 'ingress' or 'host'. Defaults to `ingress`.
-        :param builtins.int published_port: The port on the swarm hosts
+                 target_port: _builtins.int,
+                 name: Optional[_builtins.str] = None,
+                 protocol: Optional[_builtins.str] = None,
+                 publish_mode: Optional[_builtins.str] = None,
+                 published_port: Optional[_builtins.int] = None):
+        """
+        :param _builtins.int target_port: The port inside the container
+        :param _builtins.str name: A random name for the port
+        :param _builtins.str protocol: Rrepresents the protocol of a port: `tcp`, `udp` or `sctp`. Defaults to `tcp`.
+        :param _builtins.str publish_mode: Represents the mode in which the port is to be published: 'ingress' or 'host'. Defaults to `ingress`.
+        :param _builtins.int published_port: The port on the swarm hosts
         """
         pulumi.set(__self__, "target_port", target_port)
         if name is not None:
@@ -2212,41 +2864,41 @@ class ServiceEndpointSpecPort(dict):
         if published_port is not None:
             pulumi.set(__self__, "published_port", published_port)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="targetPort")
-    def target_port(self) -> builtins.int:
+    def target_port(self) -> _builtins.int:
         """
         The port inside the container
         """
         return pulumi.get(self, "target_port")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> Optional[builtins.str]:
+    def name(self) -> Optional[_builtins.str]:
         """
         A random name for the port
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def protocol(self) -> Optional[builtins.str]:
+    def protocol(self) -> Optional[_builtins.str]:
         """
         Rrepresents the protocol of a port: `tcp`, `udp` or `sctp`. Defaults to `tcp`.
         """
         return pulumi.get(self, "protocol")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="publishMode")
-    def publish_mode(self) -> Optional[builtins.str]:
+    def publish_mode(self) -> Optional[_builtins.str]:
         """
         Represents the mode in which the port is to be published: 'ingress' or 'host'. Defaults to `ingress`.
         """
         return pulumi.get(self, "publish_mode")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="publishedPort")
-    def published_port(self) -> Optional[builtins.int]:
+    def published_port(self) -> Optional[_builtins.int]:
         """
         The port on the swarm hosts
         """
@@ -2256,26 +2908,26 @@ class ServiceEndpointSpecPort(dict):
 @pulumi.output_type
 class ServiceLabel(dict):
     def __init__(__self__, *,
-                 label: builtins.str,
-                 value: builtins.str):
+                 label: _builtins.str,
+                 value: _builtins.str):
         """
-        :param builtins.str label: Name of the label
-        :param builtins.str value: Value of the label
+        :param _builtins.str label: Name of the label
+        :param _builtins.str value: Value of the label
         """
         pulumi.set(__self__, "label", label)
         pulumi.set(__self__, "value", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def label(self) -> builtins.str:
+    def label(self) -> _builtins.str:
         """
         Name of the label
         """
         return pulumi.get(self, "label")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> builtins.str:
+    def value(self) -> _builtins.str:
         """
         Value of the label
         """
@@ -2302,10 +2954,10 @@ class ServiceMode(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 global_: Optional[builtins.bool] = None,
+                 global_: Optional[_builtins.bool] = None,
                  replicated: Optional['outputs.ServiceModeReplicated'] = None):
         """
-        :param builtins.bool global_: When `true`, tasks will run on every worker node. Conflicts with `replicated`
+        :param _builtins.bool global_: When `true`, tasks will run on every worker node. Conflicts with `replicated`
         :param 'ServiceModeReplicatedArgs' replicated: The replicated service mode
         """
         if global_ is not None:
@@ -2313,15 +2965,15 @@ class ServiceMode(dict):
         if replicated is not None:
             pulumi.set(__self__, "replicated", replicated)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="global")
-    def global_(self) -> Optional[builtins.bool]:
+    def global_(self) -> Optional[_builtins.bool]:
         """
         When `true`, tasks will run on every worker node. Conflicts with `replicated`
         """
         return pulumi.get(self, "global_")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def replicated(self) -> Optional['outputs.ServiceModeReplicated']:
         """
@@ -2333,16 +2985,16 @@ class ServiceMode(dict):
 @pulumi.output_type
 class ServiceModeReplicated(dict):
     def __init__(__self__, *,
-                 replicas: Optional[builtins.int] = None):
+                 replicas: Optional[_builtins.int] = None):
         """
-        :param builtins.int replicas: The amount of replicas of the service. Defaults to `1`
+        :param _builtins.int replicas: The amount of replicas of the service. Defaults to `1`
         """
         if replicas is not None:
             pulumi.set(__self__, "replicas", replicas)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def replicas(self) -> Optional[builtins.int]:
+    def replicas(self) -> Optional[_builtins.int]:
         """
         The amount of replicas of the service. Defaults to `1`
         """
@@ -2371,19 +3023,19 @@ class ServiceRollbackConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 delay: Optional[builtins.str] = None,
-                 failure_action: Optional[builtins.str] = None,
-                 max_failure_ratio: Optional[builtins.str] = None,
-                 monitor: Optional[builtins.str] = None,
-                 order: Optional[builtins.str] = None,
-                 parallelism: Optional[builtins.int] = None):
-        """
-        :param builtins.str delay: Delay between task rollbacks (ns|us|ms|s|m|h). Defaults to `0s`.
-        :param builtins.str failure_action: Action on rollback failure: pause | continue. Defaults to `pause`.
-        :param builtins.str max_failure_ratio: Failure rate to tolerate during a rollback. Defaults to `0.0`.
-        :param builtins.str monitor: Duration after each task rollback to monitor for failure (ns|us|ms|s|m|h). Defaults to `5s`.
-        :param builtins.str order: Rollback order: either 'stop-first' or 'start-first'. Defaults to `stop-first`.
-        :param builtins.int parallelism: Maximum number of tasks to be rollbacked in one iteration. Defaults to `1`
+                 delay: Optional[_builtins.str] = None,
+                 failure_action: Optional[_builtins.str] = None,
+                 max_failure_ratio: Optional[_builtins.str] = None,
+                 monitor: Optional[_builtins.str] = None,
+                 order: Optional[_builtins.str] = None,
+                 parallelism: Optional[_builtins.int] = None):
+        """
+        :param _builtins.str delay: Delay between task rollbacks (ns|us|ms|s|m|h). Defaults to `0s`.
+        :param _builtins.str failure_action: Action on rollback failure: pause | continue. Defaults to `pause`.
+        :param _builtins.str max_failure_ratio: Failure rate to tolerate during a rollback. Defaults to `0.0`.
+        :param _builtins.str monitor: Duration after each task rollback to monitor for failure (ns|us|ms|s|m|h). Defaults to `5s`.
+        :param _builtins.str order: Rollback order: either 'stop-first' or 'start-first'. Defaults to `stop-first`.
+        :param _builtins.int parallelism: Maximum number of tasks to be rollbacked in one iteration. Defaults to `1`
         """
         if delay is not None:
             pulumi.set(__self__, "delay", delay)
@@ -2398,49 +3050,49 @@ class ServiceRollbackConfig(dict):
         if parallelism is not None:
             pulumi.set(__self__, "parallelism", parallelism)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def delay(self) -> Optional[builtins.str]:
+    def delay(self) -> Optional[_builtins.str]:
         """
         Delay between task rollbacks (ns|us|ms|s|m|h). Defaults to `0s`.
         """
         return pulumi.get(self, "delay")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="failureAction")
-    def failure_action(self) -> Optional[builtins.str]:
+    def failure_action(self) -> Optional[_builtins.str]:
         """
         Action on rollback failure: pause | continue. Defaults to `pause`.
         """
         return pulumi.get(self, "failure_action")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="maxFailureRatio")
-    def max_failure_ratio(self) -> Optional[builtins.str]:
+    def max_failure_ratio(self) -> Optional[_builtins.str]:
         """
         Failure rate to tolerate during a rollback. Defaults to `0.0`.
         """
         return pulumi.get(self, "max_failure_ratio")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def monitor(self) -> Optional[builtins.str]:
+    def monitor(self) -> Optional[_builtins.str]:
         """
         Duration after each task rollback to monitor for failure (ns|us|ms|s|m|h). Defaults to `5s`.
         """
         return pulumi.get(self, "monitor")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def order(self) -> Optional[builtins.str]:
+    def order(self) -> Optional[_builtins.str]:
         """
         Rollback order: either 'stop-first' or 'start-first'. Defaults to `stop-first`.
         """
         return pulumi.get(self, "order")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def parallelism(self) -> Optional[builtins.int]:
+    def parallelism(self) -> Optional[_builtins.int]:
         """
         Maximum number of tasks to be rollbacked in one iteration. Defaults to `1`
         """
@@ -2476,22 +3128,22 @@ class ServiceTaskSpec(dict):
 
     def __init__(__self__, *,
                  container_spec: 'outputs.ServiceTaskSpecContainerSpec',
-                 force_update: Optional[builtins.int] = None,
+                 force_update: Optional[_builtins.int] = None,
                  log_driver: Optional['outputs.ServiceTaskSpecLogDriver'] = None,
                  networks_advanceds: Optional[Sequence['outputs.ServiceTaskSpecNetworksAdvanced']] = None,
                  placement: Optional['outputs.ServiceTaskSpecPlacement'] = None,
                  resources: Optional['outputs.ServiceTaskSpecResources'] = None,
                  restart_policy: Optional['outputs.ServiceTaskSpecRestartPolicy'] = None,
-                 runtime: Optional[builtins.str] = None):
+                 runtime: Optional[_builtins.str] = None):
         """
         :param 'ServiceTaskSpecContainerSpecArgs' container_spec: The spec for each container
-        :param builtins.int force_update: A counter that triggers an update even if no relevant parameters have been changed. See the [spec](https://github.com/docker/swarmkit/blob/master/api/specs.proto#L126).
+        :param _builtins.int force_update: A counter that triggers an update even if no relevant parameters have been changed. See the [spec](https://github.com/docker/swarmkit/blob/master/api/specs.proto#L126).
         :param 'ServiceTaskSpecLogDriverArgs' log_driver: Specifies the log driver to use for tasks created from this spec. If not present, the default one for the swarm will be used, finally falling back to the engine default if not specified
         :param Sequence['ServiceTaskSpecNetworksAdvancedArgs'] networks_advanceds: The networks the container is attached to
         :param 'ServiceTaskSpecPlacementArgs' placement: The placement preferences
         :param 'ServiceTaskSpecResourcesArgs' resources: Resource requirements which apply to each individual container created as part of the service
         :param 'ServiceTaskSpecRestartPolicyArgs' restart_policy: Specification for the restart policy which applies to containers created as part of this service.
-        :param builtins.str runtime: Runtime is the type of runtime specified for the task executor. See the [types](https://github.com/moby/moby/blob/master/api/types/swarm/runtime.go).
+        :param _builtins.str runtime: Runtime is the type of runtime specified for the task executor. See the [types](https://github.com/moby/moby/blob/master/api/types/swarm/runtime.go).
         """
         pulumi.set(__self__, "container_spec", container_spec)
         if force_update is not None:
@@ -2509,7 +3161,7 @@ class ServiceTaskSpec(dict):
         if runtime is not None:
             pulumi.set(__self__, "runtime", runtime)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="containerSpec")
     def container_spec(self) -> 'outputs.ServiceTaskSpecContainerSpec':
         """
@@ -2517,15 +3169,15 @@ class ServiceTaskSpec(dict):
         """
         return pulumi.get(self, "container_spec")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="forceUpdate")
-    def force_update(self) -> Optional[builtins.int]:
+    def force_update(self) -> Optional[_builtins.int]:
         """
         A counter that triggers an update even if no relevant parameters have been changed. See the [spec](https://github.com/docker/swarmkit/blob/master/api/specs.proto#L126).
         """
         return pulumi.get(self, "force_update")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="logDriver")
     def log_driver(self) -> Optional['outputs.ServiceTaskSpecLogDriver']:
         """
@@ -2533,7 +3185,7 @@ class ServiceTaskSpec(dict):
         """
         return pulumi.get(self, "log_driver")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="networksAdvanceds")
     def networks_advanceds(self) -> Optional[Sequence['outputs.ServiceTaskSpecNetworksAdvanced']]:
         """
@@ -2541,7 +3193,7 @@ class ServiceTaskSpec(dict):
         """
         return pulumi.get(self, "networks_advanceds")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def placement(self) -> Optional['outputs.ServiceTaskSpecPlacement']:
         """
@@ -2549,7 +3201,7 @@ class ServiceTaskSpec(dict):
         """
         return pulumi.get(self, "placement")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def resources(self) -> Optional['outputs.ServiceTaskSpecResources']:
         """
@@ -2557,7 +3209,7 @@ class ServiceTaskSpec(dict):
         """
         return pulumi.get(self, "resources")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="restartPolicy")
     def restart_policy(self) -> Optional['outputs.ServiceTaskSpecRestartPolicy']:
         """
@@ -2565,9 +3217,9 @@ class ServiceTaskSpec(dict):
         """
         return pulumi.get(self, "restart_policy")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def runtime(self) -> Optional[builtins.str]:
+    def runtime(self) -> Optional[_builtins.str]:
         """
         Runtime is the type of runtime specified for the task executor. See the [types](https://github.com/moby/moby/blob/master/api/types/swarm/runtime.go).
         """
@@ -2579,7 +3231,11 @@ class ServiceTaskSpecContainerSpec(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "dnsConfig":
+        if key == "capAdds":
+            suggest = "cap_adds"
+        elif key == "capDrops":
+            suggest = "cap_drops"
+        elif key == "dnsConfig":
             suggest = "dns_config"
         elif key == "readOnly":
             suggest = "read_only"
@@ -2600,53 +3256,61 @@ class ServiceTaskSpecContainerSpec(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 image: builtins.str,
-                 args: Optional[Sequence[builtins.str]] = None,
-                 commands: Optional[Sequence[builtins.str]] = None,
+                 image: _builtins.str,
+                 args: Optional[Sequence[_builtins.str]] = None,
+                 cap_adds: Optional[Sequence[_builtins.str]] = None,
+                 cap_drops: Optional[Sequence[_builtins.str]] = None,
+                 commands: Optional[Sequence[_builtins.str]] = None,
                  configs: Optional[Sequence['outputs.ServiceTaskSpecContainerSpecConfig']] = None,
-                 dir: Optional[builtins.str] = None,
+                 dir: Optional[_builtins.str] = None,
                  dns_config: Optional['outputs.ServiceTaskSpecContainerSpecDnsConfig'] = None,
-                 env: Optional[Mapping[str, builtins.str]] = None,
-                 groups: Optional[Sequence[builtins.str]] = None,
+                 env: Optional[Mapping[str, _builtins.str]] = None,
+                 groups: Optional[Sequence[_builtins.str]] = None,
                  healthcheck: Optional['outputs.ServiceTaskSpecContainerSpecHealthcheck'] = None,
-                 hostname: Optional[builtins.str] = None,
+                 hostname: Optional[_builtins.str] = None,
                  hosts: Optional[Sequence['outputs.ServiceTaskSpecContainerSpecHost']] = None,
-                 isolation: Optional[builtins.str] = None,
+                 isolation: Optional[_builtins.str] = None,
                  labels: Optional[Sequence['outputs.ServiceTaskSpecContainerSpecLabel']] = None,
                  mounts: Optional[Sequence['outputs.ServiceTaskSpecContainerSpecMount']] = None,
                  privileges: Optional['outputs.ServiceTaskSpecContainerSpecPrivileges'] = None,
-                 read_only: Optional[builtins.bool] = None,
+                 read_only: Optional[_builtins.bool] = None,
                  secrets: Optional[Sequence['outputs.ServiceTaskSpecContainerSpecSecret']] = None,
-                 stop_grace_period: Optional[builtins.str] = None,
-                 stop_signal: Optional[builtins.str] = None,
-                 sysctl: Optional[Mapping[str, builtins.str]] = None,
-                 user: Optional[builtins.str] = None):
-        """
-        :param builtins.str image: The image name to use for the containers of the service, like `nginx:1.17.6`. Also use the data-source or resource of `RemoteImage` with the `repo_digest` or `RegistryImage` with the `name` attribute for this, as shown in the examples.
-        :param Sequence[builtins.str] args: Arguments to the command
-        :param Sequence[builtins.str] commands: The command/entrypoint to be run in the image. According to the [docker cli](https://github.com/docker/cli/blob/v20.10.7/cli/command/service/opts.go#L705) the override of the entrypoint is also passed to the `command` property and there is no `entrypoint` attribute in the `ContainerSpec` of the service.
+                 stop_grace_period: Optional[_builtins.str] = None,
+                 stop_signal: Optional[_builtins.str] = None,
+                 sysctl: Optional[Mapping[str, _builtins.str]] = None,
+                 user: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str image: The image name to use for the containers of the service, like `nginx:1.17.6`. Also use the data-source or resource of `RemoteImage` with the `repo_digest` or `RegistryImage` with the `name` attribute for this, as shown in the examples.
+        :param Sequence[_builtins.str] args: Arguments to the command
+        :param Sequence[_builtins.str] cap_adds: List of Linux capabilities to add to the container
+        :param Sequence[_builtins.str] cap_drops: List of Linux capabilities to drop from the container
+        :param Sequence[_builtins.str] commands: The command/entrypoint to be run in the image. According to the [docker cli](https://github.com/docker/cli/blob/v20.10.7/cli/command/service/opts.go#L705) the override of the entrypoint is also passed to the `command` property and there is no `entrypoint` attribute in the `ContainerSpec` of the service.
         :param Sequence['ServiceTaskSpecContainerSpecConfigArgs'] configs: References to zero or more configs that will be exposed to the service
-        :param builtins.str dir: The working directory for commands to run in
+        :param _builtins.str dir: The working directory for commands to run in
         :param 'ServiceTaskSpecContainerSpecDnsConfigArgs' dns_config: Specification for DNS related configurations in resolver configuration file (`resolv.conf`)
-        :param Mapping[str, builtins.str] env: A list of environment variables in the form VAR="value"
-        :param Sequence[builtins.str] groups: A list of additional groups that the container process will run as
+        :param Mapping[str, _builtins.str] env: A list of environment variables in the form VAR="value"
+        :param Sequence[_builtins.str] groups: A list of additional groups that the container process will run as
         :param 'ServiceTaskSpecContainerSpecHealthcheckArgs' healthcheck: A test to perform to check that the container is healthy
-        :param builtins.str hostname: The hostname to use for the container, as a valid RFC 1123 hostname
+        :param _builtins.str hostname: The hostname to use for the container, as a valid RFC 1123 hostname
         :param Sequence['ServiceTaskSpecContainerSpecHostArgs'] hosts: A list of hostname/IP mappings to add to the container's hosts file
-        :param builtins.str isolation: Isolation technology of the containers running the service. (Windows only). Defaults to `default`.
+        :param _builtins.str isolation: Isolation technology of the containers running the service. (Windows only). Defaults to `default`.
         :param Sequence['ServiceTaskSpecContainerSpecLabelArgs'] labels: User-defined key/value metadata
         :param Sequence['ServiceTaskSpecContainerSpecMountArgs'] mounts: Specification for mounts to be added to containers created as part of the service
         :param 'ServiceTaskSpecContainerSpecPrivilegesArgs' privileges: Security options for the container
-        :param builtins.bool read_only: Mount the container's root filesystem as read only
+        :param _builtins.bool read_only: Mount the container's root filesystem as read only
         :param Sequence['ServiceTaskSpecContainerSpecSecretArgs'] secrets: References to zero or more secrets that will be exposed to the service
-        :param builtins.str stop_grace_period: Amount of time to wait for the container to terminate before forcefully removing it (ms|s|m|h). If not specified or '0s' the destroy will not check if all tasks/containers of the service terminate.
-        :param builtins.str stop_signal: Signal to stop the container
-        :param Mapping[str, builtins.str] sysctl: Sysctls config (Linux only)
-        :param builtins.str user: The user inside the container
+        :param _builtins.str stop_grace_period: Amount of time to wait for the container to terminate before forcefully removing it (ms|s|m|h). If not specified or '0s' the destroy will not check if all tasks/containers of the service terminate.
+        :param _builtins.str stop_signal: Signal to stop the container
+        :param Mapping[str, _builtins.str] sysctl: Sysctls config (Linux only)
+        :param _builtins.str user: The user inside the container
         """
         pulumi.set(__self__, "image", image)
         if args is not None:
             pulumi.set(__self__, "args", args)
+        if cap_adds is not None:
+            pulumi.set(__self__, "cap_adds", cap_adds)
+        if cap_drops is not None:
+            pulumi.set(__self__, "cap_drops", cap_drops)
         if commands is not None:
             pulumi.set(__self__, "commands", commands)
         if configs is not None:
@@ -2686,31 +3350,47 @@ class ServiceTaskSpecContainerSpec(dict):
         if user is not None:
             pulumi.set(__self__, "user", user)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def image(self) -> builtins.str:
+    def image(self) -> _builtins.str:
         """
         The image name to use for the containers of the service, like `nginx:1.17.6`. Also use the data-source or resource of `RemoteImage` with the `repo_digest` or `RegistryImage` with the `name` attribute for this, as shown in the examples.
         """
         return pulumi.get(self, "image")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def args(self) -> Optional[Sequence[builtins.str]]:
+    def args(self) -> Optional[Sequence[_builtins.str]]:
         """
         Arguments to the command
         """
         return pulumi.get(self, "args")
 
-    @property
+    @_builtins.property
+    @pulumi.getter(name="capAdds")
+    def cap_adds(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        List of Linux capabilities to add to the container
+        """
+        return pulumi.get(self, "cap_adds")
+
+    @_builtins.property
+    @pulumi.getter(name="capDrops")
+    def cap_drops(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        List of Linux capabilities to drop from the container
+        """
+        return pulumi.get(self, "cap_drops")
+
+    @_builtins.property
     @pulumi.getter
-    def commands(self) -> Optional[Sequence[builtins.str]]:
+    def commands(self) -> Optional[Sequence[_builtins.str]]:
         """
         The command/entrypoint to be run in the image. According to the [docker cli](https://github.com/docker/cli/blob/v20.10.7/cli/command/service/opts.go#L705) the override of the entrypoint is also passed to the `command` property and there is no `entrypoint` attribute in the `ContainerSpec` of the service.
         """
         return pulumi.get(self, "commands")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def configs(self) -> Optional[Sequence['outputs.ServiceTaskSpecContainerSpecConfig']]:
         """
@@ -2718,15 +3398,15 @@ class ServiceTaskSpecContainerSpec(dict):
         """
         return pulumi.get(self, "configs")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def dir(self) -> Optional[builtins.str]:
+    def dir(self) -> Optional[_builtins.str]:
         """
         The working directory for commands to run in
         """
         return pulumi.get(self, "dir")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="dnsConfig")
     def dns_config(self) -> Optional['outputs.ServiceTaskSpecContainerSpecDnsConfig']:
         """
@@ -2734,23 +3414,23 @@ class ServiceTaskSpecContainerSpec(dict):
         """
         return pulumi.get(self, "dns_config")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def env(self) -> Optional[Mapping[str, builtins.str]]:
+    def env(self) -> Optional[Mapping[str, _builtins.str]]:
         """
         A list of environment variables in the form VAR="value"
         """
         return pulumi.get(self, "env")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def groups(self) -> Optional[Sequence[builtins.str]]:
+    def groups(self) -> Optional[Sequence[_builtins.str]]:
         """
         A list of additional groups that the container process will run as
         """
         return pulumi.get(self, "groups")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def healthcheck(self) -> Optional['outputs.ServiceTaskSpecContainerSpecHealthcheck']:
         """
@@ -2758,15 +3438,15 @@ class ServiceTaskSpecContainerSpec(dict):
         """
         return pulumi.get(self, "healthcheck")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def hostname(self) -> Optional[builtins.str]:
+    def hostname(self) -> Optional[_builtins.str]:
         """
         The hostname to use for the container, as a valid RFC 1123 hostname
         """
         return pulumi.get(self, "hostname")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def hosts(self) -> Optional[Sequence['outputs.ServiceTaskSpecContainerSpecHost']]:
         """
@@ -2774,15 +3454,15 @@ class ServiceTaskSpecContainerSpec(dict):
         """
         return pulumi.get(self, "hosts")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def isolation(self) -> Optional[builtins.str]:
+    def isolation(self) -> Optional[_builtins.str]:
         """
         Isolation technology of the containers running the service. (Windows only). Defaults to `default`.
         """
         return pulumi.get(self, "isolation")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def labels(self) -> Optional[Sequence['outputs.ServiceTaskSpecContainerSpecLabel']]:
         """
@@ -2790,7 +3470,7 @@ class ServiceTaskSpecContainerSpec(dict):
         """
         return pulumi.get(self, "labels")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def mounts(self) -> Optional[Sequence['outputs.ServiceTaskSpecContainerSpecMount']]:
         """
@@ -2798,7 +3478,7 @@ class ServiceTaskSpecContainerSpec(dict):
         """
         return pulumi.get(self, "mounts")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def privileges(self) -> Optional['outputs.ServiceTaskSpecContainerSpecPrivileges']:
         """
@@ -2806,15 +3486,15 @@ class ServiceTaskSpecContainerSpec(dict):
         """
         return pulumi.get(self, "privileges")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="readOnly")
-    def read_only(self) -> Optional[builtins.bool]:
+    def read_only(self) -> Optional[_builtins.bool]:
         """
         Mount the container's root filesystem as read only
         """
         return pulumi.get(self, "read_only")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def secrets(self) -> Optional[Sequence['outputs.ServiceTaskSpecContainerSpecSecret']]:
         """
@@ -2822,33 +3502,33 @@ class ServiceTaskSpecContainerSpec(dict):
         """
         return pulumi.get(self, "secrets")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="stopGracePeriod")
-    def stop_grace_period(self) -> Optional[builtins.str]:
+    def stop_grace_period(self) -> Optional[_builtins.str]:
         """
         Amount of time to wait for the container to terminate before forcefully removing it (ms|s|m|h). If not specified or '0s' the destroy will not check if all tasks/containers of the service terminate.
         """
         return pulumi.get(self, "stop_grace_period")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="stopSignal")
-    def stop_signal(self) -> Optional[builtins.str]:
+    def stop_signal(self) -> Optional[_builtins.str]:
         """
         Signal to stop the container
         """
         return pulumi.get(self, "stop_signal")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def sysctl(self) -> Optional[Mapping[str, builtins.str]]:
+    def sysctl(self) -> Optional[Mapping[str, _builtins.str]]:
         """
         Sysctls config (Linux only)
         """
         return pulumi.get(self, "sysctl")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def user(self) -> Optional[builtins.str]:
+    def user(self) -> Optional[_builtins.str]:
         """
         The user inside the container
         """
@@ -2885,19 +3565,19 @@ class ServiceTaskSpecContainerSpecConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 config_id: builtins.str,
-                 file_name: builtins.str,
-                 config_name: Optional[builtins.str] = None,
-                 file_gid: Optional[builtins.str] = None,
-                 file_mode: Optional[builtins.int] = None,
-                 file_uid: Optional[builtins.str] = None):
-        """
-        :param builtins.str config_id: ID of the specific config that we're referencing
-        :param builtins.str file_name: Represents the final filename in the filesystem
-        :param builtins.str config_name: Name of the config that this references, but this is just provided for lookup/display purposes. The config in the reference will be identified by its ID
-        :param builtins.str file_gid: Represents the file GID. Defaults to `0`.
-        :param builtins.int file_mode: Represents represents the FileMode of the file. Defaults to `0o444`.
-        :param builtins.str file_uid: Represents the file UID. Defaults to `0`.
+                 config_id: _builtins.str,
+                 file_name: _builtins.str,
+                 config_name: Optional[_builtins.str] = None,
+                 file_gid: Optional[_builtins.str] = None,
+                 file_mode: Optional[_builtins.int] = None,
+                 file_uid: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str config_id: ID of the specific config that we're referencing
+        :param _builtins.str file_name: Represents the final filename in the filesystem
+        :param _builtins.str config_name: Name of the config that this references, but this is just provided for lookup/display purposes. The config in the reference will be identified by its ID
+        :param _builtins.str file_gid: Represents the file GID. Defaults to `0`.
+        :param _builtins.int file_mode: Represents represents the FileMode of the file. Defaults to `0o444`.
+        :param _builtins.str file_uid: Represents the file UID. Defaults to `0`.
         """
         pulumi.set(__self__, "config_id", config_id)
         pulumi.set(__self__, "file_name", file_name)
@@ -2910,49 +3590,49 @@ class ServiceTaskSpecContainerSpecConfig(dict):
         if file_uid is not None:
             pulumi.set(__self__, "file_uid", file_uid)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="configId")
-    def config_id(self) -> builtins.str:
+    def config_id(self) -> _builtins.str:
         """
         ID of the specific config that we're referencing
         """
         return pulumi.get(self, "config_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="fileName")
-    def file_name(self) -> builtins.str:
+    def file_name(self) -> _builtins.str:
         """
         Represents the final filename in the filesystem
         """
         return pulumi.get(self, "file_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="configName")
-    def config_name(self) -> Optional[builtins.str]:
+    def config_name(self) -> Optional[_builtins.str]:
         """
         Name of the config that this references, but this is just provided for lookup/display purposes. The config in the reference will be identified by its ID
         """
         return pulumi.get(self, "config_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="fileGid")
-    def file_gid(self) -> Optional[builtins.str]:
+    def file_gid(self) -> Optional[_builtins.str]:
         """
         Represents the file GID. Defaults to `0`.
         """
         return pulumi.get(self, "file_gid")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="fileMode")
-    def file_mode(self) -> Optional[builtins.int]:
+    def file_mode(self) -> Optional[_builtins.int]:
         """
         Represents represents the FileMode of the file. Defaults to `0o444`.
         """
         return pulumi.get(self, "file_mode")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="fileUid")
-    def file_uid(self) -> Optional[builtins.str]:
+    def file_uid(self) -> Optional[_builtins.str]:
         """
         Represents the file UID. Defaults to `0`.
         """
@@ -2962,13 +3642,13 @@ class ServiceTaskSpecContainerSpecConfig(dict):
 @pulumi.output_type
 class ServiceTaskSpecContainerSpecDnsConfig(dict):
     def __init__(__self__, *,
-                 nameservers: Sequence[builtins.str],
-                 options: Optional[Sequence[builtins.str]] = None,
-                 searches: Optional[Sequence[builtins.str]] = None):
+                 nameservers: Sequence[_builtins.str],
+                 options: Optional[Sequence[_builtins.str]] = None,
+                 searches: Optional[Sequence[_builtins.str]] = None):
         """
-        :param Sequence[builtins.str] nameservers: The IP addresses of the name servers
-        :param Sequence[builtins.str] options: A list of internal resolver variables to be modified (e.g., `debug`, `ndots:3`, etc.)
-        :param Sequence[builtins.str] searches: A search list for host-name lookup
+        :param Sequence[_builtins.str] nameservers: The IP addresses of the name servers
+        :param Sequence[_builtins.str] options: A list of internal resolver variables to be modified (e.g., `debug`, `ndots:3`, etc.)
+        :param Sequence[_builtins.str] searches: A search list for host-name lookup
         """
         pulumi.set(__self__, "nameservers", nameservers)
         if options is not None:
@@ -2976,25 +3656,25 @@ class ServiceTaskSpecContainerSpecDnsConfig(dict):
         if searches is not None:
             pulumi.set(__self__, "searches", searches)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def nameservers(self) -> Sequence[builtins.str]:
+    def nameservers(self) -> Sequence[_builtins.str]:
         """
         The IP addresses of the name servers
         """
         return pulumi.get(self, "nameservers")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def options(self) -> Optional[Sequence[builtins.str]]:
+    def options(self) -> Optional[Sequence[_builtins.str]]:
         """
         A list of internal resolver variables to be modified (e.g., `debug`, `ndots:3`, etc.)
         """
         return pulumi.get(self, "options")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def searches(self) -> Optional[Sequence[builtins.str]]:
+    def searches(self) -> Optional[Sequence[_builtins.str]]:
         """
         A search list for host-name lookup
         """
@@ -3021,17 +3701,17 @@ class ServiceTaskSpecContainerSpecHealthcheck(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 tests: Sequence[builtins.str],
-                 interval: Optional[builtins.str] = None,
-                 retries: Optional[builtins.int] = None,
-                 start_period: Optional[builtins.str] = None,
-                 timeout: Optional[builtins.str] = None):
-        """
-        :param Sequence[builtins.str] tests: The test to perform as list
-        :param builtins.str interval: Time between running the check (ms|s|m|h). Defaults to `0s`.
-        :param builtins.int retries: Consecutive failures needed to report unhealthy. Defaults to `0`
-        :param builtins.str start_period: Start period for the container to initialize before counting retries towards unstable (ms|s|m|h). Defaults to `0s`.
-        :param builtins.str timeout: Maximum time to allow one check to run (ms|s|m|h). Defaults to `0s`.
+                 tests: Sequence[_builtins.str],
+                 interval: Optional[_builtins.str] = None,
+                 retries: Optional[_builtins.int] = None,
+                 start_period: Optional[_builtins.str] = None,
+                 timeout: Optional[_builtins.str] = None):
+        """
+        :param Sequence[_builtins.str] tests: The test to perform as list
+        :param _builtins.str interval: Time between running the check (ms|s|m|h). Defaults to `0s`.
+        :param _builtins.int retries: Consecutive failures needed to report unhealthy. Defaults to `0`
+        :param _builtins.str start_period: Start period for the container to initialize before counting retries towards unstable (ms|s|m|h). Defaults to `0s`.
+        :param _builtins.str timeout: Maximum time to allow one check to run (ms|s|m|h). Defaults to `0s`.
         """
         pulumi.set(__self__, "tests", tests)
         if interval is not None:
@@ -3043,41 +3723,41 @@ class ServiceTaskSpecContainerSpecHealthcheck(dict):
         if timeout is not None:
             pulumi.set(__self__, "timeout", timeout)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def tests(self) -> Sequence[builtins.str]:
+    def tests(self) -> Sequence[_builtins.str]:
         """
         The test to perform as list
         """
         return pulumi.get(self, "tests")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def interval(self) -> Optional[builtins.str]:
+    def interval(self) -> Optional[_builtins.str]:
         """
         Time between running the check (ms|s|m|h). Defaults to `0s`.
         """
         return pulumi.get(self, "interval")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def retries(self) -> Optional[builtins.int]:
+    def retries(self) -> Optional[_builtins.int]:
         """
         Consecutive failures needed to report unhealthy. Defaults to `0`
         """
         return pulumi.get(self, "retries")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="startPeriod")
-    def start_period(self) -> Optional[builtins.str]:
+    def start_period(self) -> Optional[_builtins.str]:
         """
         Start period for the container to initialize before counting retries towards unstable (ms|s|m|h). Defaults to `0s`.
         """
         return pulumi.get(self, "start_period")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def timeout(self) -> Optional[builtins.str]:
+    def timeout(self) -> Optional[_builtins.str]:
         """
         Maximum time to allow one check to run (ms|s|m|h). Defaults to `0s`.
         """
@@ -3087,26 +3767,26 @@ class ServiceTaskSpecContainerSpecHealthcheck(dict):
 @pulumi.output_type
 class ServiceTaskSpecContainerSpecHost(dict):
     def __init__(__self__, *,
-                 host: builtins.str,
-                 ip: builtins.str):
+                 host: _builtins.str,
+                 ip: _builtins.str):
         """
-        :param builtins.str host: The name of the host
-        :param builtins.str ip: The ip of the host
+        :param _builtins.str host: The name of the host
+        :param _builtins.str ip: The ip of the host
         """
         pulumi.set(__self__, "host", host)
         pulumi.set(__self__, "ip", ip)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def host(self) -> builtins.str:
+    def host(self) -> _builtins.str:
         """
         The name of the host
         """
         return pulumi.get(self, "host")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def ip(self) -> builtins.str:
+    def ip(self) -> _builtins.str:
         """
         The ip of the host
         """
@@ -3116,26 +3796,26 @@ class ServiceTaskSpecContainerSpecHost(dict):
 @pulumi.output_type
 class ServiceTaskSpecContainerSpecLabel(dict):
     def __init__(__self__, *,
-                 label: builtins.str,
-                 value: builtins.str):
+                 label: _builtins.str,
+                 value: _builtins.str):
         """
-        :param builtins.str label: Name of the label
-        :param builtins.str value: Value of the label
+        :param _builtins.str label: Name of the label
+        :param _builtins.str value: Value of the label
         """
         pulumi.set(__self__, "label", label)
         pulumi.set(__self__, "value", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def label(self) -> builtins.str:
+    def label(self) -> _builtins.str:
         """
         Name of the label
         """
         return pulumi.get(self, "label")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> builtins.str:
+    def value(self) -> _builtins.str:
         """
         Value of the label
         """
@@ -3168,19 +3848,19 @@ class ServiceTaskSpecContainerSpecMount(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 target: builtins.str,
-                 type: builtins.str,
+                 target: _builtins.str,
+                 type: _builtins.str,
                  bind_options: Optional['outputs.ServiceTaskSpecContainerSpecMountBindOptions'] = None,
-                 read_only: Optional[builtins.bool] = None,
-                 source: Optional[builtins.str] = None,
+                 read_only: Optional[_builtins.bool] = None,
+                 source: Optional[_builtins.str] = None,
                  tmpfs_options: Optional['outputs.ServiceTaskSpecContainerSpecMountTmpfsOptions'] = None,
                  volume_options: Optional['outputs.ServiceTaskSpecContainerSpecMountVolumeOptions'] = None):
         """
-        :param builtins.str target: Container path
-        :param builtins.str type: The mount type
+        :param _builtins.str target: Container path
+        :param _builtins.str type: The mount type
         :param 'ServiceTaskSpecContainerSpecMountBindOptionsArgs' bind_options: Optional configuration for the bind type
-        :param builtins.bool read_only: Whether the mount should be read-only
-        :param builtins.str source: Mount source (e.g. a volume name, a host path)
+        :param _builtins.bool read_only: Whether the mount should be read-only
+        :param _builtins.str source: Mount source (e.g. a volume name, a host path)
         :param 'ServiceTaskSpecContainerSpecMountTmpfsOptionsArgs' tmpfs_options: Optional configuration for the tmpfs type
         :param 'ServiceTaskSpecContainerSpecMountVolumeOptionsArgs' volume_options: Optional configuration for the volume type
         """
@@ -3197,23 +3877,23 @@ class ServiceTaskSpecContainerSpecMount(dict):
         if volume_options is not None:
             pulumi.set(__self__, "volume_options", volume_options)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def target(self) -> builtins.str:
+    def target(self) -> _builtins.str:
         """
         Container path
         """
         return pulumi.get(self, "target")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> builtins.str:
+    def type(self) -> _builtins.str:
         """
         The mount type
         """
         return pulumi.get(self, "type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="bindOptions")
     def bind_options(self) -> Optional['outputs.ServiceTaskSpecContainerSpecMountBindOptions']:
         """
@@ -3221,23 +3901,23 @@ class ServiceTaskSpecContainerSpecMount(dict):
         """
         return pulumi.get(self, "bind_options")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="readOnly")
-    def read_only(self) -> Optional[builtins.bool]:
+    def read_only(self) -> Optional[_builtins.bool]:
         """
         Whether the mount should be read-only
         """
         return pulumi.get(self, "read_only")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def source(self) -> Optional[builtins.str]:
+    def source(self) -> Optional[_builtins.str]:
         """
         Mount source (e.g. a volume name, a host path)
         """
         return pulumi.get(self, "source")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="tmpfsOptions")
     def tmpfs_options(self) -> Optional['outputs.ServiceTaskSpecContainerSpecMountTmpfsOptions']:
         """
@@ -3245,7 +3925,7 @@ class ServiceTaskSpecContainerSpecMount(dict):
         """
         return pulumi.get(self, "tmpfs_options")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="volumeOptions")
     def volume_options(self) -> Optional['outputs.ServiceTaskSpecContainerSpecMountVolumeOptions']:
         """
@@ -3257,16 +3937,16 @@ class ServiceTaskSpecContainerSpecMount(dict):
 @pulumi.output_type
 class ServiceTaskSpecContainerSpecMountBindOptions(dict):
     def __init__(__self__, *,
-                 propagation: Optional[builtins.str] = None):
+                 propagation: Optional[_builtins.str] = None):
         """
-        :param builtins.str propagation: Bind propagation refers to whether or not mounts created within a given bind-mount or named volume can be propagated to replicas of that mount. See the [docs](https://docs.docker.com/storage/bind-mounts/#configure-bind-propagation) for details. Defaults to `rprivate`
+        :param _builtins.str propagation: Bind propagation refers to whether or not mounts created within a given bind-mount or named volume can be propagated to replicas of that mount. See the [docs](https://docs.docker.com/storage/bind-mounts/#configure-bind-propagation) for details. Defaults to `rprivate`
         """
         if propagation is not None:
             pulumi.set(__self__, "propagation", propagation)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def propagation(self) -> Optional[builtins.str]:
+    def propagation(self) -> Optional[_builtins.str]:
         """
         Bind propagation refers to whether or not mounts created within a given bind-mount or named volume can be propagated to replicas of that mount. See the [docs](https://docs.docker.com/storage/bind-mounts/#configure-bind-propagation) for details. Defaults to `rprivate`
         """
@@ -3293,28 +3973,28 @@ class ServiceTaskSpecContainerSpecMountTmpfsOptions(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 mode: Optional[builtins.int] = None,
-                 size_bytes: Optional[builtins.int] = None):
+                 mode: Optional[_builtins.int] = None,
+                 size_bytes: Optional[_builtins.int] = None):
         """
-        :param builtins.int mode: The permission mode for the tmpfs mount in an integer
-        :param builtins.int size_bytes: The size for the tmpfs mount in bytes
+        :param _builtins.int mode: The permission mode for the tmpfs mount in an integer
+        :param _builtins.int size_bytes: The size for the tmpfs mount in bytes
         """
         if mode is not None:
             pulumi.set(__self__, "mode", mode)
         if size_bytes is not None:
             pulumi.set(__self__, "size_bytes", size_bytes)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def mode(self) -> Optional[builtins.int]:
+    def mode(self) -> Optional[_builtins.int]:
         """
         The permission mode for the tmpfs mount in an integer
         """
         return pulumi.get(self, "mode")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="sizeBytes")
-    def size_bytes(self) -> Optional[builtins.int]:
+    def size_bytes(self) -> Optional[_builtins.int]:
         """
         The size for the tmpfs mount in bytes
         """
@@ -3345,15 +4025,15 @@ class ServiceTaskSpecContainerSpecMountVolumeOptions(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 driver_name: Optional[builtins.str] = None,
-                 driver_options: Optional[Mapping[str, builtins.str]] = None,
+                 driver_name: Optional[_builtins.str] = None,
+                 driver_options: Optional[Mapping[str, _builtins.str]] = None,
                  labels: Optional[Sequence['outputs.ServiceTaskSpecContainerSpecMountVolumeOptionsLabel']] = None,
-                 no_copy: Optional[builtins.bool] = None):
+                 no_copy: Optional[_builtins.bool] = None):
         """
-        :param builtins.str driver_name: Name of the driver to use to create the volume
-        :param Mapping[str, builtins.str] driver_options: key/value map of driver specific options
+        :param _builtins.str driver_name: Name of the driver to use to create the volume
+        :param Mapping[str, _builtins.str] driver_options: key/value map of driver specific options
         :param Sequence['ServiceTaskSpecContainerSpecMountVolumeOptionsLabelArgs'] labels: User-defined key/value metadata
-        :param builtins.bool no_copy: Populate volume with data from the target
+        :param _builtins.bool no_copy: Populate volume with data from the target
         """
         if driver_name is not None:
             pulumi.set(__self__, "driver_name", driver_name)
@@ -3364,23 +4044,23 @@ class ServiceTaskSpecContainerSpecMountVolumeOptions(dict):
         if no_copy is not None:
             pulumi.set(__self__, "no_copy", no_copy)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="driverName")
-    def driver_name(self) -> Optional[builtins.str]:
+    def driver_name(self) -> Optional[_builtins.str]:
         """
         Name of the driver to use to create the volume
         """
         return pulumi.get(self, "driver_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="driverOptions")
-    def driver_options(self) -> Optional[Mapping[str, builtins.str]]:
+    def driver_options(self) -> Optional[Mapping[str, _builtins.str]]:
         """
         key/value map of driver specific options
         """
         return pulumi.get(self, "driver_options")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def labels(self) -> Optional[Sequence['outputs.ServiceTaskSpecContainerSpecMountVolumeOptionsLabel']]:
         """
@@ -3388,9 +4068,9 @@ class ServiceTaskSpecContainerSpecMountVolumeOptions(dict):
         """
         return pulumi.get(self, "labels")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="noCopy")
-    def no_copy(self) -> Optional[builtins.bool]:
+    def no_copy(self) -> Optional[_builtins.bool]:
         """
         Populate volume with data from the target
         """
@@ -3400,26 +4080,26 @@ class ServiceTaskSpecContainerSpecMountVolumeOptions(dict):
 @pulumi.output_type
 class ServiceTaskSpecContainerSpecMountVolumeOptionsLabel(dict):
     def __init__(__self__, *,
-                 label: builtins.str,
-                 value: builtins.str):
+                 label: _builtins.str,
+                 value: _builtins.str):
         """
-        :param builtins.str label: Name of the label
-        :param builtins.str value: Value of the label
+        :param _builtins.str label: Name of the label
+        :param _builtins.str value: Value of the label
         """
         pulumi.set(__self__, "label", label)
         pulumi.set(__self__, "value", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def label(self) -> builtins.str:
+    def label(self) -> _builtins.str:
         """
         Name of the label
         """
         return pulumi.get(self, "label")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> builtins.str:
+    def value(self) -> _builtins.str:
         """
         Value of the label
         """
@@ -3459,7 +4139,7 @@ class ServiceTaskSpecContainerSpecPrivileges(dict):
         if se_linux_context is not None:
             pulumi.set(__self__, "se_linux_context", se_linux_context)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="credentialSpec")
     def credential_spec(self) -> Optional['outputs.ServiceTaskSpecContainerSpecPrivilegesCredentialSpec']:
         """
@@ -3467,7 +4147,7 @@ class ServiceTaskSpecContainerSpecPrivileges(dict):
         """
         return pulumi.get(self, "credential_spec")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="seLinuxContext")
     def se_linux_context(self) -> Optional['outputs.ServiceTaskSpecContainerSpecPrivilegesSeLinuxContext']:
         """
@@ -3479,28 +4159,28 @@ class ServiceTaskSpecContainerSpecPrivileges(dict):
 @pulumi.output_type
 class ServiceTaskSpecContainerSpecPrivilegesCredentialSpec(dict):
     def __init__(__self__, *,
-                 file: Optional[builtins.str] = None,
-                 registry: Optional[builtins.str] = None):
+                 file: Optional[_builtins.str] = None,
+                 registry: Optional[_builtins.str] = None):
         """
-        :param builtins.str file: Load credential spec from this file
-        :param builtins.str registry: Load credential spec from this value in the Windows registry
+        :param _builtins.str file: Load credential spec from this file
+        :param _builtins.str registry: Load credential spec from this value in the Windows registry
         """
         if file is not None:
             pulumi.set(__self__, "file", file)
         if registry is not None:
             pulumi.set(__self__, "registry", registry)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def file(self) -> Optional[builtins.str]:
+    def file(self) -> Optional[_builtins.str]:
         """
         Load credential spec from this file
         """
         return pulumi.get(self, "file")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def registry(self) -> Optional[builtins.str]:
+    def registry(self) -> Optional[_builtins.str]:
         """
         Load credential spec from this value in the Windows registry
         """
@@ -3510,17 +4190,17 @@ class ServiceTaskSpecContainerSpecPrivilegesCredentialSpec(dict):
 @pulumi.output_type
 class ServiceTaskSpecContainerSpecPrivilegesSeLinuxContext(dict):
     def __init__(__self__, *,
-                 disable: Optional[builtins.bool] = None,
-                 level: Optional[builtins.str] = None,
-                 role: Optional[builtins.str] = None,
-                 type: Optional[builtins.str] = None,
-                 user: Optional[builtins.str] = None):
-        """
-        :param builtins.bool disable: Disable SELinux
-        :param builtins.str level: SELinux level label
-        :param builtins.str role: SELinux role label
-        :param builtins.str type: SELinux type label
-        :param builtins.str user: SELinux user label
+                 disable: Optional[_builtins.bool] = None,
+                 level: Optional[_builtins.str] = None,
+                 role: Optional[_builtins.str] = None,
+                 type: Optional[_builtins.str] = None,
+                 user: Optional[_builtins.str] = None):
+        """
+        :param _builtins.bool disable: Disable SELinux
+        :param _builtins.str level: SELinux level label
+        :param _builtins.str role: SELinux role label
+        :param _builtins.str type: SELinux type label
+        :param _builtins.str user: SELinux user label
         """
         if disable is not None:
             pulumi.set(__self__, "disable", disable)
@@ -3533,41 +4213,41 @@ class ServiceTaskSpecContainerSpecPrivilegesSeLinuxContext(dict):
         if user is not None:
             pulumi.set(__self__, "user", user)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def disable(self) -> Optional[builtins.bool]:
+    def disable(self) -> Optional[_builtins.bool]:
         """
         Disable SELinux
         """
         return pulumi.get(self, "disable")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def level(self) -> Optional[builtins.str]:
+    def level(self) -> Optional[_builtins.str]:
         """
         SELinux level label
         """
         return pulumi.get(self, "level")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def role(self) -> Optional[builtins.str]:
+    def role(self) -> Optional[_builtins.str]:
         """
         SELinux role label
         """
         return pulumi.get(self, "role")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> Optional[builtins.str]:
+    def type(self) -> Optional[_builtins.str]:
         """
         SELinux type label
         """
         return pulumi.get(self, "type")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def user(self) -> Optional[builtins.str]:
+    def user(self) -> Optional[_builtins.str]:
         """
         SELinux user label
         """
@@ -3604,19 +4284,19 @@ class ServiceTaskSpecContainerSpecSecret(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 file_name: builtins.str,
-                 secret_id: builtins.str,
-                 file_gid: Optional[builtins.str] = None,
-                 file_mode: Optional[builtins.int] = None,
-                 file_uid: Optional[builtins.str] = None,
-                 secret_name: Optional[builtins.str] = None):
-        """
-        :param builtins.str file_name: Represents the final filename in the filesystem
-        :param builtins.str secret_id: ID of the specific secret that we're referencing
-        :param builtins.str file_gid: Represents the file GID. Defaults to `0`
-        :param builtins.int file_mode: Represents represents the FileMode of the file. Defaults to `0o444`
-        :param builtins.str file_uid: Represents the file UID. Defaults to `0`
-        :param builtins.str secret_name: Name of the secret that this references, but this is just provided for lookup/display purposes. The config in the reference will be identified by its ID
+                 file_name: _builtins.str,
+                 secret_id: _builtins.str,
+                 file_gid: Optional[_builtins.str] = None,
+                 file_mode: Optional[_builtins.int] = None,
+                 file_uid: Optional[_builtins.str] = None,
+                 secret_name: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str file_name: Represents the final filename in the filesystem
+        :param _builtins.str secret_id: ID of the specific secret that we're referencing
+        :param _builtins.str file_gid: Represents the file GID. Defaults to `0`
+        :param _builtins.int file_mode: Represents represents the FileMode of the file. Defaults to `0o444`
+        :param _builtins.str file_uid: Represents the file UID. Defaults to `0`
+        :param _builtins.str secret_name: Name of the secret that this references, but this is just provided for lookup/display purposes. The config in the reference will be identified by its ID
         """
         pulumi.set(__self__, "file_name", file_name)
         pulumi.set(__self__, "secret_id", secret_id)
@@ -3629,49 +4309,49 @@ class ServiceTaskSpecContainerSpecSecret(dict):
         if secret_name is not None:
             pulumi.set(__self__, "secret_name", secret_name)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="fileName")
-    def file_name(self) -> builtins.str:
+    def file_name(self) -> _builtins.str:
         """
         Represents the final filename in the filesystem
         """
         return pulumi.get(self, "file_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="secretId")
-    def secret_id(self) -> builtins.str:
+    def secret_id(self) -> _builtins.str:
         """
         ID of the specific secret that we're referencing
         """
         return pulumi.get(self, "secret_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="fileGid")
-    def file_gid(self) -> Optional[builtins.str]:
+    def file_gid(self) -> Optional[_builtins.str]:
         """
         Represents the file GID. Defaults to `0`
         """
         return pulumi.get(self, "file_gid")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="fileMode")
-    def file_mode(self) -> Optional[builtins.int]:
+    def file_mode(self) -> Optional[_builtins.int]:
         """
         Represents represents the FileMode of the file. Defaults to `0o444`
         """
         return pulumi.get(self, "file_mode")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="fileUid")
-    def file_uid(self) -> Optional[builtins.str]:
+    def file_uid(self) -> Optional[_builtins.str]:
         """
         Represents the file UID. Defaults to `0`
         """
         return pulumi.get(self, "file_uid")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="secretName")
-    def secret_name(self) -> Optional[builtins.str]:
+    def secret_name(self) -> Optional[_builtins.str]:
         """
         Name of the secret that this references, but this is just provided for lookup/display purposes. The config in the reference will be identified by its ID
         """
@@ -3681,27 +4361,27 @@ class ServiceTaskSpecContainerSpecSecret(dict):
 @pulumi.output_type
 class ServiceTaskSpecLogDriver(dict):
     def __init__(__self__, *,
-                 name: builtins.str,
-                 options: Optional[Mapping[str, builtins.str]] = None):
+                 name: _builtins.str,
+                 options: Optional[Mapping[str, _builtins.str]] = None):
         """
-        :param builtins.str name: The logging driver to use
-        :param Mapping[str, builtins.str] options: The options for the logging driver
+        :param _builtins.str name: The logging driver to use
+        :param Mapping[str, _builtins.str] options: The options for the logging driver
         """
         pulumi.set(__self__, "name", name)
         if options is not None:
             pulumi.set(__self__, "options", options)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         The logging driver to use
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def options(self) -> Optional[Mapping[str, builtins.str]]:
+    def options(self) -> Optional[Mapping[str, _builtins.str]]:
         """
         The options for the logging driver
         """
@@ -3728,13 +4408,13 @@ class ServiceTaskSpecNetworksAdvanced(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 name: builtins.str,
-                 aliases: Optional[Sequence[builtins.str]] = None,
-                 driver_opts: Optional[Sequence[builtins.str]] = None):
+                 name: _builtins.str,
+                 aliases: Optional[Sequence[_builtins.str]] = None,
+                 driver_opts: Optional[Sequence[_builtins.str]] = None):
         """
-        :param builtins.str name: The name/id of the network.
-        :param Sequence[builtins.str] aliases: The network aliases of the container in the specific network.
-        :param Sequence[builtins.str] driver_opts: An array of driver options for the network, e.g. `opts1=value`
+        :param _builtins.str name: The name/id of the network.
+        :param Sequence[_builtins.str] aliases: The network aliases of the container in the specific network.
+        :param Sequence[_builtins.str] driver_opts: An array of driver options for the network, e.g. `opts1=value`
         """
         pulumi.set(__self__, "name", name)
         if aliases is not None:
@@ -3742,25 +4422,25 @@ class ServiceTaskSpecNetworksAdvanced(dict):
         if driver_opts is not None:
             pulumi.set(__self__, "driver_opts", driver_opts)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         The name/id of the network.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def aliases(self) -> Optional[Sequence[builtins.str]]:
+    def aliases(self) -> Optional[Sequence[_builtins.str]]:
         """
         The network aliases of the container in the specific network.
         """
         return pulumi.get(self, "aliases")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="driverOpts")
-    def driver_opts(self) -> Optional[Sequence[builtins.str]]:
+    def driver_opts(self) -> Optional[Sequence[_builtins.str]]:
         """
         An array of driver options for the network, e.g. `opts1=value`
         """
@@ -3787,15 +4467,15 @@ class ServiceTaskSpecPlacement(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 constraints: Optional[Sequence[builtins.str]] = None,
-                 max_replicas: Optional[builtins.int] = None,
+                 constraints: Optional[Sequence[_builtins.str]] = None,
+                 max_replicas: Optional[_builtins.int] = None,
                  platforms: Optional[Sequence['outputs.ServiceTaskSpecPlacementPlatform']] = None,
-                 prefs: Optional[Sequence[builtins.str]] = None):
+                 prefs: Optional[Sequence[_builtins.str]] = None):
         """
-        :param Sequence[builtins.str] constraints: An array of constraints. e.g.: `node.role==manager`
-        :param builtins.int max_replicas: Maximum number of replicas for per node (default value is `0`, which is unlimited)
+        :param Sequence[_builtins.str] constraints: An array of constraints. e.g.: `node.role==manager`
+        :param _builtins.int max_replicas: Maximum number of replicas for per node (default value is `0`, which is unlimited)
         :param Sequence['ServiceTaskSpecPlacementPlatformArgs'] platforms: Platforms stores all the platforms that the service's image can run on
-        :param Sequence[builtins.str] prefs: Preferences provide a way to make the scheduler aware of factors such as topology. They are provided in order from highest to lowest precedence, e.g.: `spread=node.role.manager`
+        :param Sequence[_builtins.str] prefs: Preferences provide a way to make the scheduler aware of factors such as topology. They are provided in order from highest to lowest precedence, e.g.: `spread=node.role.manager`
         """
         if constraints is not None:
             pulumi.set(__self__, "constraints", constraints)
@@ -3806,23 +4486,23 @@ class ServiceTaskSpecPlacement(dict):
         if prefs is not None:
             pulumi.set(__self__, "prefs", prefs)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def constraints(self) -> Optional[Sequence[builtins.str]]:
+    def constraints(self) -> Optional[Sequence[_builtins.str]]:
         """
         An array of constraints. e.g.: `node.role==manager`
         """
         return pulumi.get(self, "constraints")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="maxReplicas")
-    def max_replicas(self) -> Optional[builtins.int]:
+    def max_replicas(self) -> Optional[_builtins.int]:
         """
         Maximum number of replicas for per node (default value is `0`, which is unlimited)
         """
         return pulumi.get(self, "max_replicas")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def platforms(self) -> Optional[Sequence['outputs.ServiceTaskSpecPlacementPlatform']]:
         """
@@ -3830,9 +4510,9 @@ class ServiceTaskSpecPlacement(dict):
         """
         return pulumi.get(self, "platforms")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def prefs(self) -> Optional[Sequence[builtins.str]]:
+    def prefs(self) -> Optional[Sequence[_builtins.str]]:
         """
         Preferences provide a way to make the scheduler aware of factors such as topology. They are provided in order from highest to lowest precedence, e.g.: `spread=node.role.manager`
         """
@@ -3842,26 +4522,26 @@ class ServiceTaskSpecPlacement(dict):
 @pulumi.output_type
 class ServiceTaskSpecPlacementPlatform(dict):
     def __init__(__self__, *,
-                 architecture: builtins.str,
-                 os: builtins.str):
+                 architecture: _builtins.str,
+                 os: _builtins.str):
         """
-        :param builtins.str architecture: The architecture, e.g. `amd64`
-        :param builtins.str os: The operation system, e.g. `linux`
+        :param _builtins.str architecture: The architecture, e.g. `amd64`
+        :param _builtins.str os: The operation system, e.g. `linux`
         """
         pulumi.set(__self__, "architecture", architecture)
         pulumi.set(__self__, "os", os)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def architecture(self) -> builtins.str:
+    def architecture(self) -> _builtins.str:
         """
         The architecture, e.g. `amd64`
         """
         return pulumi.get(self, "architecture")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def os(self) -> builtins.str:
+    def os(self) -> _builtins.str:
         """
         The operation system, e.g. `linux`
         """
@@ -3882,7 +4562,7 @@ class ServiceTaskSpecResources(dict):
         if reservation is not None:
             pulumi.set(__self__, "reservation", reservation)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def limits(self) -> Optional['outputs.ServiceTaskSpecResourcesLimits']:
         """
@@ -3890,7 +4570,7 @@ class ServiceTaskSpecResources(dict):
         """
         return pulumi.get(self, "limits")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def reservation(self) -> Optional['outputs.ServiceTaskSpecResourcesReservation']:
         """
@@ -3921,28 +4601,28 @@ class ServiceTaskSpecResourcesLimits(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 memory_bytes: Optional[builtins.int] = None,
-                 nano_cpus: Optional[builtins.int] = None):
+                 memory_bytes: Optional[_builtins.int] = None,
+                 nano_cpus: Optional[_builtins.int] = None):
         """
-        :param builtins.int memory_bytes: The amounf of memory in bytes the container allocates
-        :param builtins.int nano_cpus: CPU shares in units of `1/1e9` (or `10^-9`) of the CPU. Should be at least `1000000`
+        :param _builtins.int memory_bytes: The amounf of memory in bytes the container allocates
+        :param _builtins.int nano_cpus: CPU shares in units of `1/1e9` (or `10^-9`) of the CPU. Should be at least `1000000`
         """
         if memory_bytes is not None:
             pulumi.set(__self__, "memory_bytes", memory_bytes)
         if nano_cpus is not None:
             pulumi.set(__self__, "nano_cpus", nano_cpus)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="memoryBytes")
-    def memory_bytes(self) -> Optional[builtins.int]:
+    def memory_bytes(self) -> Optional[_builtins.int]:
         """
         The amounf of memory in bytes the container allocates
         """
         return pulumi.get(self, "memory_bytes")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="nanoCpus")
-    def nano_cpus(self) -> Optional[builtins.int]:
+    def nano_cpus(self) -> Optional[_builtins.int]:
         """
         CPU shares in units of `1/1e9` (or `10^-9`) of the CPU. Should be at least `1000000`
         """
@@ -3974,12 +4654,12 @@ class ServiceTaskSpecResourcesReservation(dict):
 
     def __init__(__self__, *,
                  generic_resources: Optional['outputs.ServiceTaskSpecResourcesReservationGenericResources'] = None,
-                 memory_bytes: Optional[builtins.int] = None,
-                 nano_cpus: Optional[builtins.int] = None):
+                 memory_bytes: Optional[_builtins.int] = None,
+                 nano_cpus: Optional[_builtins.int] = None):
         """
         :param 'ServiceTaskSpecResourcesReservationGenericResourcesArgs' generic_resources: User-defined resources can be either Integer resources (e.g, `SSD=3`) or String resources (e.g, GPU=UUID1)
-        :param builtins.int memory_bytes: The amounf of memory in bytes the container allocates
-        :param builtins.int nano_cpus: CPU shares in units of 1/1e9 (or 10^-9) of the CPU. Should be at least `1000000`
+        :param _builtins.int memory_bytes: The amounf of memory in bytes the container allocates
+        :param _builtins.int nano_cpus: CPU shares in units of 1/1e9 (or 10^-9) of the CPU. Should be at least `1000000`
         """
         if generic_resources is not None:
             pulumi.set(__self__, "generic_resources", generic_resources)
@@ -3988,7 +4668,7 @@ class ServiceTaskSpecResourcesReservation(dict):
         if nano_cpus is not None:
             pulumi.set(__self__, "nano_cpus", nano_cpus)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="genericResources")
     def generic_resources(self) -> Optional['outputs.ServiceTaskSpecResourcesReservationGenericResources']:
         """
@@ -3996,17 +4676,17 @@ class ServiceTaskSpecResourcesReservation(dict):
         """
         return pulumi.get(self, "generic_resources")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="memoryBytes")
-    def memory_bytes(self) -> Optional[builtins.int]:
+    def memory_bytes(self) -> Optional[_builtins.int]:
         """
         The amounf of memory in bytes the container allocates
         """
         return pulumi.get(self, "memory_bytes")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="nanoCpus")
-    def nano_cpus(self) -> Optional[builtins.int]:
+    def nano_cpus(self) -> Optional[_builtins.int]:
         """
         CPU shares in units of 1/1e9 (or 10^-9) of the CPU. Should be at least `1000000`
         """
@@ -4035,28 +4715,28 @@ class ServiceTaskSpecResourcesReservationGenericResources(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 discrete_resources_specs: Optional[Sequence[builtins.str]] = None,
-                 named_resources_specs: Optional[Sequence[builtins.str]] = None):
+                 discrete_resources_specs: Optional[Sequence[_builtins.str]] = None,
+                 named_resources_specs: Optional[Sequence[_builtins.str]] = None):
         """
-        :param Sequence[builtins.str] discrete_resources_specs: The Integer resources
-        :param Sequence[builtins.str] named_resources_specs: The String resources
+        :param Sequence[_builtins.str] discrete_resources_specs: The Integer resources
+        :param Sequence[_builtins.str] named_resources_specs: The String resources
         """
         if discrete_resources_specs is not None:
             pulumi.set(__self__, "discrete_resources_specs", discrete_resources_specs)
         if named_resources_specs is not None:
             pulumi.set(__self__, "named_resources_specs", named_resources_specs)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="discreteResourcesSpecs")
-    def discrete_resources_specs(self) -> Optional[Sequence[builtins.str]]:
+    def discrete_resources_specs(self) -> Optional[Sequence[_builtins.str]]:
         """
         The Integer resources
         """
         return pulumi.get(self, "discrete_resources_specs")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="namedResourcesSpecs")
-    def named_resources_specs(self) -> Optional[Sequence[builtins.str]]:
+    def named_resources_specs(self) -> Optional[Sequence[_builtins.str]]:
         """
         The String resources
         """
@@ -4083,15 +4763,15 @@ class ServiceTaskSpecRestartPolicy(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 condition: Optional[builtins.str] = None,
-                 delay: Optional[builtins.str] = None,
-                 max_attempts: Optional[builtins.int] = None,
-                 window: Optional[builtins.str] = None):
+                 condition: Optional[_builtins.str] = None,
+                 delay: Optional[_builtins.str] = None,
+                 max_attempts: Optional[_builtins.int] = None,
+                 window: Optional[_builtins.str] = None):
         """
-        :param builtins.str condition: Condition for restart
-        :param builtins.str delay: Delay between restart attempts (ms|s|m|h)
-        :param builtins.int max_attempts: Maximum attempts to restart a given container before giving up (default value is `0`, which is ignored)
-        :param builtins.str window: The time window used to evaluate the restart policy (default value is `0`, which is unbounded) (ms|s|m|h)
+        :param _builtins.str condition: Condition for restart
+        :param _builtins.str delay: Delay between restart attempts (ms|s|m|h)
+        :param _builtins.int max_attempts: Maximum attempts to restart a given container before giving up (default value is `0`, which is ignored)
+        :param _builtins.str window: The time window used to evaluate the restart policy (default value is `0`, which is unbounded) (ms|s|m|h)
         """
         if condition is not None:
             pulumi.set(__self__, "condition", condition)
@@ -4102,33 +4782,33 @@ class ServiceTaskSpecRestartPolicy(dict):
         if window is not None:
             pulumi.set(__self__, "window", window)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def condition(self) -> Optional[builtins.str]:
+    def condition(self) -> Optional[_builtins.str]:
         """
         Condition for restart
         """
         return pulumi.get(self, "condition")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def delay(self) -> Optional[builtins.str]:
+    def delay(self) -> Optional[_builtins.str]:
         """
         Delay between restart attempts (ms|s|m|h)
         """
         return pulumi.get(self, "delay")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="maxAttempts")
-    def max_attempts(self) -> Optional[builtins.int]:
+    def max_attempts(self) -> Optional[_builtins.int]:
         """
         Maximum attempts to restart a given container before giving up (default value is `0`, which is ignored)
         """
         return pulumi.get(self, "max_attempts")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def window(self) -> Optional[builtins.str]:
+    def window(self) -> Optional[_builtins.str]:
         """
         The time window used to evaluate the restart policy (default value is `0`, which is unbounded) (ms|s|m|h)
         """
@@ -4157,19 +4837,19 @@ class ServiceUpdateConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 delay: Optional[builtins.str] = None,
-                 failure_action: Optional[builtins.str] = None,
-                 max_failure_ratio: Optional[builtins.str] = None,
-                 monitor: Optional[builtins.str] = None,
-                 order: Optional[builtins.str] = None,
-                 parallelism: Optional[builtins.int] = None):
-        """
-        :param builtins.str delay: Delay between task updates `(ns|us|ms|s|m|h)`. Defaults to `0s`.
-        :param builtins.str failure_action: Action on update failure: `pause`, `continue` or `rollback`. Defaults to `pause`.
-        :param builtins.str max_failure_ratio: Failure rate to tolerate during an update. Defaults to `0.0`.
-        :param builtins.str monitor: Duration after each task update to monitor for failure (ns|us|ms|s|m|h). Defaults to `5s`.
-        :param builtins.str order: Update order: either 'stop-first' or 'start-first'. Defaults to `stop-first`.
-        :param builtins.int parallelism: Maximum number of tasks to be updated in one iteration. Defaults to `1`
+                 delay: Optional[_builtins.str] = None,
+                 failure_action: Optional[_builtins.str] = None,
+                 max_failure_ratio: Optional[_builtins.str] = None,
+                 monitor: Optional[_builtins.str] = None,
+                 order: Optional[_builtins.str] = None,
+                 parallelism: Optional[_builtins.int] = None):
+        """
+        :param _builtins.str delay: Delay between task updates `(ns|us|ms|s|m|h)`. Defaults to `0s`.
+        :param _builtins.str failure_action: Action on update failure: `pause`, `continue` or `rollback`. Defaults to `pause`.
+        :param _builtins.str max_failure_ratio: Failure rate to tolerate during an update. Defaults to `0.0`.
+        :param _builtins.str monitor: Duration after each task update to monitor for failure (ns|us|ms|s|m|h). Defaults to `5s`.
+        :param _builtins.str order: Update order: either 'stop-first' or 'start-first'. Defaults to `stop-first`.
+        :param _builtins.int parallelism: Maximum number of tasks to be updated in one iteration. Defaults to `1`
         """
         if delay is not None:
             pulumi.set(__self__, "delay", delay)
@@ -4184,49 +4864,49 @@ class ServiceUpdateConfig(dict):
         if parallelism is not None:
             pulumi.set(__self__, "parallelism", parallelism)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def delay(self) -> Optional[builtins.str]:
+    def delay(self) -> Optional[_builtins.str]:
         """
         Delay between task updates `(ns|us|ms|s|m|h)`. Defaults to `0s`.
         """
         return pulumi.get(self, "delay")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="failureAction")
-    def failure_action(self) -> Optional[builtins.str]:
+    def failure_action(self) -> Optional[_builtins.str]:
         """
         Action on update failure: `pause`, `continue` or `rollback`. Defaults to `pause`.
         """
         return pulumi.get(self, "failure_action")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="maxFailureRatio")
-    def max_failure_ratio(self) -> Optional[builtins.str]:
+    def max_failure_ratio(self) -> Optional[_builtins.str]:
         """
         Failure rate to tolerate during an update. Defaults to `0.0`.
         """
         return pulumi.get(self, "max_failure_ratio")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def monitor(self) -> Optional[builtins.str]:
+    def monitor(self) -> Optional[_builtins.str]:
         """
         Duration after each task update to monitor for failure (ns|us|ms|s|m|h). Defaults to `5s`.
         """
         return pulumi.get(self, "monitor")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def order(self) -> Optional[builtins.str]:
+    def order(self) -> Optional[_builtins.str]:
         """
         Update order: either 'stop-first' or 'start-first'. Defaults to `stop-first`.
         """
         return pulumi.get(self, "order")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def parallelism(self) -> Optional[builtins.int]:
+    def parallelism(self) -> Optional[_builtins.int]:
         """
         Maximum number of tasks to be updated in one iteration. Defaults to `1`
         """
@@ -4236,26 +4916,26 @@ class ServiceUpdateConfig(dict):
 @pulumi.output_type
 class VolumeLabel(dict):
     def __init__(__self__, *,
-                 label: builtins.str,
-                 value: builtins.str):
+                 label: _builtins.str,
+                 value: _builtins.str):
         """
-        :param builtins.str label: Name of the label
-        :param builtins.str value: Value of the label
+        :param _builtins.str label: Name of the label
+        :param _builtins.str value: Value of the label
         """
         pulumi.set(__self__, "label", label)
         pulumi.set(__self__, "value", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def label(self) -> builtins.str:
+    def label(self) -> _builtins.str:
         """
         Name of the label
         """
         return pulumi.get(self, "label")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> builtins.str:
+    def value(self) -> _builtins.str:
         """
         Value of the label
         """
@@ -4265,15 +4945,15 @@ class VolumeLabel(dict):
 @pulumi.output_type
 class GetNetworkIpamConfigResult(dict):
     def __init__(__self__, *,
-                 aux_address: Optional[Mapping[str, builtins.str]] = None,
-                 gateway: Optional[builtins.str] = None,
-                 ip_range: Optional[builtins.str] = None,
-                 subnet: Optional[builtins.str] = None):
+                 aux_address: Optional[Mapping[str, _builtins.str]] = None,
+                 gateway: Optional[_builtins.str] = None,
+                 ip_range: Optional[_builtins.str] = None,
+                 subnet: Optional[_builtins.str] = None):
         """
-        :param Mapping[str, builtins.str] aux_address: Auxiliary IPv4 or IPv6 addresses used by Network driver
-        :param builtins.str gateway: The IP address of the gateway
-        :param builtins.str ip_range: The ip range in CIDR form
-        :param builtins.str subnet: The subnet in CIDR form
+        :param Mapping[str, _builtins.str] aux_address: Auxiliary IPv4 or IPv6 addresses used by Network driver
+        :param _builtins.str gateway: The IP address of the gateway
+        :param _builtins.str ip_range: The ip range in CIDR form
+        :param _builtins.str subnet: The subnet in CIDR form
         """
         if aux_address is not None:
             pulumi.set(__self__, "aux_address", aux_address)
@@ -4284,33 +4964,33 @@ class GetNetworkIpamConfigResult(dict):
         if subnet is not None:
             pulumi.set(__self__, "subnet", subnet)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="auxAddress")
-    def aux_address(self) -> Optional[Mapping[str, builtins.str]]:
+    def aux_address(self) -> Optional[Mapping[str, _builtins.str]]:
         """
         Auxiliary IPv4 or IPv6 addresses used by Network driver
         """
         return pulumi.get(self, "aux_address")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def gateway(self) -> Optional[builtins.str]:
+    def gateway(self) -> Optional[_builtins.str]:
         """
         The IP address of the gateway
         """
         return pulumi.get(self, "gateway")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipRange")
-    def ip_range(self) -> Optional[builtins.str]:
+    def ip_range(self) -> Optional[_builtins.str]:
         """
         The ip range in CIDR form
         """
         return pulumi.get(self, "ip_range")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def subnet(self) -> Optional[builtins.str]:
+    def subnet(self) -> Optional[_builtins.str]:
         """
         The subnet in CIDR form
         """
@@ -4320,37 +5000,37 @@ class GetNetworkIpamConfigResult(dict):
 @pulumi.output_type
 class GetRegistryImageManifestsAuthConfigResult(dict):
     def __init__(__self__, *,
-                 address: builtins.str,
-                 password: builtins.str,
-                 username: builtins.str):
+                 address: _builtins.str,
+                 password: _builtins.str,
+                 username: _builtins.str):
         """
-        :param builtins.str address: The address of the Docker registry.
-        :param builtins.str password: The password for the Docker registry.
-        :param builtins.str username: The username for the Docker registry.
+        :param _builtins.str address: The address of the Docker registry.
+        :param _builtins.str password: The password for the Docker registry.
+        :param _builtins.str username: The username for the Docker registry.
         """
         pulumi.set(__self__, "address", address)
         pulumi.set(__self__, "password", password)
         pulumi.set(__self__, "username", username)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def address(self) -> builtins.str:
+    def address(self) -> _builtins.str:
         """
         The address of the Docker registry.
         """
         return pulumi.get(self, "address")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def password(self) -> builtins.str:
+    def password(self) -> _builtins.str:
         """
         The password for the Docker registry.
         """
         return pulumi.get(self, "password")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def username(self) -> builtins.str:
+    def username(self) -> _builtins.str:
         """
         The username for the Docker registry.
         """
@@ -4360,48 +5040,48 @@ class GetRegistryImageManifestsAuthConfigResult(dict):
 @pulumi.output_type
 class GetRegistryImageManifestsManifestResult(dict):
     def __init__(__self__, *,
-                 architecture: builtins.str,
-                 media_type: builtins.str,
-                 os: builtins.str,
-                 sha256_digest: builtins.str):
+                 architecture: _builtins.str,
+                 media_type: _builtins.str,
+                 os: _builtins.str,
+                 sha256_digest: _builtins.str):
         """
-        :param builtins.str architecture: The platform architecture supported by the manifest.
-        :param builtins.str media_type: The media type of the manifest.
-        :param builtins.str os: The operating system supported by the manifest.
-        :param builtins.str sha256_digest: The content digest of the manifest, as stored in the registry.
+        :param _builtins.str architecture: The platform architecture supported by the manifest.
+        :param _builtins.str media_type: The media type of the manifest.
+        :param _builtins.str os: The operating system supported by the manifest.
+        :param _builtins.str sha256_digest: The content digest of the manifest, as stored in the registry.
         """
         pulumi.set(__self__, "architecture", architecture)
         pulumi.set(__self__, "media_type", media_type)
         pulumi.set(__self__, "os", os)
         pulumi.set(__self__, "sha256_digest", sha256_digest)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def architecture(self) -> builtins.str:
+    def architecture(self) -> _builtins.str:
         """
         The platform architecture supported by the manifest.
         """
         return pulumi.get(self, "architecture")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="mediaType")
-    def media_type(self) -> builtins.str:
+    def media_type(self) -> _builtins.str:
         """
         The media type of the manifest.
         """
         return pulumi.get(self, "media_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def os(self) -> builtins.str:
+    def os(self) -> _builtins.str:
         """
         The operating system supported by the manifest.
         """
         return pulumi.get(self, "os")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="sha256Digest")
-    def sha256_digest(self) -> builtins.str:
+    def sha256_digest(self) -> _builtins.str:
         """
         The content digest of the manifest, as stored in the registry.
         """