pulumi-docker 4.6.0b1__py3-none-any.whl → 4.6.0b3__py3-none-any.whl

pulumi_docker/buildx/outputs.py

@@ -14,31 +14,31 @@ from ._enums import *
 __all__ = [
     'BuildContext',
     'BuilderConfig',
+    'CacheFrom',
     'CacheFromAzureBlob',
-    'CacheFromEntry',
     'CacheFromGitHubActions',
     'CacheFromLocal',
     'CacheFromRegistry',
     'CacheFromS3',
-    'CacheInline',
+    'CacheTo',
     'CacheToAzureBlob',
-    'CacheToEntry',
     'CacheToGitHubActions',
+    'CacheToInline',
     'CacheToLocal',
     'CacheToRegistry',
     'CacheToS3',
     'Context',
     'Dockerfile',
+    'Export',
+    'ExportCacheOnly',
     'ExportDocker',
-    'ExportEntry',
     'ExportImage',
     'ExportLocal',
     'ExportOCI',
     'ExportRegistry',
     'ExportTar',
-    'Manifest',
-    'ManifestPlatform',
     'RegistryAuth',
+    'SSH',
 ]
 
 @pulumi.output_type
@@ -104,6 +104,8 @@ class BuilderConfig(dict):
                
                Only `docker-container`, `kubernetes`, or `remote` drivers are
                supported. The legacy `docker` driver is not supported.
+               
+               Equivalent to Docker's `--builder` flag.
         """
         if name is not None:
             pulumi.set(__self__, "name", name)
@@ -116,90 +118,29 @@ class BuilderConfig(dict):
 
         Only `docker-container`, `kubernetes`, or `remote` drivers are
         supported. The legacy `docker` driver is not supported.
-        """
-        return pulumi.get(self, "name")
-
-
-@pulumi.output_type
-class CacheFromAzureBlob(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "accountUrl":
-            suggest = "account_url"
-        elif key == "secretAccessKey":
-            suggest = "secret_access_key"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in CacheFromAzureBlob. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        CacheFromAzureBlob.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        CacheFromAzureBlob.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 name: str,
-                 account_url: Optional[str] = None,
-                 secret_access_key: Optional[str] = None):
-        """
-        :param str name: The name of the cache image.
-        :param str account_url: Base URL of the storage account.
-        :param str secret_access_key: Blob storage account key.
-        """
-        pulumi.set(__self__, "name", name)
-        if account_url is not None:
-            pulumi.set(__self__, "account_url", account_url)
-        if secret_access_key is not None:
-            pulumi.set(__self__, "secret_access_key", secret_access_key)
 
-    @property
-    @pulumi.getter
-    def name(self) -> str:
-        """
-        The name of the cache image.
+        Equivalent to Docker's `--builder` flag.
         """
         return pulumi.get(self, "name")
 
-    @property
-    @pulumi.getter(name="accountUrl")
-    def account_url(self) -> Optional[str]:
-        """
-        Base URL of the storage account.
-        """
-        return pulumi.get(self, "account_url")
-
-    @property
-    @pulumi.getter(name="secretAccessKey")
-    def secret_access_key(self) -> Optional[str]:
-        """
-        Blob storage account key.
-        """
-        return pulumi.get(self, "secret_access_key")
-
 
 @pulumi.output_type
-class CacheFromEntry(dict):
+class CacheFrom(dict):
     def __init__(__self__, *,
                  azblob: Optional['outputs.CacheFromAzureBlob'] = None,
+                 disabled: Optional[bool] = None,
                  gha: Optional['outputs.CacheFromGitHubActions'] = None,
-                 inline: Optional['outputs.CacheInline'] = None,
                  local: Optional['outputs.CacheFromLocal'] = None,
                  raw: Optional[str] = None,
                  registry: Optional['outputs.CacheFromRegistry'] = None,
                  s3: Optional['outputs.CacheFromS3'] = None):
         """
         :param 'CacheFromAzureBlobArgs' azblob: Upload build caches to Azure's blob storage service.
+        :param bool disabled: When `true` this entry will be excluded. Defaults to `false`.
         :param 'CacheFromGitHubActionsArgs' gha: Recommended for use with GitHub Actions workflows.
                
                An action like `crazy-max/ghaction-github-runtime` is recommended to
                expose appropriate credentials to your GitHub workflow.
-        :param 'CacheInlineArgs' inline: The inline cache storage backend is the simplest implementation to get
-               started with, but it does not handle multi-stage builds. Consider the
-               registry cache backend instead.
         :param 'CacheFromLocalArgs' local: A simple backend which caches images on your local filesystem.
         :param str raw: A raw string as you would provide it to the Docker CLI (e.g.,
                `type=inline`).
@@ -209,10 +150,10 @@ class CacheFromEntry(dict):
         """
         if azblob is not None:
             pulumi.set(__self__, "azblob", azblob)
+        if disabled is not None:
+            pulumi.set(__self__, "disabled", disabled)
         if gha is not None:
             pulumi.set(__self__, "gha", gha)
-        if inline is not None:
-            pulumi.set(__self__, "inline", inline)
         if local is not None:
             pulumi.set(__self__, "local", local)
         if raw is not None:
@@ -230,6 +171,14 @@ class CacheFromEntry(dict):
         """
         return pulumi.get(self, "azblob")
 
+    @property
+    @pulumi.getter
+    def disabled(self) -> Optional[bool]:
+        """
+        When `true` this entry will be excluded. Defaults to `false`.
+        """
+        return pulumi.get(self, "disabled")
+
     @property
     @pulumi.getter
     def gha(self) -> Optional['outputs.CacheFromGitHubActions']:
@@ -241,16 +190,6 @@ class CacheFromEntry(dict):
         """
         return pulumi.get(self, "gha")
 
-    @property
-    @pulumi.getter
-    def inline(self) -> Optional['outputs.CacheInline']:
-        """
-        The inline cache storage backend is the simplest implementation to get
-        started with, but it does not handle multi-stage builds. Consider the
-        registry cache backend instead.
-        """
-        return pulumi.get(self, "inline")
-
     @property
     @pulumi.getter
     def local(self) -> Optional['outputs.CacheFromLocal']:
@@ -286,6 +225,67 @@ class CacheFromEntry(dict):
         return pulumi.get(self, "s3")
 
 
+@pulumi.output_type
+class CacheFromAzureBlob(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "accountUrl":
+            suggest = "account_url"
+        elif key == "secretAccessKey":
+            suggest = "secret_access_key"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CacheFromAzureBlob. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CacheFromAzureBlob.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CacheFromAzureBlob.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 name: str,
+                 account_url: Optional[str] = None,
+                 secret_access_key: Optional[str] = None):
+        """
+        :param str name: The name of the cache image.
+        :param str account_url: Base URL of the storage account.
+        :param str secret_access_key: Blob storage account key.
+        """
+        pulumi.set(__self__, "name", name)
+        if account_url is not None:
+            pulumi.set(__self__, "account_url", account_url)
+        if secret_access_key is not None:
+            pulumi.set(__self__, "secret_access_key", secret_access_key)
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of the cache image.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="accountUrl")
+    def account_url(self) -> Optional[str]:
+        """
+        Base URL of the storage account.
+        """
+        return pulumi.get(self, "account_url")
+
+    @property
+    @pulumi.getter(name="secretAccessKey")
+    def secret_access_key(self) -> Optional[str]:
+        """
+        Blob storage account key.
+        """
+        return pulumi.get(self, "secret_access_key")
+
+
 @pulumi.output_type
 class CacheFromGitHubActions(dict):
     def __init__(__self__, *,
@@ -570,119 +570,24 @@ class CacheFromS3(dict):
 
 
 @pulumi.output_type
-class CacheInline(dict):
-    def __init__(__self__):
-        pass
-
-
-@pulumi.output_type
-class CacheToAzureBlob(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "accountUrl":
-            suggest = "account_url"
-        elif key == "ignoreError":
-            suggest = "ignore_error"
-        elif key == "secretAccessKey":
-            suggest = "secret_access_key"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in CacheToAzureBlob. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        CacheToAzureBlob.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        CacheToAzureBlob.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 name: str,
-                 account_url: Optional[str] = None,
-                 ignore_error: Optional[bool] = None,
-                 mode: Optional['CacheMode'] = None,
-                 secret_access_key: Optional[str] = None):
-        """
-        :param str name: The name of the cache image.
-        :param str account_url: Base URL of the storage account.
-        :param bool ignore_error: Ignore errors caused by failed cache exports.
-        :param 'CacheMode' mode: The cache mode to use. Defaults to `min`.
-        :param str secret_access_key: Blob storage account key.
-        """
-        pulumi.set(__self__, "name", name)
-        if account_url is not None:
-            pulumi.set(__self__, "account_url", account_url)
-        if ignore_error is None:
-            ignore_error = False
-        if ignore_error is not None:
-            pulumi.set(__self__, "ignore_error", ignore_error)
-        if mode is None:
-            mode = 'min'
-        if mode is not None:
-            pulumi.set(__self__, "mode", mode)
-        if secret_access_key is not None:
-            pulumi.set(__self__, "secret_access_key", secret_access_key)
-
-    @property
-    @pulumi.getter
-    def name(self) -> str:
-        """
-        The name of the cache image.
-        """
-        return pulumi.get(self, "name")
-
-    @property
-    @pulumi.getter(name="accountUrl")
-    def account_url(self) -> Optional[str]:
-        """
-        Base URL of the storage account.
-        """
-        return pulumi.get(self, "account_url")
-
-    @property
-    @pulumi.getter(name="ignoreError")
-    def ignore_error(self) -> Optional[bool]:
-        """
-        Ignore errors caused by failed cache exports.
-        """
-        return pulumi.get(self, "ignore_error")
-
-    @property
-    @pulumi.getter
-    def mode(self) -> Optional['CacheMode']:
-        """
-        The cache mode to use. Defaults to `min`.
-        """
-        return pulumi.get(self, "mode")
-
-    @property
-    @pulumi.getter(name="secretAccessKey")
-    def secret_access_key(self) -> Optional[str]:
-        """
-        Blob storage account key.
-        """
-        return pulumi.get(self, "secret_access_key")
-
-
-@pulumi.output_type
-class CacheToEntry(dict):
+class CacheTo(dict):
     def __init__(__self__, *,
                  azblob: Optional['outputs.CacheToAzureBlob'] = None,
+                 disabled: Optional[bool] = None,
                  gha: Optional['outputs.CacheToGitHubActions'] = None,
-                 inline: Optional['outputs.CacheInline'] = None,
+                 inline: Optional['outputs.CacheToInline'] = None,
                  local: Optional['outputs.CacheToLocal'] = None,
                  raw: Optional[str] = None,
                  registry: Optional['outputs.CacheToRegistry'] = None,
                  s3: Optional['outputs.CacheToS3'] = None):
         """
         :param 'CacheToAzureBlobArgs' azblob: Push cache to Azure's blob storage service.
+        :param bool disabled: When `true` this entry will be excluded. Defaults to `false`.
         :param 'CacheToGitHubActionsArgs' gha: Recommended for use with GitHub Actions workflows.
                
                An action like `crazy-max/ghaction-github-runtime` is recommended to
                expose appropriate credentials to your GitHub workflow.
-        :param 'CacheInlineArgs' inline: The inline cache storage backend is the simplest implementation to get
+        :param 'CacheToInlineArgs' inline: The inline cache storage backend is the simplest implementation to get
                started with, but it does not handle multi-stage builds. Consider the
                `registry` cache backend instead.
         :param 'CacheToLocalArgs' local: A simple backend which caches imagines on your local filesystem.
@@ -694,6 +599,8 @@ class CacheToEntry(dict):
         """
         if azblob is not None:
             pulumi.set(__self__, "azblob", azblob)
+        if disabled is not None:
+            pulumi.set(__self__, "disabled", disabled)
         if gha is not None:
             pulumi.set(__self__, "gha", gha)
         if inline is not None:
@@ -715,6 +622,14 @@ class CacheToEntry(dict):
         """
         return pulumi.get(self, "azblob")
 
+    @property
+    @pulumi.getter
+    def disabled(self) -> Optional[bool]:
+        """
+        When `true` this entry will be excluded. Defaults to `false`.
+        """
+        return pulumi.get(self, "disabled")
+
     @property
     @pulumi.getter
     def gha(self) -> Optional['outputs.CacheToGitHubActions']:
@@ -728,7 +643,7 @@ class CacheToEntry(dict):
 
     @property
     @pulumi.getter
-    def inline(self) -> Optional['outputs.CacheInline']:
+    def inline(self) -> Optional['outputs.CacheToInline']:
         """
         The inline cache storage backend is the simplest implementation to get
         started with, but it does not handle multi-stage builds. Consider the
@@ -771,6 +686,97 @@ class CacheToEntry(dict):
         return pulumi.get(self, "s3")
 
 
+@pulumi.output_type
+class CacheToAzureBlob(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "accountUrl":
+            suggest = "account_url"
+        elif key == "ignoreError":
+            suggest = "ignore_error"
+        elif key == "secretAccessKey":
+            suggest = "secret_access_key"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in CacheToAzureBlob. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        CacheToAzureBlob.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        CacheToAzureBlob.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 name: str,
+                 account_url: Optional[str] = None,
+                 ignore_error: Optional[bool] = None,
+                 mode: Optional['CacheMode'] = None,
+                 secret_access_key: Optional[str] = None):
+        """
+        :param str name: The name of the cache image.
+        :param str account_url: Base URL of the storage account.
+        :param bool ignore_error: Ignore errors caused by failed cache exports.
+        :param 'CacheMode' mode: The cache mode to use. Defaults to `min`.
+        :param str secret_access_key: Blob storage account key.
+        """
+        pulumi.set(__self__, "name", name)
+        if account_url is not None:
+            pulumi.set(__self__, "account_url", account_url)
+        if ignore_error is None:
+            ignore_error = False
+        if ignore_error is not None:
+            pulumi.set(__self__, "ignore_error", ignore_error)
+        if mode is None:
+            mode = 'min'
+        if mode is not None:
+            pulumi.set(__self__, "mode", mode)
+        if secret_access_key is not None:
+            pulumi.set(__self__, "secret_access_key", secret_access_key)
+
+    @property
+    @pulumi.getter
+    def name(self) -> str:
+        """
+        The name of the cache image.
+        """
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter(name="accountUrl")
+    def account_url(self) -> Optional[str]:
+        """
+        Base URL of the storage account.
+        """
+        return pulumi.get(self, "account_url")
+
+    @property
+    @pulumi.getter(name="ignoreError")
+    def ignore_error(self) -> Optional[bool]:
+        """
+        Ignore errors caused by failed cache exports.
+        """
+        return pulumi.get(self, "ignore_error")
+
+    @property
+    @pulumi.getter
+    def mode(self) -> Optional['CacheMode']:
+        """
+        The cache mode to use. Defaults to `min`.
+        """
+        return pulumi.get(self, "mode")
+
+    @property
+    @pulumi.getter(name="secretAccessKey")
+    def secret_access_key(self) -> Optional[str]:
+        """
+        Blob storage account key.
+        """
+        return pulumi.get(self, "secret_access_key")
+
+
 @pulumi.output_type
 class CacheToGitHubActions(dict):
     @staticmethod
@@ -889,6 +895,18 @@ class CacheToGitHubActions(dict):
         return pulumi.get(self, "url")
 
 
+@pulumi.output_type
+class CacheToInline(dict):
+    """
+    Include an inline cache with the exported image.
+    """
+    def __init__(__self__):
+        """
+        Include an inline cache with the exported image.
+        """
+        pass
+
+
 @pulumi.output_type
 class CacheToLocal(dict):
     @staticmethod
@@ -1041,11 +1059,14 @@ class CacheToRegistry(dict):
         :param bool force_compression: Forcefully apply compression.
         :param bool ignore_error: Ignore errors caused by failed cache exports.
         :param bool image_manifest: Export cache manifest as an OCI-compatible image manifest instead of a
-               manifest list (requires OCI media types).
+               manifest list. Requires `ociMediaTypes` to also be `true`.
                
-               Defaults to `false`.
+               Some registries like AWS ECR will not work with caching if this is
+               `false`.
+               
+               Defaults to `false` to match Docker's default behavior.
         :param 'CacheMode' mode: The cache mode to use. Defaults to `min`.
-        :param bool oci_media_types: Whether to use OCI mediatypes in exported manifests. Defaults to
+        :param bool oci_media_types: Whether to use OCI media types in exported manifests. Defaults to
                `true`.
         """
         pulumi.set(__self__, "ref", ref)
@@ -1123,9 +1144,12 @@ class CacheToRegistry(dict):
     def image_manifest(self) -> Optional[bool]:
         """
         Export cache manifest as an OCI-compatible image manifest instead of a
-        manifest list (requires OCI media types).
+        manifest list. Requires `ociMediaTypes` to also be `true`.
+
+        Some registries like AWS ECR will not work with caching if this is
+        `false`.
 
-        Defaults to `false`.
+        Defaults to `false` to match Docker's default behavior.
         """
         return pulumi.get(self, "image_manifest")
 
@@ -1141,7 +1165,7 @@ class CacheToRegistry(dict):
     @pulumi.getter(name="ociMediaTypes")
     def oci_media_types(self) -> Optional[bool]:
         """
-        Whether to use OCI mediatypes in exported manifests. Defaults to
+        Whether to use OCI media types in exported manifests. Defaults to
         `true`.
         """
         return pulumi.get(self, "oci_media_types")
@@ -1326,92 +1350,225 @@ class CacheToS3(dict):
     @pulumi.getter(name="sessionToken")
     def session_token(self) -> Optional[str]:
         """
-        Defaults to `$AWS_SESSION_TOKEN`.
+        Defaults to `$AWS_SESSION_TOKEN`.
+        """
+        return pulumi.get(self, "session_token")
+
+    @property
+    @pulumi.getter(name="usePathStyle")
+    def use_path_style(self) -> Optional[bool]:
+        """
+        Uses `bucket` in the URL instead of hostname when `true`.
+        """
+        return pulumi.get(self, "use_path_style")
+
+
+@pulumi.output_type
+class Context(dict):
+    def __init__(__self__, *,
+                 location: str):
+        """
+        :param str location: Resources to use for build context.
+               
+               The location can be:
+               * A relative or absolute path to a local directory (`.`, `./app`,
+                 `/app`, etc.).
+               * A remote URL of a Git repository, tarball, or plain text file
+                 (`https://github.com/user/myrepo.git`, `http://server/context.tar.gz`,
+                 etc.).
+        """
+        pulumi.set(__self__, "location", location)
+
+    @property
+    @pulumi.getter
+    def location(self) -> str:
+        """
+        Resources to use for build context.
+
+        The location can be:
+        * A relative or absolute path to a local directory (`.`, `./app`,
+          `/app`, etc.).
+        * A remote URL of a Git repository, tarball, or plain text file
+          (`https://github.com/user/myrepo.git`, `http://server/context.tar.gz`,
+          etc.).
+        """
+        return pulumi.get(self, "location")
+
+
+@pulumi.output_type
+class Dockerfile(dict):
+    def __init__(__self__, *,
+                 inline: Optional[str] = None,
+                 location: Optional[str] = None):
+        """
+        :param str inline: Raw Dockerfile contents.
+               
+               Conflicts with `location`.
+               
+               Equivalent to invoking Docker with `-f -`.
+        :param str location: Location of the Dockerfile to use.
+               
+               Can be a relative or absolute path to a local file, or a remote URL.
+               
+               Defaults to `${context.location}/Dockerfile` if context is on-disk.
+               
+               Conflicts with `inline`.
+        """
+        if inline is not None:
+            pulumi.set(__self__, "inline", inline)
+        if location is not None:
+            pulumi.set(__self__, "location", location)
+
+    @property
+    @pulumi.getter
+    def inline(self) -> Optional[str]:
+        """
+        Raw Dockerfile contents.
+
+        Conflicts with `location`.
+
+        Equivalent to invoking Docker with `-f -`.
+        """
+        return pulumi.get(self, "inline")
+
+    @property
+    @pulumi.getter
+    def location(self) -> Optional[str]:
+        """
+        Location of the Dockerfile to use.
+
+        Can be a relative or absolute path to a local file, or a remote URL.
+
+        Defaults to `${context.location}/Dockerfile` if context is on-disk.
+
+        Conflicts with `inline`.
+        """
+        return pulumi.get(self, "location")
+
+
+@pulumi.output_type
+class Export(dict):
+    def __init__(__self__, *,
+                 cacheonly: Optional['outputs.ExportCacheOnly'] = None,
+                 disabled: Optional[bool] = None,
+                 docker: Optional['outputs.ExportDocker'] = None,
+                 image: Optional['outputs.ExportImage'] = None,
+                 local: Optional['outputs.ExportLocal'] = None,
+                 oci: Optional['outputs.ExportOCI'] = None,
+                 raw: Optional[str] = None,
+                 registry: Optional['outputs.ExportRegistry'] = None,
+                 tar: Optional['outputs.ExportTar'] = None):
+        """
+        :param 'ExportCacheOnlyArgs' cacheonly: A no-op export. Helpful for silencing the 'no exports' warning if you
+               just want to populate caches.
+        :param bool disabled: When `true` this entry will be excluded. Defaults to `false`.
+        :param 'ExportDockerArgs' docker: Export as a Docker image layout.
+        :param 'ExportImageArgs' image: Outputs the build result into a container image format.
+        :param 'ExportLocalArgs' local: Export to a local directory as files and directories.
+        :param 'ExportOCIArgs' oci: Identical to the Docker exporter but uses OCI media types by default.
+        :param str raw: A raw string as you would provide it to the Docker CLI (e.g.,
+               `type=docker`)
+        :param 'ExportRegistryArgs' registry: Identical to the Image exporter, but pushes by default.
+        :param 'ExportTarArgs' tar: Export to a local directory as a tarball.
+        """
+        if cacheonly is not None:
+            pulumi.set(__self__, "cacheonly", cacheonly)
+        if disabled is not None:
+            pulumi.set(__self__, "disabled", disabled)
+        if docker is not None:
+            pulumi.set(__self__, "docker", docker)
+        if image is not None:
+            pulumi.set(__self__, "image", image)
+        if local is not None:
+            pulumi.set(__self__, "local", local)
+        if oci is not None:
+            pulumi.set(__self__, "oci", oci)
+        if raw is not None:
+            pulumi.set(__self__, "raw", raw)
+        if registry is not None:
+            pulumi.set(__self__, "registry", registry)
+        if tar is not None:
+            pulumi.set(__self__, "tar", tar)
+
+    @property
+    @pulumi.getter
+    def cacheonly(self) -> Optional['outputs.ExportCacheOnly']:
+        """
+        A no-op export. Helpful for silencing the 'no exports' warning if you
+        just want to populate caches.
+        """
+        return pulumi.get(self, "cacheonly")
+
+    @property
+    @pulumi.getter
+    def disabled(self) -> Optional[bool]:
+        """
+        When `true` this entry will be excluded. Defaults to `false`.
+        """
+        return pulumi.get(self, "disabled")
+
+    @property
+    @pulumi.getter
+    def docker(self) -> Optional['outputs.ExportDocker']:
+        """
+        Export as a Docker image layout.
         """
-        return pulumi.get(self, "session_token")
+        return pulumi.get(self, "docker")
 
     @property
-    @pulumi.getter(name="usePathStyle")
-    def use_path_style(self) -> Optional[bool]:
+    @pulumi.getter
+    def image(self) -> Optional['outputs.ExportImage']:
         """
-        Uses `bucket` in the URL instead of hostname when `true`.
+        Outputs the build result into a container image format.
         """
-        return pulumi.get(self, "use_path_style")
-
+        return pulumi.get(self, "image")
 
-@pulumi.output_type
-class Context(dict):
-    def __init__(__self__, *,
-                 location: str):
+    @property
+    @pulumi.getter
+    def local(self) -> Optional['outputs.ExportLocal']:
         """
-        :param str location: Resources to use for build context.
-               
-               The location can be:
-               * A relative or absolute path to a local directory (`.`, `./app`,
-                 `/app`, etc.).
-               * A remote URL of a Git repository, tarball, or plain text file
-                 (`https://github.com/user/myrepo.git`, `http://server/context.tar.gz`,
-                 etc.).
+        Export to a local directory as files and directories.
         """
-        pulumi.set(__self__, "location", location)
+        return pulumi.get(self, "local")
 
     @property
     @pulumi.getter
-    def location(self) -> str:
+    def oci(self) -> Optional['outputs.ExportOCI']:
         """
-        Resources to use for build context.
-
-        The location can be:
-        * A relative or absolute path to a local directory (`.`, `./app`,
-          `/app`, etc.).
-        * A remote URL of a Git repository, tarball, or plain text file
-          (`https://github.com/user/myrepo.git`, `http://server/context.tar.gz`,
-          etc.).
+        Identical to the Docker exporter but uses OCI media types by default.
         """
-        return pulumi.get(self, "location")
-
+        return pulumi.get(self, "oci")
 
-@pulumi.output_type
-class Dockerfile(dict):
-    def __init__(__self__, *,
-                 inline: Optional[str] = None,
-                 location: Optional[str] = None):
+    @property
+    @pulumi.getter
+    def raw(self) -> Optional[str]:
         """
-        :param str inline: Raw Dockerfile contents.
-               
-               Conflicts with `location`.
-        :param str location: Location of the Dockerfile to use.
-               
-               Can be a relative or absolute path to a local file, or a remote URL.
-               
-               Conflicts with `inline`.
+        A raw string as you would provide it to the Docker CLI (e.g.,
+        `type=docker`)
         """
-        if inline is not None:
-            pulumi.set(__self__, "inline", inline)
-        if location is not None:
-            pulumi.set(__self__, "location", location)
+        return pulumi.get(self, "raw")
 
     @property
     @pulumi.getter
-    def inline(self) -> Optional[str]:
+    def registry(self) -> Optional['outputs.ExportRegistry']:
         """
-        Raw Dockerfile contents.
-
-        Conflicts with `location`.
+        Identical to the Image exporter, but pushes by default.
         """
-        return pulumi.get(self, "inline")
+        return pulumi.get(self, "registry")
 
     @property
     @pulumi.getter
-    def location(self) -> Optional[str]:
+    def tar(self) -> Optional['outputs.ExportTar']:
         """
-        Location of the Dockerfile to use.
+        Export to a local directory as a tarball.
+        """
+        return pulumi.get(self, "tar")
 
-        Can be a relative or absolute path to a local file, or a remote URL.
 
-        Conflicts with `inline`.
-        """
-        return pulumi.get(self, "location")
+@pulumi.output_type
+class ExportCacheOnly(dict):
+    def __init__(__self__):
+        pass
 
 
 @pulumi.output_type
@@ -1548,113 +1705,6 @@ class ExportDocker(dict):
         return pulumi.get(self, "tar")
 
 
-@pulumi.output_type
-class ExportEntry(dict):
-    def __init__(__self__, *,
-                 docker: Optional['outputs.ExportDocker'] = None,
-                 image: Optional['outputs.ExportImage'] = None,
-                 local: Optional['outputs.ExportLocal'] = None,
-                 manifests: Optional[Sequence['outputs.Manifest']] = None,
-                 oci: Optional['outputs.ExportOCI'] = None,
-                 raw: Optional[str] = None,
-                 registry: Optional['outputs.ExportRegistry'] = None,
-                 tar: Optional['outputs.ExportTar'] = None):
-        """
-        :param 'ExportDockerArgs' docker: Export as a Docker image layout.
-        :param 'ExportImageArgs' image: Outputs the build result into a container image format.
-        :param 'ExportLocalArgs' local: Export to a local directory as files and directories.
-        :param Sequence['ManifestArgs'] manifests: An output property populated for exporters that pushed image
-               manifest(s) to a registry.
-        :param 'ExportOCIArgs' oci: Identical to the Docker exporter but uses OCI media types by default.
-        :param str raw: A raw string as you would provide it to the Docker CLI (e.g.,
-               `type=docker`)
-        :param 'ExportRegistryArgs' registry: Identical to the Image exporter, but pushes by default.
-        :param 'ExportTarArgs' tar: Export to a local directory as a tarball.
-        """
-        if docker is not None:
-            pulumi.set(__self__, "docker", docker)
-        if image is not None:
-            pulumi.set(__self__, "image", image)
-        if local is not None:
-            pulumi.set(__self__, "local", local)
-        if manifests is not None:
-            pulumi.set(__self__, "manifests", manifests)
-        if oci is not None:
-            pulumi.set(__self__, "oci", oci)
-        if raw is not None:
-            pulumi.set(__self__, "raw", raw)
-        if registry is not None:
-            pulumi.set(__self__, "registry", registry)
-        if tar is not None:
-            pulumi.set(__self__, "tar", tar)
-
-    @property
-    @pulumi.getter
-    def docker(self) -> Optional['outputs.ExportDocker']:
-        """
-        Export as a Docker image layout.
-        """
-        return pulumi.get(self, "docker")
-
-    @property
-    @pulumi.getter
-    def image(self) -> Optional['outputs.ExportImage']:
-        """
-        Outputs the build result into a container image format.
-        """
-        return pulumi.get(self, "image")
-
-    @property
-    @pulumi.getter
-    def local(self) -> Optional['outputs.ExportLocal']:
-        """
-        Export to a local directory as files and directories.
-        """
-        return pulumi.get(self, "local")
-
-    @property
-    @pulumi.getter
-    def manifests(self) -> Optional[Sequence['outputs.Manifest']]:
-        """
-        An output property populated for exporters that pushed image
-        manifest(s) to a registry.
-        """
-        return pulumi.get(self, "manifests")
-
-    @property
-    @pulumi.getter
-    def oci(self) -> Optional['outputs.ExportOCI']:
-        """
-        Identical to the Docker exporter but uses OCI media types by default.
-        """
-        return pulumi.get(self, "oci")
-
-    @property
-    @pulumi.getter
-    def raw(self) -> Optional[str]:
-        """
-        A raw string as you would provide it to the Docker CLI (e.g.,
-        `type=docker`)
-        """
-        return pulumi.get(self, "raw")
-
-    @property
-    @pulumi.getter
-    def registry(self) -> Optional['outputs.ExportRegistry']:
-        """
-        Identical to the Image exporter, but pushes by default.
-        """
-        return pulumi.get(self, "registry")
-
-    @property
-    @pulumi.getter
-    def tar(self) -> Optional['outputs.ExportTar']:
-        """
-        Export to a local directory as a tarball.
-        """
-        return pulumi.get(self, "tar")
-
-
 @pulumi.output_type
 class ExportImage(dict):
     @staticmethod
@@ -1711,7 +1761,7 @@ class ExportImage(dict):
         :param bool push: Push after creating the image.
         :param bool push_by_digest: Push image without name.
         :param bool store: Store resulting images to the worker's image store and ensure all of
-               its blobs are in the content store. 
+               its blobs are in the content store.
                
                Defaults to `true`.
                
@@ -1850,7 +1900,7 @@ class ExportImage(dict):
     def store(self) -> Optional[bool]:
         """
         Store resulting images to the worker's image store and ensure all of
-        its blobs are in the content store. 
+        its blobs are in the content store.
 
         Defaults to `true`.
 
@@ -2077,7 +2127,7 @@ class ExportRegistry(dict):
         :param bool push: Push after creating the image.
         :param bool push_by_digest: Push image without name.
         :param bool store: Store resulting images to the worker's image store and ensure all of
-               its blobs are in the content store. 
+               its blobs are in the content store.
                
                Defaults to `true`.
                
@@ -2218,7 +2268,7 @@ class ExportRegistry(dict):
     def store(self) -> Optional[bool]:
         """
         Store resulting images to the worker's image store and ensure all of
-        its blobs are in the content store. 
+        its blobs are in the content store.
 
         Defaults to `true`.
 
@@ -2255,86 +2305,6 @@ class ExportTar(dict):
         return pulumi.get(self, "dest")
 
 
-@pulumi.output_type
-class Manifest(dict):
-    def __init__(__self__, *,
-                 digest: str,
-                 platform: 'outputs.ManifestPlatform',
-                 ref: str,
-                 size: int):
-        """
-        :param str digest: The SHA256 digest of the manifest.
-        :param 'ManifestPlatformArgs' platform: The manifest's platform.
-        :param str ref: The manifest's canonical ref.
-        :param int size: The size of the manifest in bytes.
-        """
-        pulumi.set(__self__, "digest", digest)
-        pulumi.set(__self__, "platform", platform)
-        pulumi.set(__self__, "ref", ref)
-        pulumi.set(__self__, "size", size)
-
-    @property
-    @pulumi.getter
-    def digest(self) -> str:
-        """
-        The SHA256 digest of the manifest.
-        """
-        return pulumi.get(self, "digest")
-
-    @property
-    @pulumi.getter
-    def platform(self) -> 'outputs.ManifestPlatform':
-        """
-        The manifest's platform.
-        """
-        return pulumi.get(self, "platform")
-
-    @property
-    @pulumi.getter
-    def ref(self) -> str:
-        """
-        The manifest's canonical ref.
-        """
-        return pulumi.get(self, "ref")
-
-    @property
-    @pulumi.getter
-    def size(self) -> int:
-        """
-        The size of the manifest in bytes.
-        """
-        return pulumi.get(self, "size")
-
-
-@pulumi.output_type
-class ManifestPlatform(dict):
-    def __init__(__self__, *,
-                 architecture: str,
-                 os: str):
-        """
-        :param str architecture: The manifest's architecture.
-        :param str os: The manifest's operating systen.
-        """
-        pulumi.set(__self__, "architecture", architecture)
-        pulumi.set(__self__, "os", os)
-
-    @property
-    @pulumi.getter
-    def architecture(self) -> str:
-        """
-        The manifest's architecture.
-        """
-        return pulumi.get(self, "architecture")
-
-    @property
-    @pulumi.getter
-    def os(self) -> str:
-        """
-        The manifest's operating systen.
-        """
-        return pulumi.get(self, "os")
-
-
 @pulumi.output_type
 class RegistryAuth(dict):
     def __init__(__self__, *,
@@ -2377,3 +2347,53 @@ class RegistryAuth(dict):
         return pulumi.get(self, "username")
 
 
+@pulumi.output_type
+class SSH(dict):
+    def __init__(__self__, *,
+                 id: str,
+                 paths: Optional[Sequence[str]] = None):
+        """
+        :param str id: Useful for distinguishing different servers that are part of the same
+               build.
+               
+               A value of `default` is appropriate if only dealing with a single host.
+        :param Sequence[str] paths: SSH agent socket or private keys to expose to the build under the given
+               identifier.
+               
+               Defaults to `[$SSH_AUTH_SOCK]`.
+               
+               Note that your keys are **not** automatically added when using an
+               agent. Run `ssh-add -l` locally to confirm which public keys are
+               visible to the agent; these will be exposed to your build.
+        """
+        pulumi.set(__self__, "id", id)
+        if paths is not None:
+            pulumi.set(__self__, "paths", paths)
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        Useful for distinguishing different servers that are part of the same
+        build.
+
+        A value of `default` is appropriate if only dealing with a single host.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def paths(self) -> Optional[Sequence[str]]:
+        """
+        SSH agent socket or private keys to expose to the build under the given
+        identifier.
+
+        Defaults to `[$SSH_AUTH_SOCK]`.
+
+        Note that your keys are **not** automatically added when using an
+        agent. Run `ssh-add -l` locally to confirm which public keys are
+        visible to the agent; these will be exposed to your build.
+        """
+        return pulumi.get(self, "paths")
+
+