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

pulumi_docker/buildx/_inputs.py

@@ -14,27 +14,28 @@ __all__ = [
     'BuildContextArgs',
     'BuilderConfigArgs',
     'CacheFromAzureBlobArgs',
-    'CacheFromEntryArgs',
     'CacheFromGitHubActionsArgs',
     'CacheFromLocalArgs',
     'CacheFromRegistryArgs',
     'CacheFromS3Args',
+    'CacheFromArgs',
     'CacheToAzureBlobArgs',
-    'CacheToEntryArgs',
     'CacheToGitHubActionsArgs',
     'CacheToInlineArgs',
     'CacheToLocalArgs',
     'CacheToRegistryArgs',
     'CacheToS3Args',
+    'CacheToArgs',
     'ContextArgs',
     'DockerfileArgs',
+    'ExportCacheOnlyArgs',
     'ExportDockerArgs',
-    'ExportEntryArgs',
     'ExportImageArgs',
     'ExportLocalArgs',
     'ExportOCIArgs',
     'ExportRegistryArgs',
     'ExportTarArgs',
+    'ExportArgs',
     'RegistryAuthArgs',
     'SSHArgs',
 ]
@@ -188,135 +189,6 @@ class CacheFromAzureBlobArgs:
         pulumi.set(self, "secret_access_key", value)
 
 
-@pulumi.input_type
-class CacheFromEntryArgs:
-    def __init__(__self__, *,
-                 azblob: Optional[pulumi.Input['CacheFromAzureBlobArgs']] = None,
-                 disabled: Optional[pulumi.Input[bool]] = None,
-                 gha: Optional[pulumi.Input['CacheFromGitHubActionsArgs']] = None,
-                 local: Optional[pulumi.Input['CacheFromLocalArgs']] = None,
-                 raw: Optional[pulumi.Input[str]] = None,
-                 registry: Optional[pulumi.Input['CacheFromRegistryArgs']] = None,
-                 s3: Optional[pulumi.Input['CacheFromS3Args']] = None):
-        """
-        :param pulumi.Input['CacheFromAzureBlobArgs'] azblob: Upload build caches to Azure's blob storage service.
-        :param pulumi.Input[bool] disabled: When `true` this entry will be excluded. Defaults to `false`.
-        :param pulumi.Input['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 pulumi.Input['CacheFromLocalArgs'] local: A simple backend which caches images on your local filesystem.
-        :param pulumi.Input[str] raw: A raw string as you would provide it to the Docker CLI (e.g.,
-               `type=inline`).
-        :param pulumi.Input['CacheFromRegistryArgs'] registry: Upload build caches to remote registries.
-        :param pulumi.Input['CacheFromS3Args'] s3: Upload build caches to AWS S3 or an S3-compatible services such as
-               MinIO.
-        """
-        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 local is not None:
-            pulumi.set(__self__, "local", local)
-        if raw is not None:
-            pulumi.set(__self__, "raw", raw)
-        if registry is not None:
-            pulumi.set(__self__, "registry", registry)
-        if s3 is not None:
-            pulumi.set(__self__, "s3", s3)
-
-    @property
-    @pulumi.getter
-    def azblob(self) -> Optional[pulumi.Input['CacheFromAzureBlobArgs']]:
-        """
-        Upload build caches to Azure's blob storage service.
-        """
-        return pulumi.get(self, "azblob")
-
-    @azblob.setter
-    def azblob(self, value: Optional[pulumi.Input['CacheFromAzureBlobArgs']]):
-        pulumi.set(self, "azblob", value)
-
-    @property
-    @pulumi.getter
-    def disabled(self) -> Optional[pulumi.Input[bool]]:
-        """
-        When `true` this entry will be excluded. Defaults to `false`.
-        """
-        return pulumi.get(self, "disabled")
-
-    @disabled.setter
-    def disabled(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "disabled", value)
-
-    @property
-    @pulumi.getter
-    def gha(self) -> Optional[pulumi.Input['CacheFromGitHubActionsArgs']]:
-        """
-        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.
-        """
-        return pulumi.get(self, "gha")
-
-    @gha.setter
-    def gha(self, value: Optional[pulumi.Input['CacheFromGitHubActionsArgs']]):
-        pulumi.set(self, "gha", value)
-
-    @property
-    @pulumi.getter
-    def local(self) -> Optional[pulumi.Input['CacheFromLocalArgs']]:
-        """
-        A simple backend which caches images on your local filesystem.
-        """
-        return pulumi.get(self, "local")
-
-    @local.setter
-    def local(self, value: Optional[pulumi.Input['CacheFromLocalArgs']]):
-        pulumi.set(self, "local", value)
-
-    @property
-    @pulumi.getter
-    def raw(self) -> Optional[pulumi.Input[str]]:
-        """
-        A raw string as you would provide it to the Docker CLI (e.g.,
-        `type=inline`).
-        """
-        return pulumi.get(self, "raw")
-
-    @raw.setter
-    def raw(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "raw", value)
-
-    @property
-    @pulumi.getter
-    def registry(self) -> Optional[pulumi.Input['CacheFromRegistryArgs']]:
-        """
-        Upload build caches to remote registries.
-        """
-        return pulumi.get(self, "registry")
-
-    @registry.setter
-    def registry(self, value: Optional[pulumi.Input['CacheFromRegistryArgs']]):
-        pulumi.set(self, "registry", value)
-
-    @property
-    @pulumi.getter
-    def s3(self) -> Optional[pulumi.Input['CacheFromS3Args']]:
-        """
-        Upload build caches to AWS S3 or an S3-compatible services such as
-        MinIO.
-        """
-        return pulumi.get(self, "s3")
-
-    @s3.setter
-    def s3(self, value: Optional[pulumi.Input['CacheFromS3Args']]):
-        pulumi.set(self, "s3", value)
-
-
 @pulumi.input_type
 class CacheFromGitHubActionsArgs:
     def __init__(__self__, *,
@@ -635,6 +507,135 @@ class CacheFromS3Args:
         pulumi.set(self, "use_path_style", value)
 
 
+@pulumi.input_type
+class CacheFromArgs:
+    def __init__(__self__, *,
+                 azblob: Optional[pulumi.Input['CacheFromAzureBlobArgs']] = None,
+                 disabled: Optional[pulumi.Input[bool]] = None,
+                 gha: Optional[pulumi.Input['CacheFromGitHubActionsArgs']] = None,
+                 local: Optional[pulumi.Input['CacheFromLocalArgs']] = None,
+                 raw: Optional[pulumi.Input[str]] = None,
+                 registry: Optional[pulumi.Input['CacheFromRegistryArgs']] = None,
+                 s3: Optional[pulumi.Input['CacheFromS3Args']] = None):
+        """
+        :param pulumi.Input['CacheFromAzureBlobArgs'] azblob: Upload build caches to Azure's blob storage service.
+        :param pulumi.Input[bool] disabled: When `true` this entry will be excluded. Defaults to `false`.
+        :param pulumi.Input['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 pulumi.Input['CacheFromLocalArgs'] local: A simple backend which caches images on your local filesystem.
+        :param pulumi.Input[str] raw: A raw string as you would provide it to the Docker CLI (e.g.,
+               `type=inline`).
+        :param pulumi.Input['CacheFromRegistryArgs'] registry: Upload build caches to remote registries.
+        :param pulumi.Input['CacheFromS3Args'] s3: Upload build caches to AWS S3 or an S3-compatible services such as
+               MinIO.
+        """
+        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 local is not None:
+            pulumi.set(__self__, "local", local)
+        if raw is not None:
+            pulumi.set(__self__, "raw", raw)
+        if registry is not None:
+            pulumi.set(__self__, "registry", registry)
+        if s3 is not None:
+            pulumi.set(__self__, "s3", s3)
+
+    @property
+    @pulumi.getter
+    def azblob(self) -> Optional[pulumi.Input['CacheFromAzureBlobArgs']]:
+        """
+        Upload build caches to Azure's blob storage service.
+        """
+        return pulumi.get(self, "azblob")
+
+    @azblob.setter
+    def azblob(self, value: Optional[pulumi.Input['CacheFromAzureBlobArgs']]):
+        pulumi.set(self, "azblob", value)
+
+    @property
+    @pulumi.getter
+    def disabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        When `true` this entry will be excluded. Defaults to `false`.
+        """
+        return pulumi.get(self, "disabled")
+
+    @disabled.setter
+    def disabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "disabled", value)
+
+    @property
+    @pulumi.getter
+    def gha(self) -> Optional[pulumi.Input['CacheFromGitHubActionsArgs']]:
+        """
+        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.
+        """
+        return pulumi.get(self, "gha")
+
+    @gha.setter
+    def gha(self, value: Optional[pulumi.Input['CacheFromGitHubActionsArgs']]):
+        pulumi.set(self, "gha", value)
+
+    @property
+    @pulumi.getter
+    def local(self) -> Optional[pulumi.Input['CacheFromLocalArgs']]:
+        """
+        A simple backend which caches images on your local filesystem.
+        """
+        return pulumi.get(self, "local")
+
+    @local.setter
+    def local(self, value: Optional[pulumi.Input['CacheFromLocalArgs']]):
+        pulumi.set(self, "local", value)
+
+    @property
+    @pulumi.getter
+    def raw(self) -> Optional[pulumi.Input[str]]:
+        """
+        A raw string as you would provide it to the Docker CLI (e.g.,
+        `type=inline`).
+        """
+        return pulumi.get(self, "raw")
+
+    @raw.setter
+    def raw(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "raw", value)
+
+    @property
+    @pulumi.getter
+    def registry(self) -> Optional[pulumi.Input['CacheFromRegistryArgs']]:
+        """
+        Upload build caches to remote registries.
+        """
+        return pulumi.get(self, "registry")
+
+    @registry.setter
+    def registry(self, value: Optional[pulumi.Input['CacheFromRegistryArgs']]):
+        pulumi.set(self, "registry", value)
+
+    @property
+    @pulumi.getter
+    def s3(self) -> Optional[pulumi.Input['CacheFromS3Args']]:
+        """
+        Upload build caches to AWS S3 or an S3-compatible services such as
+        MinIO.
+        """
+        return pulumi.get(self, "s3")
+
+    @s3.setter
+    def s3(self, value: Optional[pulumi.Input['CacheFromS3Args']]):
+        pulumi.set(self, "s3", value)
+
+
 @pulumi.input_type
 class CacheToAzureBlobArgs:
     def __init__(__self__, *,
@@ -725,155 +726,6 @@ class CacheToAzureBlobArgs:
         pulumi.set(self, "secret_access_key", value)
 
 
-@pulumi.input_type
-class CacheToEntryArgs:
-    def __init__(__self__, *,
-                 azblob: Optional[pulumi.Input['CacheToAzureBlobArgs']] = None,
-                 disabled: Optional[pulumi.Input[bool]] = None,
-                 gha: Optional[pulumi.Input['CacheToGitHubActionsArgs']] = None,
-                 inline: Optional[pulumi.Input['CacheToInlineArgs']] = None,
-                 local: Optional[pulumi.Input['CacheToLocalArgs']] = None,
-                 raw: Optional[pulumi.Input[str]] = None,
-                 registry: Optional[pulumi.Input['CacheToRegistryArgs']] = None,
-                 s3: Optional[pulumi.Input['CacheToS3Args']] = None):
-        """
-        :param pulumi.Input['CacheToAzureBlobArgs'] azblob: Push cache to Azure's blob storage service.
-        :param pulumi.Input[bool] disabled: When `true` this entry will be excluded. Defaults to `false`.
-        :param pulumi.Input['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 pulumi.Input['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 pulumi.Input['CacheToLocalArgs'] local: A simple backend which caches imagines on your local filesystem.
-        :param pulumi.Input[str] raw: A raw string as you would provide it to the Docker CLI (e.g.,
-               `type=inline`)
-        :param pulumi.Input['CacheToRegistryArgs'] registry: Push caches to remote registries. Incompatible with the `docker` build
-               driver.
-        :param pulumi.Input['CacheToS3Args'] s3: Push cache to AWS S3 or S3-compatible services such as MinIO.
-        """
-        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:
-            pulumi.set(__self__, "raw", raw)
-        if registry is not None:
-            pulumi.set(__self__, "registry", registry)
-        if s3 is not None:
-            pulumi.set(__self__, "s3", s3)
-
-    @property
-    @pulumi.getter
-    def azblob(self) -> Optional[pulumi.Input['CacheToAzureBlobArgs']]:
-        """
-        Push cache to Azure's blob storage service.
-        """
-        return pulumi.get(self, "azblob")
-
-    @azblob.setter
-    def azblob(self, value: Optional[pulumi.Input['CacheToAzureBlobArgs']]):
-        pulumi.set(self, "azblob", value)
-
-    @property
-    @pulumi.getter
-    def disabled(self) -> Optional[pulumi.Input[bool]]:
-        """
-        When `true` this entry will be excluded. Defaults to `false`.
-        """
-        return pulumi.get(self, "disabled")
-
-    @disabled.setter
-    def disabled(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "disabled", value)
-
-    @property
-    @pulumi.getter
-    def gha(self) -> Optional[pulumi.Input['CacheToGitHubActionsArgs']]:
-        """
-        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.
-        """
-        return pulumi.get(self, "gha")
-
-    @gha.setter
-    def gha(self, value: Optional[pulumi.Input['CacheToGitHubActionsArgs']]):
-        pulumi.set(self, "gha", value)
-
-    @property
-    @pulumi.getter
-    def inline(self) -> Optional[pulumi.Input['CacheToInlineArgs']]:
-        """
-        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")
-
-    @inline.setter
-    def inline(self, value: Optional[pulumi.Input['CacheToInlineArgs']]):
-        pulumi.set(self, "inline", value)
-
-    @property
-    @pulumi.getter
-    def local(self) -> Optional[pulumi.Input['CacheToLocalArgs']]:
-        """
-        A simple backend which caches imagines on your local filesystem.
-        """
-        return pulumi.get(self, "local")
-
-    @local.setter
-    def local(self, value: Optional[pulumi.Input['CacheToLocalArgs']]):
-        pulumi.set(self, "local", value)
-
-    @property
-    @pulumi.getter
-    def raw(self) -> Optional[pulumi.Input[str]]:
-        """
-        A raw string as you would provide it to the Docker CLI (e.g.,
-        `type=inline`)
-        """
-        return pulumi.get(self, "raw")
-
-    @raw.setter
-    def raw(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "raw", value)
-
-    @property
-    @pulumi.getter
-    def registry(self) -> Optional[pulumi.Input['CacheToRegistryArgs']]:
-        """
-        Push caches to remote registries. Incompatible with the `docker` build
-        driver.
-        """
-        return pulumi.get(self, "registry")
-
-    @registry.setter
-    def registry(self, value: Optional[pulumi.Input['CacheToRegistryArgs']]):
-        pulumi.set(self, "registry", value)
-
-    @property
-    @pulumi.getter
-    def s3(self) -> Optional[pulumi.Input['CacheToS3Args']]:
-        """
-        Push cache to AWS S3 or S3-compatible services such as MinIO.
-        """
-        return pulumi.get(self, "s3")
-
-    @s3.setter
-    def s3(self, value: Optional[pulumi.Input['CacheToS3Args']]):
-        pulumi.set(self, "s3", value)
-
-
 @pulumi.input_type
 class CacheToGitHubActionsArgs:
     def __init__(__self__, *,
@@ -998,6 +850,9 @@ class CacheToGitHubActionsArgs:
 @pulumi.input_type
 class CacheToInlineArgs:
     def __init__(__self__):
+        """
+        Include an inline cache with the exported image.
+        """
         pass
 
 
@@ -1131,9 +986,12 @@ class CacheToRegistryArgs:
         :param pulumi.Input[bool] force_compression: Forcefully apply compression.
         :param pulumi.Input[bool] ignore_error: Ignore errors caused by failed cache exports.
         :param pulumi.Input[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`.
+               
+               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.
         :param pulumi.Input['CacheMode'] mode: The cache mode to use. Defaults to `min`.
         :param pulumi.Input[bool] oci_media_types: Whether to use OCI media types in exported manifests. Defaults to
                `true`.
@@ -1233,9 +1091,12 @@ class CacheToRegistryArgs:
     def image_manifest(self) -> Optional[pulumi.Input[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`.
 
-        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.
         """
         return pulumi.get(self, "image_manifest")
 
@@ -1478,6 +1339,155 @@ class CacheToS3Args:
         pulumi.set(self, "use_path_style", value)
 
 
+@pulumi.input_type
+class CacheToArgs:
+    def __init__(__self__, *,
+                 azblob: Optional[pulumi.Input['CacheToAzureBlobArgs']] = None,
+                 disabled: Optional[pulumi.Input[bool]] = None,
+                 gha: Optional[pulumi.Input['CacheToGitHubActionsArgs']] = None,
+                 inline: Optional[pulumi.Input['CacheToInlineArgs']] = None,
+                 local: Optional[pulumi.Input['CacheToLocalArgs']] = None,
+                 raw: Optional[pulumi.Input[str]] = None,
+                 registry: Optional[pulumi.Input['CacheToRegistryArgs']] = None,
+                 s3: Optional[pulumi.Input['CacheToS3Args']] = None):
+        """
+        :param pulumi.Input['CacheToAzureBlobArgs'] azblob: Push cache to Azure's blob storage service.
+        :param pulumi.Input[bool] disabled: When `true` this entry will be excluded. Defaults to `false`.
+        :param pulumi.Input['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 pulumi.Input['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 pulumi.Input['CacheToLocalArgs'] local: A simple backend which caches imagines on your local filesystem.
+        :param pulumi.Input[str] raw: A raw string as you would provide it to the Docker CLI (e.g.,
+               `type=inline`)
+        :param pulumi.Input['CacheToRegistryArgs'] registry: Push caches to remote registries. Incompatible with the `docker` build
+               driver.
+        :param pulumi.Input['CacheToS3Args'] s3: Push cache to AWS S3 or S3-compatible services such as MinIO.
+        """
+        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:
+            pulumi.set(__self__, "raw", raw)
+        if registry is not None:
+            pulumi.set(__self__, "registry", registry)
+        if s3 is not None:
+            pulumi.set(__self__, "s3", s3)
+
+    @property
+    @pulumi.getter
+    def azblob(self) -> Optional[pulumi.Input['CacheToAzureBlobArgs']]:
+        """
+        Push cache to Azure's blob storage service.
+        """
+        return pulumi.get(self, "azblob")
+
+    @azblob.setter
+    def azblob(self, value: Optional[pulumi.Input['CacheToAzureBlobArgs']]):
+        pulumi.set(self, "azblob", value)
+
+    @property
+    @pulumi.getter
+    def disabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        When `true` this entry will be excluded. Defaults to `false`.
+        """
+        return pulumi.get(self, "disabled")
+
+    @disabled.setter
+    def disabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "disabled", value)
+
+    @property
+    @pulumi.getter
+    def gha(self) -> Optional[pulumi.Input['CacheToGitHubActionsArgs']]:
+        """
+        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.
+        """
+        return pulumi.get(self, "gha")
+
+    @gha.setter
+    def gha(self, value: Optional[pulumi.Input['CacheToGitHubActionsArgs']]):
+        pulumi.set(self, "gha", value)
+
+    @property
+    @pulumi.getter
+    def inline(self) -> Optional[pulumi.Input['CacheToInlineArgs']]:
+        """
+        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")
+
+    @inline.setter
+    def inline(self, value: Optional[pulumi.Input['CacheToInlineArgs']]):
+        pulumi.set(self, "inline", value)
+
+    @property
+    @pulumi.getter
+    def local(self) -> Optional[pulumi.Input['CacheToLocalArgs']]:
+        """
+        A simple backend which caches imagines on your local filesystem.
+        """
+        return pulumi.get(self, "local")
+
+    @local.setter
+    def local(self, value: Optional[pulumi.Input['CacheToLocalArgs']]):
+        pulumi.set(self, "local", value)
+
+    @property
+    @pulumi.getter
+    def raw(self) -> Optional[pulumi.Input[str]]:
+        """
+        A raw string as you would provide it to the Docker CLI (e.g.,
+        `type=inline`)
+        """
+        return pulumi.get(self, "raw")
+
+    @raw.setter
+    def raw(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "raw", value)
+
+    @property
+    @pulumi.getter
+    def registry(self) -> Optional[pulumi.Input['CacheToRegistryArgs']]:
+        """
+        Push caches to remote registries. Incompatible with the `docker` build
+        driver.
+        """
+        return pulumi.get(self, "registry")
+
+    @registry.setter
+    def registry(self, value: Optional[pulumi.Input['CacheToRegistryArgs']]):
+        pulumi.set(self, "registry", value)
+
+    @property
+    @pulumi.getter
+    def s3(self) -> Optional[pulumi.Input['CacheToS3Args']]:
+        """
+        Push cache to AWS S3 or S3-compatible services such as MinIO.
+        """
+        return pulumi.get(self, "s3")
+
+    @s3.setter
+    def s3(self, value: Optional[pulumi.Input['CacheToS3Args']]):
+        pulumi.set(self, "s3", value)
+
+
 @pulumi.input_type
 class ContextArgs:
     def __init__(__self__, *,
@@ -1573,6 +1583,12 @@ class DockerfileArgs:
         pulumi.set(self, "location", value)
 
 
+@pulumi.input_type
+class ExportCacheOnlyArgs:
+    def __init__(__self__):
+        pass
+
+
 @pulumi.input_type
 class ExportDockerArgs:
     def __init__(__self__, *,
@@ -1601,257 +1617,120 @@ class ExportDockerArgs:
         if compression is not None:
             pulumi.set(__self__, "compression", compression)
         if compression_level is None:
-            compression_level = 0
-        if compression_level is not None:
-            pulumi.set(__self__, "compression_level", compression_level)
-        if dest is not None:
-            pulumi.set(__self__, "dest", dest)
-        if force_compression is None:
-            force_compression = False
-        if force_compression is not None:
-            pulumi.set(__self__, "force_compression", force_compression)
-        if names is not None:
-            pulumi.set(__self__, "names", names)
-        if oci_media_types is None:
-            oci_media_types = False
-        if oci_media_types is not None:
-            pulumi.set(__self__, "oci_media_types", oci_media_types)
-        if tar is None:
-            tar = True
-        if tar is not None:
-            pulumi.set(__self__, "tar", tar)
-
-    @property
-    @pulumi.getter
-    def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
-        """
-        Attach an arbitrary key/value annotation to the image.
-        """
-        return pulumi.get(self, "annotations")
-
-    @annotations.setter
-    def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
-        pulumi.set(self, "annotations", value)
-
-    @property
-    @pulumi.getter
-    def compression(self) -> Optional[pulumi.Input['CompressionType']]:
-        """
-        The compression type to use.
-        """
-        return pulumi.get(self, "compression")
-
-    @compression.setter
-    def compression(self, value: Optional[pulumi.Input['CompressionType']]):
-        pulumi.set(self, "compression", value)
-
-    @property
-    @pulumi.getter(name="compressionLevel")
-    def compression_level(self) -> Optional[pulumi.Input[int]]:
-        """
-        Compression level from 0 to 22.
-        """
-        return pulumi.get(self, "compression_level")
-
-    @compression_level.setter
-    def compression_level(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "compression_level", value)
-
-    @property
-    @pulumi.getter
-    def dest(self) -> Optional[pulumi.Input[str]]:
-        """
-        The local export path.
-        """
-        return pulumi.get(self, "dest")
-
-    @dest.setter
-    def dest(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "dest", value)
-
-    @property
-    @pulumi.getter(name="forceCompression")
-    def force_compression(self) -> Optional[pulumi.Input[bool]]:
-        """
-        Forcefully apply compression.
-        """
-        return pulumi.get(self, "force_compression")
-
-    @force_compression.setter
-    def force_compression(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "force_compression", value)
-
-    @property
-    @pulumi.getter
-    def names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
-        """
-        Specify images names to export. This is overridden if tags are already specified.
-        """
-        return pulumi.get(self, "names")
-
-    @names.setter
-    def names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
-        pulumi.set(self, "names", value)
-
-    @property
-    @pulumi.getter(name="ociMediaTypes")
-    def oci_media_types(self) -> Optional[pulumi.Input[bool]]:
-        """
-        Use OCI media types in exporter manifests.
-        """
-        return pulumi.get(self, "oci_media_types")
-
-    @oci_media_types.setter
-    def oci_media_types(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "oci_media_types", value)
-
-    @property
-    @pulumi.getter
-    def tar(self) -> Optional[pulumi.Input[bool]]:
-        """
-        Bundle the output into a tarball layout.
-        """
-        return pulumi.get(self, "tar")
-
-    @tar.setter
-    def tar(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "tar", value)
-
-
-@pulumi.input_type
-class ExportEntryArgs:
-    def __init__(__self__, *,
-                 disabled: Optional[pulumi.Input[bool]] = None,
-                 docker: Optional[pulumi.Input['ExportDockerArgs']] = None,
-                 image: Optional[pulumi.Input['ExportImageArgs']] = None,
-                 local: Optional[pulumi.Input['ExportLocalArgs']] = None,
-                 oci: Optional[pulumi.Input['ExportOCIArgs']] = None,
-                 raw: Optional[pulumi.Input[str]] = None,
-                 registry: Optional[pulumi.Input['ExportRegistryArgs']] = None,
-                 tar: Optional[pulumi.Input['ExportTarArgs']] = None):
-        """
-        :param pulumi.Input[bool] disabled: When `true` this entry will be excluded. Defaults to `false`.
-        :param pulumi.Input['ExportDockerArgs'] docker: Export as a Docker image layout.
-        :param pulumi.Input['ExportImageArgs'] image: Outputs the build result into a container image format.
-        :param pulumi.Input['ExportLocalArgs'] local: Export to a local directory as files and directories.
-        :param pulumi.Input['ExportOCIArgs'] oci: Identical to the Docker exporter but uses OCI media types by default.
-        :param pulumi.Input[str] raw: A raw string as you would provide it to the Docker CLI (e.g.,
-               `type=docker`)
-        :param pulumi.Input['ExportRegistryArgs'] registry: Identical to the Image exporter, but pushes by default.
-        :param pulumi.Input['ExportTarArgs'] tar: Export to a local directory as a tarball.
-        """
-        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)
+            compression_level = 0
+        if compression_level is not None:
+            pulumi.set(__self__, "compression_level", compression_level)
+        if dest is not None:
+            pulumi.set(__self__, "dest", dest)
+        if force_compression is None:
+            force_compression = False
+        if force_compression is not None:
+            pulumi.set(__self__, "force_compression", force_compression)
+        if names is not None:
+            pulumi.set(__self__, "names", names)
+        if oci_media_types is None:
+            oci_media_types = False
+        if oci_media_types is not None:
+            pulumi.set(__self__, "oci_media_types", oci_media_types)
+        if tar is None:
+            tar = True
         if tar is not None:
             pulumi.set(__self__, "tar", tar)
 
     @property
     @pulumi.getter
-    def disabled(self) -> Optional[pulumi.Input[bool]]:
+    def annotations(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
         """
-        When `true` this entry will be excluded. Defaults to `false`.
+        Attach an arbitrary key/value annotation to the image.
         """
-        return pulumi.get(self, "disabled")
+        return pulumi.get(self, "annotations")
 
-    @disabled.setter
-    def disabled(self, value: Optional[pulumi.Input[bool]]):
-        pulumi.set(self, "disabled", value)
+    @annotations.setter
+    def annotations(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
+        pulumi.set(self, "annotations", value)
 
     @property
     @pulumi.getter
-    def docker(self) -> Optional[pulumi.Input['ExportDockerArgs']]:
+    def compression(self) -> Optional[pulumi.Input['CompressionType']]:
         """
-        Export as a Docker image layout.
+        The compression type to use.
         """
-        return pulumi.get(self, "docker")
+        return pulumi.get(self, "compression")
 
-    @docker.setter
-    def docker(self, value: Optional[pulumi.Input['ExportDockerArgs']]):
-        pulumi.set(self, "docker", value)
+    @compression.setter
+    def compression(self, value: Optional[pulumi.Input['CompressionType']]):
+        pulumi.set(self, "compression", value)
 
     @property
-    @pulumi.getter
-    def image(self) -> Optional[pulumi.Input['ExportImageArgs']]:
+    @pulumi.getter(name="compressionLevel")
+    def compression_level(self) -> Optional[pulumi.Input[int]]:
         """
-        Outputs the build result into a container image format.
+        Compression level from 0 to 22.
         """
-        return pulumi.get(self, "image")
+        return pulumi.get(self, "compression_level")
 
-    @image.setter
-    def image(self, value: Optional[pulumi.Input['ExportImageArgs']]):
-        pulumi.set(self, "image", value)
+    @compression_level.setter
+    def compression_level(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "compression_level", value)
 
     @property
     @pulumi.getter
-    def local(self) -> Optional[pulumi.Input['ExportLocalArgs']]:
+    def dest(self) -> Optional[pulumi.Input[str]]:
         """
-        Export to a local directory as files and directories.
+        The local export path.
         """
-        return pulumi.get(self, "local")
+        return pulumi.get(self, "dest")
 
-    @local.setter
-    def local(self, value: Optional[pulumi.Input['ExportLocalArgs']]):
-        pulumi.set(self, "local", value)
+    @dest.setter
+    def dest(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "dest", value)
 
     @property
-    @pulumi.getter
-    def oci(self) -> Optional[pulumi.Input['ExportOCIArgs']]:
+    @pulumi.getter(name="forceCompression")
+    def force_compression(self) -> Optional[pulumi.Input[bool]]:
         """
-        Identical to the Docker exporter but uses OCI media types by default.
+        Forcefully apply compression.
         """
-        return pulumi.get(self, "oci")
+        return pulumi.get(self, "force_compression")
 
-    @oci.setter
-    def oci(self, value: Optional[pulumi.Input['ExportOCIArgs']]):
-        pulumi.set(self, "oci", value)
+    @force_compression.setter
+    def force_compression(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "force_compression", value)
 
     @property
     @pulumi.getter
-    def raw(self) -> Optional[pulumi.Input[str]]:
+    def names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
         """
-        A raw string as you would provide it to the Docker CLI (e.g.,
-        `type=docker`)
+        Specify images names to export. This is overridden if tags are already specified.
         """
-        return pulumi.get(self, "raw")
+        return pulumi.get(self, "names")
 
-    @raw.setter
-    def raw(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "raw", value)
+    @names.setter
+    def names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "names", value)
 
     @property
-    @pulumi.getter
-    def registry(self) -> Optional[pulumi.Input['ExportRegistryArgs']]:
+    @pulumi.getter(name="ociMediaTypes")
+    def oci_media_types(self) -> Optional[pulumi.Input[bool]]:
         """
-        Identical to the Image exporter, but pushes by default.
+        Use OCI media types in exporter manifests.
         """
-        return pulumi.get(self, "registry")
+        return pulumi.get(self, "oci_media_types")
 
-    @registry.setter
-    def registry(self, value: Optional[pulumi.Input['ExportRegistryArgs']]):
-        pulumi.set(self, "registry", value)
+    @oci_media_types.setter
+    def oci_media_types(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "oci_media_types", value)
 
     @property
     @pulumi.getter
-    def tar(self) -> Optional[pulumi.Input['ExportTarArgs']]:
+    def tar(self) -> Optional[pulumi.Input[bool]]:
         """
-        Export to a local directory as a tarball.
+        Bundle the output into a tarball layout.
         """
         return pulumi.get(self, "tar")
 
     @tar.setter
-    def tar(self, value: Optional[pulumi.Input['ExportTarArgs']]):
+    def tar(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "tar", value)
 
 
@@ -2524,6 +2403,161 @@ class ExportTarArgs:
         pulumi.set(self, "dest", value)
 
 
+@pulumi.input_type
+class ExportArgs:
+    def __init__(__self__, *,
+                 cacheonly: Optional[pulumi.Input['ExportCacheOnlyArgs']] = None,
+                 disabled: Optional[pulumi.Input[bool]] = None,
+                 docker: Optional[pulumi.Input['ExportDockerArgs']] = None,
+                 image: Optional[pulumi.Input['ExportImageArgs']] = None,
+                 local: Optional[pulumi.Input['ExportLocalArgs']] = None,
+                 oci: Optional[pulumi.Input['ExportOCIArgs']] = None,
+                 raw: Optional[pulumi.Input[str]] = None,
+                 registry: Optional[pulumi.Input['ExportRegistryArgs']] = None,
+                 tar: Optional[pulumi.Input['ExportTarArgs']] = None):
+        """
+        :param pulumi.Input['ExportCacheOnlyArgs'] cacheonly: A no-op export. Helpful for silencing the 'no exports' warning if you
+               just want to populate caches.
+        :param pulumi.Input[bool] disabled: When `true` this entry will be excluded. Defaults to `false`.
+        :param pulumi.Input['ExportDockerArgs'] docker: Export as a Docker image layout.
+        :param pulumi.Input['ExportImageArgs'] image: Outputs the build result into a container image format.
+        :param pulumi.Input['ExportLocalArgs'] local: Export to a local directory as files and directories.
+        :param pulumi.Input['ExportOCIArgs'] oci: Identical to the Docker exporter but uses OCI media types by default.
+        :param pulumi.Input[str] raw: A raw string as you would provide it to the Docker CLI (e.g.,
+               `type=docker`)
+        :param pulumi.Input['ExportRegistryArgs'] registry: Identical to the Image exporter, but pushes by default.
+        :param pulumi.Input['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[pulumi.Input['ExportCacheOnlyArgs']]:
+        """
+        A no-op export. Helpful for silencing the 'no exports' warning if you
+        just want to populate caches.
+        """
+        return pulumi.get(self, "cacheonly")
+
+    @cacheonly.setter
+    def cacheonly(self, value: Optional[pulumi.Input['ExportCacheOnlyArgs']]):
+        pulumi.set(self, "cacheonly", value)
+
+    @property
+    @pulumi.getter
+    def disabled(self) -> Optional[pulumi.Input[bool]]:
+        """
+        When `true` this entry will be excluded. Defaults to `false`.
+        """
+        return pulumi.get(self, "disabled")
+
+    @disabled.setter
+    def disabled(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "disabled", value)
+
+    @property
+    @pulumi.getter
+    def docker(self) -> Optional[pulumi.Input['ExportDockerArgs']]:
+        """
+        Export as a Docker image layout.
+        """
+        return pulumi.get(self, "docker")
+
+    @docker.setter
+    def docker(self, value: Optional[pulumi.Input['ExportDockerArgs']]):
+        pulumi.set(self, "docker", value)
+
+    @property
+    @pulumi.getter
+    def image(self) -> Optional[pulumi.Input['ExportImageArgs']]:
+        """
+        Outputs the build result into a container image format.
+        """
+        return pulumi.get(self, "image")
+
+    @image.setter
+    def image(self, value: Optional[pulumi.Input['ExportImageArgs']]):
+        pulumi.set(self, "image", value)
+
+    @property
+    @pulumi.getter
+    def local(self) -> Optional[pulumi.Input['ExportLocalArgs']]:
+        """
+        Export to a local directory as files and directories.
+        """
+        return pulumi.get(self, "local")
+
+    @local.setter
+    def local(self, value: Optional[pulumi.Input['ExportLocalArgs']]):
+        pulumi.set(self, "local", value)
+
+    @property
+    @pulumi.getter
+    def oci(self) -> Optional[pulumi.Input['ExportOCIArgs']]:
+        """
+        Identical to the Docker exporter but uses OCI media types by default.
+        """
+        return pulumi.get(self, "oci")
+
+    @oci.setter
+    def oci(self, value: Optional[pulumi.Input['ExportOCIArgs']]):
+        pulumi.set(self, "oci", value)
+
+    @property
+    @pulumi.getter
+    def raw(self) -> Optional[pulumi.Input[str]]:
+        """
+        A raw string as you would provide it to the Docker CLI (e.g.,
+        `type=docker`)
+        """
+        return pulumi.get(self, "raw")
+
+    @raw.setter
+    def raw(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "raw", value)
+
+    @property
+    @pulumi.getter
+    def registry(self) -> Optional[pulumi.Input['ExportRegistryArgs']]:
+        """
+        Identical to the Image exporter, but pushes by default.
+        """
+        return pulumi.get(self, "registry")
+
+    @registry.setter
+    def registry(self, value: Optional[pulumi.Input['ExportRegistryArgs']]):
+        pulumi.set(self, "registry", value)
+
+    @property
+    @pulumi.getter
+    def tar(self) -> Optional[pulumi.Input['ExportTarArgs']]:
+        """
+        Export to a local directory as a tarball.
+        """
+        return pulumi.get(self, "tar")
+
+    @tar.setter
+    def tar(self, value: Optional[pulumi.Input['ExportTarArgs']]):
+        pulumi.set(self, "tar", value)
+
+
 @pulumi.input_type
 class RegistryAuthArgs:
     def __init__(__self__, *,