pulumi-docker-build/sdk/python/pulumi_docker_build/outputs.py

# coding=utf-8
# *** 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 as _builtins
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from . import _utilities
from . import outputs
from ._enums import *

__all__ = [
    'BuildContext',
    'BuilderConfig',
    'CacheFrom',
    'CacheFromAzureBlob',
    'CacheFromGitHubActions',
    'CacheFromLocal',
    'CacheFromRegistry',
    'CacheFromS3',
    'CacheTo',
    'CacheToAzureBlob',
    'CacheToGitHubActions',
    'CacheToInline',
    'CacheToLocal',
    'CacheToRegistry',
    'CacheToS3',
    'Context',
    'Dockerfile',
    'Export',
    'ExportCacheOnly',
    'ExportDocker',
    'ExportImage',
    'ExportLocal',
    'ExportOCI',
    'ExportRegistry',
    'ExportTar',
    'Registry',
    'SSH',
]

@pulumi.output_type
class BuildContext(dict):
    def __init__(__self__, *,
                 location: _builtins.str,
                 named: Optional[Mapping[str, 'outputs.Context']] = None):
        """
        :param _builtins.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.).
        :param Mapping[str, 'Context'] named: Additional build contexts to use.
               
               These contexts are accessed with `FROM name` or `--from=name`
               statements when using Dockerfile 1.4+ syntax.
               
               Values can be local paths, HTTP URLs, or  `docker-image://` images.
        """
        pulumi.set(__self__, "location", location)
        if named is not None:
            pulumi.set(__self__, "named", named)

    @_builtins.property
    @pulumi.getter
    def location(self) -> _builtins.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")

    @_builtins.property
    @pulumi.getter
    def named(self) -> Optional[Mapping[str, 'outputs.Context']]:
        """
        Additional build contexts to use.

        These contexts are accessed with `FROM name` or `--from=name`
        statements when using Dockerfile 1.4+ syntax.

        Values can be local paths, HTTP URLs, or  `docker-image://` images.
        """
        return pulumi.get(self, "named")


@pulumi.output_type
class BuilderConfig(dict):
    def __init__(__self__, *,
                 name: Optional[_builtins.str] = None):
        """
        :param _builtins.str name: Name of an existing buildx builder to use.
               
               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)

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        Name of an existing buildx builder to use.

        Only `docker-container`, `kubernetes`, or `remote` drivers are
        supported. The legacy `docker` driver is not supported.

        Equivalent to Docker's `--builder` flag.
        """
        return pulumi.get(self, "name")


@pulumi.output_type
class CacheFrom(dict):
    def __init__(__self__, *,
                 azblob: Optional['outputs.CacheFromAzureBlob'] = None,
                 disabled: Optional[_builtins.bool] = None,
                 gha: Optional['outputs.CacheFromGitHubActions'] = None,
                 local: Optional['outputs.CacheFromLocal'] = None,
                 raw: Optional[_builtins.str] = None,
                 registry: Optional['outputs.CacheFromRegistry'] = None,
                 s3: Optional['outputs.CacheFromS3'] = None):
        """
        :param 'CacheFromAzureBlob' azblob: Upload build caches to Azure's blob storage service.
        :param _builtins.bool disabled: When `true` this entry will be excluded. Defaults to `false`.
        :param 'CacheFromGitHubActions' 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 'CacheFromLocal' local: A simple backend which caches images on your local filesystem.
        :param _builtins.str raw: A raw string as you would provide it to the Docker CLI (e.g.,
               `type=inline`).
        :param 'CacheFromRegistry' registry: Upload build caches to remote registries.
        :param 'CacheFromS3' 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)

    @_builtins.property
    @pulumi.getter
    def azblob(self) -> Optional['outputs.CacheFromAzureBlob']:
        """
        Upload build caches to Azure's blob storage service.
        """
        return pulumi.get(self, "azblob")

    @_builtins.property
    @pulumi.getter
    def disabled(self) -> Optional[_builtins.bool]:
        """
        When `true` this entry will be excluded. Defaults to `false`.
        """
        return pulumi.get(self, "disabled")

    @_builtins.property
    @pulumi.getter
    def gha(self) -> Optional['outputs.CacheFromGitHubActions']:
        """
        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")

    @_builtins.property
    @pulumi.getter
    def local(self) -> Optional['outputs.CacheFromLocal']:
        """
        A simple backend which caches images on your local filesystem.
        """
        return pulumi.get(self, "local")

    @_builtins.property
    @pulumi.getter
    def raw(self) -> Optional[_builtins.str]:
        """
        A raw string as you would provide it to the Docker CLI (e.g.,
        `type=inline`).
        """
        return pulumi.get(self, "raw")

    @_builtins.property
    @pulumi.getter
    def registry(self) -> Optional['outputs.CacheFromRegistry']:
        """
        Upload build caches to remote registries.
        """
        return pulumi.get(self, "registry")

    @_builtins.property
    @pulumi.getter
    def s3(self) -> Optional['outputs.CacheFromS3']:
        """
        Upload build caches to AWS S3 or an S3-compatible services such as
        MinIO.
        """
        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: _builtins.str,
                 account_url: Optional[_builtins.str] = None,
                 secret_access_key: Optional[_builtins.str] = None):
        """
        :param _builtins.str name: The name of the cache image.
        :param _builtins.str account_url: Base URL of the storage account.
        :param _builtins.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)

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        """
        The name of the cache image.
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="accountUrl")
    def account_url(self) -> Optional[_builtins.str]:
        """
        Base URL of the storage account.
        """
        return pulumi.get(self, "account_url")

    @_builtins.property
    @pulumi.getter(name="secretAccessKey")
    def secret_access_key(self) -> Optional[_builtins.str]:
        """
        Blob storage account key.
        """
        return pulumi.get(self, "secret_access_key")


@pulumi.output_type
class CacheFromGitHubActions(dict):
    """
    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.
    """
    def __init__(__self__, *,
                 scope: Optional[_builtins.str] = None):
        """
        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 _builtins.str scope: The scope to use for cache keys. Defaults to `buildkit`.
               
               This should be set if building and caching multiple images in one
               workflow, otherwise caches will overwrite each other.
        """
        if scope is None:
            scope = 'buildkit'
        if scope is not None:
            pulumi.set(__self__, "scope", scope)

    @_builtins.property
    @pulumi.getter
    def scope(self) -> Optional[_builtins.str]:
        """
        The scope to use for cache keys. Defaults to `buildkit`.

        This should be set if building and caching multiple images in one
        workflow, otherwise caches will overwrite each other.
        """
        return pulumi.get(self, "scope")


@pulumi.output_type
class CacheFromLocal(dict):
    def __init__(__self__, *,
                 src: _builtins.str,
                 digest: Optional[_builtins.str] = None):
        """
        :param _builtins.str src: Path of the local directory where cache gets imported from.
        :param _builtins.str digest: Digest of manifest to import.
        """
        pulumi.set(__self__, "src", src)
        if digest is not None:
            pulumi.set(__self__, "digest", digest)

    @_builtins.property
    @pulumi.getter
    def src(self) -> _builtins.str:
        """
        Path of the local directory where cache gets imported from.
        """
        return pulumi.get(self, "src")

    @_builtins.property
    @pulumi.getter
    def digest(self) -> Optional[_builtins.str]:
        """
        Digest of manifest to import.
        """
        return pulumi.get(self, "digest")


@pulumi.output_type
class CacheFromRegistry(dict):
    def __init__(__self__, *,
                 ref: _builtins.str):
        """
        :param _builtins.str ref: Fully qualified name of the cache image to import.
        """
        pulumi.set(__self__, "ref", ref)

    @_builtins.property
    @pulumi.getter
    def ref(self) -> _builtins.str:
        """
        Fully qualified name of the cache image to import.
        """
        return pulumi.get(self, "ref")


@pulumi.output_type
class CacheFromS3(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessKeyId":
            suggest = "access_key_id"
        elif key == "blobsPrefix":
            suggest = "blobs_prefix"
        elif key == "endpointUrl":
            suggest = "endpoint_url"
        elif key == "manifestsPrefix":
            suggest = "manifests_prefix"
        elif key == "secretAccessKey":
            suggest = "secret_access_key"
        elif key == "sessionToken":
            suggest = "session_token"
        elif key == "usePathStyle":
            suggest = "use_path_style"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CacheFromS3. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CacheFromS3.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CacheFromS3.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bucket: _builtins.str,
                 region: Optional[_builtins.str] = None,
                 access_key_id: Optional[_builtins.str] = None,
                 blobs_prefix: Optional[_builtins.str] = None,
                 endpoint_url: Optional[_builtins.str] = None,
                 manifests_prefix: Optional[_builtins.str] = None,
                 name: Optional[_builtins.str] = None,
                 secret_access_key: Optional[_builtins.str] = None,
                 session_token: Optional[_builtins.str] = None,
                 use_path_style: Optional[_builtins.bool] = None):
        """
        :param _builtins.str bucket: Name of the S3 bucket.
        :param _builtins.str region: The geographic location of the bucket. Defaults to `$AWS_REGION`.
        :param _builtins.str access_key_id: Defaults to `$AWS_ACCESS_KEY_ID`.
        :param _builtins.str blobs_prefix: Prefix to prepend to blob filenames.
        :param _builtins.str endpoint_url: Endpoint of the S3 bucket.
        :param _builtins.str manifests_prefix: Prefix to prepend on manifest filenames.
        :param _builtins.str name: Name of the cache image.
        :param _builtins.str secret_access_key: Defaults to `$AWS_SECRET_ACCESS_KEY`.
        :param _builtins.str session_token: Defaults to `$AWS_SESSION_TOKEN`.
        :param _builtins.bool use_path_style: Uses `bucket` in the URL instead of hostname when `true`.
        """
        pulumi.set(__self__, "bucket", bucket)
        if region is None:
            region = (_utilities.get_env('AWS_REGION') or '')
        pulumi.set(__self__, "region", region)
        if access_key_id is None:
            access_key_id = (_utilities.get_env('AWS_ACCESS_KEY_ID') or '')
        if access_key_id is not None:
            pulumi.set(__self__, "access_key_id", access_key_id)
        if blobs_prefix is not None:
            pulumi.set(__self__, "blobs_prefix", blobs_prefix)
        if endpoint_url is not None:
            pulumi.set(__self__, "endpoint_url", endpoint_url)
        if manifests_prefix is not None:
            pulumi.set(__self__, "manifests_prefix", manifests_prefix)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if secret_access_key is None:
            secret_access_key = (_utilities.get_env('AWS_SECRET_ACCESS_KEY') or '')
        if secret_access_key is not None:
            pulumi.set(__self__, "secret_access_key", secret_access_key)
        if session_token is None:
            session_token = (_utilities.get_env('AWS_SESSION_TOKEN') or '')
        if session_token is not None:
            pulumi.set(__self__, "session_token", session_token)
        if use_path_style is not None:
            pulumi.set(__self__, "use_path_style", use_path_style)

    @_builtins.property
    @pulumi.getter
    def bucket(self) -> _builtins.str:
        """
        Name of the S3 bucket.
        """
        return pulumi.get(self, "bucket")

    @_builtins.property
    @pulumi.getter
    def region(self) -> _builtins.str:
        """
        The geographic location of the bucket. Defaults to `$AWS_REGION`.
        """
        return pulumi.get(self, "region")

    @_builtins.property
    @pulumi.getter(name="accessKeyId")
    def access_key_id(self) -> Optional[_builtins.str]:
        """
        Defaults to `$AWS_ACCESS_KEY_ID`.
        """
        return pulumi.get(self, "access_key_id")

    @_builtins.property
    @pulumi.getter(name="blobsPrefix")
    def blobs_prefix(self) -> Optional[_builtins.str]:
        """
        Prefix to prepend to blob filenames.
        """
        return pulumi.get(self, "blobs_prefix")

    @_builtins.property
    @pulumi.getter(name="endpointUrl")
    def endpoint_url(self) -> Optional[_builtins.str]:
        """
        Endpoint of the S3 bucket.
        """
        return pulumi.get(self, "endpoint_url")

    @_builtins.property
    @pulumi.getter(name="manifestsPrefix")
    def manifests_prefix(self) -> Optional[_builtins.str]:
        """
        Prefix to prepend on manifest filenames.
        """
        return pulumi.get(self, "manifests_prefix")

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        Name of the cache image.
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="secretAccessKey")
    def secret_access_key(self) -> Optional[_builtins.str]:
        """
        Defaults to `$AWS_SECRET_ACCESS_KEY`.
        """
        return pulumi.get(self, "secret_access_key")

    @_builtins.property
    @pulumi.getter(name="sessionToken")
    def session_token(self) -> Optional[_builtins.str]:
        """
        Defaults to `$AWS_SESSION_TOKEN`.
        """
        return pulumi.get(self, "session_token")

    @_builtins.property
    @pulumi.getter(name="usePathStyle")
    def use_path_style(self) -> Optional[_builtins.bool]:
        """
        Uses `bucket` in the URL instead of hostname when `true`.
        """
        return pulumi.get(self, "use_path_style")


@pulumi.output_type
class CacheTo(dict):
    def __init__(__self__, *,
                 azblob: Optional['outputs.CacheToAzureBlob'] = None,
                 disabled: Optional[_builtins.bool] = None,
                 gha: Optional['outputs.CacheToGitHubActions'] = None,
                 inline: Optional['outputs.CacheToInline'] = None,
                 local: Optional['outputs.CacheToLocal'] = None,
                 raw: Optional[_builtins.str] = None,
                 registry: Optional['outputs.CacheToRegistry'] = None,
                 s3: Optional['outputs.CacheToS3'] = None):
        """
        :param 'CacheToAzureBlob' azblob: Push cache to Azure's blob storage service.
        :param _builtins.bool disabled: When `true` this entry will be excluded. Defaults to `false`.
        :param 'CacheToGitHubActions' 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 'CacheToInline' 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 'CacheToLocal' local: A simple backend which caches imagines on your local filesystem.
        :param _builtins.str raw: A raw string as you would provide it to the Docker CLI (e.g.,
               `type=inline`)
        :param 'CacheToRegistry' registry: Push caches to remote registries. Incompatible with the `docker` build
               driver.
        :param 'CacheToS3' 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)

    @_builtins.property
    @pulumi.getter
    def azblob(self) -> Optional['outputs.CacheToAzureBlob']:
        """
        Push cache to Azure's blob storage service.
        """
        return pulumi.get(self, "azblob")

    @_builtins.property
    @pulumi.getter
    def disabled(self) -> Optional[_builtins.bool]:
        """
        When `true` this entry will be excluded. Defaults to `false`.
        """
        return pulumi.get(self, "disabled")

    @_builtins.property
    @pulumi.getter
    def gha(self) -> Optional['outputs.CacheToGitHubActions']:
        """
        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")

    @_builtins.property
    @pulumi.getter
    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
        `registry` cache backend instead.
        """
        return pulumi.get(self, "inline")

    @_builtins.property
    @pulumi.getter
    def local(self) -> Optional['outputs.CacheToLocal']:
        """
        A simple backend which caches imagines on your local filesystem.
        """
        return pulumi.get(self, "local")

    @_builtins.property
    @pulumi.getter
    def raw(self) -> Optional[_builtins.str]:
        """
        A raw string as you would provide it to the Docker CLI (e.g.,
        `type=inline`)
        """
        return pulumi.get(self, "raw")

    @_builtins.property
    @pulumi.getter
    def registry(self) -> Optional['outputs.CacheToRegistry']:
        """
        Push caches to remote registries. Incompatible with the `docker` build
        driver.
        """
        return pulumi.get(self, "registry")

    @_builtins.property
    @pulumi.getter
    def s3(self) -> Optional['outputs.CacheToS3']:
        """
        Push cache to AWS S3 or S3-compatible services such as MinIO.
        """
        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: _builtins.str,
                 account_url: Optional[_builtins.str] = None,
                 ignore_error: Optional[_builtins.bool] = None,
                 mode: Optional['CacheMode'] = None,
                 secret_access_key: Optional[_builtins.str] = None):
        """
        :param _builtins.str name: The name of the cache image.
        :param _builtins.str account_url: Base URL of the storage account.
        :param _builtins.bool ignore_error: Ignore errors caused by failed cache exports.
        :param 'CacheMode' mode: The cache mode to use. Defaults to `min`.
        :param _builtins.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)

    @_builtins.property
    @pulumi.getter
    def name(self) -> _builtins.str:
        """
        The name of the cache image.
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="accountUrl")
    def account_url(self) -> Optional[_builtins.str]:
        """
        Base URL of the storage account.
        """
        return pulumi.get(self, "account_url")

    @_builtins.property
    @pulumi.getter(name="ignoreError")
    def ignore_error(self) -> Optional[_builtins.bool]:
        """
        Ignore errors caused by failed cache exports.
        """
        return pulumi.get(self, "ignore_error")

    @_builtins.property
    @pulumi.getter
    def mode(self) -> Optional['CacheMode']:
        """
        The cache mode to use. Defaults to `min`.
        """
        return pulumi.get(self, "mode")

    @_builtins.property
    @pulumi.getter(name="secretAccessKey")
    def secret_access_key(self) -> Optional[_builtins.str]:
        """
        Blob storage account key.
        """
        return pulumi.get(self, "secret_access_key")


@pulumi.output_type
class CacheToGitHubActions(dict):
    """
    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.
    """
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ignoreError":
            suggest = "ignore_error"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CacheToGitHubActions. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CacheToGitHubActions.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CacheToGitHubActions.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ignore_error: Optional[_builtins.bool] = None,
                 mode: Optional['CacheMode'] = None,
                 scope: Optional[_builtins.str] = None):
        """
        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 _builtins.bool ignore_error: Ignore errors caused by failed cache exports.
        :param 'CacheMode' mode: The cache mode to use. Defaults to `min`.
        :param _builtins.str scope: The scope to use for cache keys. Defaults to `buildkit`.
               
               This should be set if building and caching multiple images in one
               workflow, otherwise caches will overwrite each other.
        """
        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 scope is None:
            scope = 'buildkit'
        if scope is not None:
            pulumi.set(__self__, "scope", scope)

    @_builtins.property
    @pulumi.getter(name="ignoreError")
    def ignore_error(self) -> Optional[_builtins.bool]:
        """
        Ignore errors caused by failed cache exports.
        """
        return pulumi.get(self, "ignore_error")

    @_builtins.property
    @pulumi.getter
    def mode(self) -> Optional['CacheMode']:
        """
        The cache mode to use. Defaults to `min`.
        """
        return pulumi.get(self, "mode")

    @_builtins.property
    @pulumi.getter
    def scope(self) -> Optional[_builtins.str]:
        """
        The scope to use for cache keys. Defaults to `buildkit`.

        This should be set if building and caching multiple images in one
        workflow, otherwise caches will overwrite each other.
        """
        return pulumi.get(self, "scope")


@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
    def __key_warning(key: str):
        suggest = None
        if key == "compressionLevel":
            suggest = "compression_level"
        elif key == "forceCompression":
            suggest = "force_compression"
        elif key == "ignoreError":
            suggest = "ignore_error"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CacheToLocal. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CacheToLocal.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CacheToLocal.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 dest: _builtins.str,
                 compression: Optional['CompressionType'] = None,
                 compression_level: Optional[_builtins.int] = None,
                 force_compression: Optional[_builtins.bool] = None,
                 ignore_error: Optional[_builtins.bool] = None,
                 mode: Optional['CacheMode'] = None):
        """
        :param _builtins.str dest: Path of the local directory to export the cache.
        :param 'CompressionType' compression: The compression type to use.
        :param _builtins.int compression_level: Compression level from 0 to 22.
        :param _builtins.bool force_compression: Forcefully apply compression.
        :param _builtins.bool ignore_error: Ignore errors caused by failed cache exports.
        :param 'CacheMode' mode: The cache mode to use. Defaults to `min`.
        """
        pulumi.set(__self__, "dest", dest)
        if compression is None:
            compression = 'gzip'
        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 force_compression is None:
            force_compression = False
        if force_compression is not None:
            pulumi.set(__self__, "force_compression", force_compression)
        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)

    @_builtins.property
    @pulumi.getter
    def dest(self) -> _builtins.str:
        """
        Path of the local directory to export the cache.
        """
        return pulumi.get(self, "dest")

    @_builtins.property
    @pulumi.getter
    def compression(self) -> Optional['CompressionType']:
        """
        The compression type to use.
        """
        return pulumi.get(self, "compression")

    @_builtins.property
    @pulumi.getter(name="compressionLevel")
    def compression_level(self) -> Optional[_builtins.int]:
        """
        Compression level from 0 to 22.
        """
        return pulumi.get(self, "compression_level")

    @_builtins.property
    @pulumi.getter(name="forceCompression")
    def force_compression(self) -> Optional[_builtins.bool]:
        """
        Forcefully apply compression.
        """
        return pulumi.get(self, "force_compression")

    @_builtins.property
    @pulumi.getter(name="ignoreError")
    def ignore_error(self) -> Optional[_builtins.bool]:
        """
        Ignore errors caused by failed cache exports.
        """
        return pulumi.get(self, "ignore_error")

    @_builtins.property
    @pulumi.getter
    def mode(self) -> Optional['CacheMode']:
        """
        The cache mode to use. Defaults to `min`.
        """
        return pulumi.get(self, "mode")


@pulumi.output_type
class CacheToRegistry(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "compressionLevel":
            suggest = "compression_level"
        elif key == "forceCompression":
            suggest = "force_compression"
        elif key == "ignoreError":
            suggest = "ignore_error"
        elif key == "imageManifest":
            suggest = "image_manifest"
        elif key == "ociMediaTypes":
            suggest = "oci_media_types"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CacheToRegistry. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CacheToRegistry.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CacheToRegistry.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 ref: _builtins.str,
                 compression: Optional['CompressionType'] = None,
                 compression_level: Optional[_builtins.int] = None,
                 force_compression: Optional[_builtins.bool] = None,
                 ignore_error: Optional[_builtins.bool] = None,
                 image_manifest: Optional[_builtins.bool] = None,
                 mode: Optional['CacheMode'] = None,
                 oci_media_types: Optional[_builtins.bool] = None):
        """
        :param _builtins.str ref: Fully qualified name of the cache image to import.
        :param 'CompressionType' compression: The compression type to use.
        :param _builtins.int compression_level: Compression level from 0 to 22.
        :param _builtins.bool force_compression: Forcefully apply compression.
        :param _builtins.bool ignore_error: Ignore errors caused by failed cache exports.
        :param _builtins.bool image_manifest: Export cache manifest as an OCI-compatible image manifest instead of a
               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` to match Docker's default behavior.
        :param 'CacheMode' mode: The cache mode to use. Defaults to `min`.
        :param _builtins.bool oci_media_types: Whether to use OCI media types in exported manifests. Defaults to
               `true`.
        """
        pulumi.set(__self__, "ref", ref)
        if compression is None:
            compression = 'gzip'
        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 force_compression is None:
            force_compression = False
        if force_compression is not None:
            pulumi.set(__self__, "force_compression", force_compression)
        if ignore_error is None:
            ignore_error = False
        if ignore_error is not None:
            pulumi.set(__self__, "ignore_error", ignore_error)
        if image_manifest is None:
            image_manifest = False
        if image_manifest is not None:
            pulumi.set(__self__, "image_manifest", image_manifest)
        if mode is None:
            mode = 'min'
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if oci_media_types is None:
            oci_media_types = True
        if oci_media_types is not None:
            pulumi.set(__self__, "oci_media_types", oci_media_types)

    @_builtins.property
    @pulumi.getter
    def ref(self) -> _builtins.str:
        """
        Fully qualified name of the cache image to import.
        """
        return pulumi.get(self, "ref")

    @_builtins.property
    @pulumi.getter
    def compression(self) -> Optional['CompressionType']:
        """
        The compression type to use.
        """
        return pulumi.get(self, "compression")

    @_builtins.property
    @pulumi.getter(name="compressionLevel")
    def compression_level(self) -> Optional[_builtins.int]:
        """
        Compression level from 0 to 22.
        """
        return pulumi.get(self, "compression_level")

    @_builtins.property
    @pulumi.getter(name="forceCompression")
    def force_compression(self) -> Optional[_builtins.bool]:
        """
        Forcefully apply compression.
        """
        return pulumi.get(self, "force_compression")

    @_builtins.property
    @pulumi.getter(name="ignoreError")
    def ignore_error(self) -> Optional[_builtins.bool]:
        """
        Ignore errors caused by failed cache exports.
        """
        return pulumi.get(self, "ignore_error")

    @_builtins.property
    @pulumi.getter(name="imageManifest")
    def image_manifest(self) -> Optional[_builtins.bool]:
        """
        Export cache manifest as an OCI-compatible image manifest instead of a
        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` to match Docker's default behavior.
        """
        return pulumi.get(self, "image_manifest")

    @_builtins.property
    @pulumi.getter
    def mode(self) -> Optional['CacheMode']:
        """
        The cache mode to use. Defaults to `min`.
        """
        return pulumi.get(self, "mode")

    @_builtins.property
    @pulumi.getter(name="ociMediaTypes")
    def oci_media_types(self) -> Optional[_builtins.bool]:
        """
        Whether to use OCI media types in exported manifests. Defaults to
        `true`.
        """
        return pulumi.get(self, "oci_media_types")


@pulumi.output_type
class CacheToS3(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "accessKeyId":
            suggest = "access_key_id"
        elif key == "blobsPrefix":
            suggest = "blobs_prefix"
        elif key == "endpointUrl":
            suggest = "endpoint_url"
        elif key == "ignoreError":
            suggest = "ignore_error"
        elif key == "manifestsPrefix":
            suggest = "manifests_prefix"
        elif key == "secretAccessKey":
            suggest = "secret_access_key"
        elif key == "sessionToken":
            suggest = "session_token"
        elif key == "usePathStyle":
            suggest = "use_path_style"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in CacheToS3. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        CacheToS3.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        CacheToS3.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 bucket: _builtins.str,
                 region: Optional[_builtins.str] = None,
                 access_key_id: Optional[_builtins.str] = None,
                 blobs_prefix: Optional[_builtins.str] = None,
                 endpoint_url: Optional[_builtins.str] = None,
                 ignore_error: Optional[_builtins.bool] = None,
                 manifests_prefix: Optional[_builtins.str] = None,
                 mode: Optional['CacheMode'] = None,
                 name: Optional[_builtins.str] = None,
                 secret_access_key: Optional[_builtins.str] = None,
                 session_token: Optional[_builtins.str] = None,
                 use_path_style: Optional[_builtins.bool] = None):
        """
        :param _builtins.str bucket: Name of the S3 bucket.
        :param _builtins.str region: The geographic location of the bucket. Defaults to `$AWS_REGION`.
        :param _builtins.str access_key_id: Defaults to `$AWS_ACCESS_KEY_ID`.
        :param _builtins.str blobs_prefix: Prefix to prepend to blob filenames.
        :param _builtins.str endpoint_url: Endpoint of the S3 bucket.
        :param _builtins.bool ignore_error: Ignore errors caused by failed cache exports.
        :param _builtins.str manifests_prefix: Prefix to prepend on manifest filenames.
        :param 'CacheMode' mode: The cache mode to use. Defaults to `min`.
        :param _builtins.str name: Name of the cache image.
        :param _builtins.str secret_access_key: Defaults to `$AWS_SECRET_ACCESS_KEY`.
        :param _builtins.str session_token: Defaults to `$AWS_SESSION_TOKEN`.
        :param _builtins.bool use_path_style: Uses `bucket` in the URL instead of hostname when `true`.
        """
        pulumi.set(__self__, "bucket", bucket)
        if region is None:
            region = (_utilities.get_env('AWS_REGION') or '')
        pulumi.set(__self__, "region", region)
        if access_key_id is None:
            access_key_id = (_utilities.get_env('AWS_ACCESS_KEY_ID') or '')
        if access_key_id is not None:
            pulumi.set(__self__, "access_key_id", access_key_id)
        if blobs_prefix is not None:
            pulumi.set(__self__, "blobs_prefix", blobs_prefix)
        if endpoint_url is not None:
            pulumi.set(__self__, "endpoint_url", endpoint_url)
        if ignore_error is None:
            ignore_error = False
        if ignore_error is not None:
            pulumi.set(__self__, "ignore_error", ignore_error)
        if manifests_prefix is not None:
            pulumi.set(__self__, "manifests_prefix", manifests_prefix)
        if mode is None:
            mode = 'min'
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if secret_access_key is None:
            secret_access_key = (_utilities.get_env('AWS_SECRET_ACCESS_KEY') or '')
        if secret_access_key is not None:
            pulumi.set(__self__, "secret_access_key", secret_access_key)
        if session_token is None:
            session_token = (_utilities.get_env('AWS_SESSION_TOKEN') or '')
        if session_token is not None:
            pulumi.set(__self__, "session_token", session_token)
        if use_path_style is not None:
            pulumi.set(__self__, "use_path_style", use_path_style)

    @_builtins.property
    @pulumi.getter
    def bucket(self) -> _builtins.str:
        """
        Name of the S3 bucket.
        """
        return pulumi.get(self, "bucket")

    @_builtins.property
    @pulumi.getter
    def region(self) -> _builtins.str:
        """
        The geographic location of the bucket. Defaults to `$AWS_REGION`.
        """
        return pulumi.get(self, "region")

    @_builtins.property
    @pulumi.getter(name="accessKeyId")
    def access_key_id(self) -> Optional[_builtins.str]:
        """
        Defaults to `$AWS_ACCESS_KEY_ID`.
        """
        return pulumi.get(self, "access_key_id")

    @_builtins.property
    @pulumi.getter(name="blobsPrefix")
    def blobs_prefix(self) -> Optional[_builtins.str]:
        """
        Prefix to prepend to blob filenames.
        """
        return pulumi.get(self, "blobs_prefix")

    @_builtins.property
    @pulumi.getter(name="endpointUrl")
    def endpoint_url(self) -> Optional[_builtins.str]:
        """
        Endpoint of the S3 bucket.
        """
        return pulumi.get(self, "endpoint_url")

    @_builtins.property
    @pulumi.getter(name="ignoreError")
    def ignore_error(self) -> Optional[_builtins.bool]:
        """
        Ignore errors caused by failed cache exports.
        """
        return pulumi.get(self, "ignore_error")

    @_builtins.property
    @pulumi.getter(name="manifestsPrefix")
    def manifests_prefix(self) -> Optional[_builtins.str]:
        """
        Prefix to prepend on manifest filenames.
        """
        return pulumi.get(self, "manifests_prefix")

    @_builtins.property
    @pulumi.getter
    def mode(self) -> Optional['CacheMode']:
        """
        The cache mode to use. Defaults to `min`.
        """
        return pulumi.get(self, "mode")

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[_builtins.str]:
        """
        Name of the cache image.
        """
        return pulumi.get(self, "name")

    @_builtins.property
    @pulumi.getter(name="secretAccessKey")
    def secret_access_key(self) -> Optional[_builtins.str]:
        """
        Defaults to `$AWS_SECRET_ACCESS_KEY`.
        """
        return pulumi.get(self, "secret_access_key")

    @_builtins.property
    @pulumi.getter(name="sessionToken")
    def session_token(self) -> Optional[_builtins.str]:
        """
        Defaults to `$AWS_SESSION_TOKEN`.
        """
        return pulumi.get(self, "session_token")

    @_builtins.property
    @pulumi.getter(name="usePathStyle")
    def use_path_style(self) -> Optional[_builtins.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: _builtins.str):
        """
        :param _builtins.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)

    @_builtins.property
    @pulumi.getter
    def location(self) -> _builtins.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[_builtins.str] = None,
                 location: Optional[_builtins.str] = None):
        """
        :param _builtins.str inline: Raw Dockerfile contents.
               
               Conflicts with `location`.
               
               Equivalent to invoking Docker with `-f -`.
        :param _builtins.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)

    @_builtins.property
    @pulumi.getter
    def inline(self) -> Optional[_builtins.str]:
        """
        Raw Dockerfile contents.

        Conflicts with `location`.

        Equivalent to invoking Docker with `-f -`.
        """
        return pulumi.get(self, "inline")

    @_builtins.property
    @pulumi.getter
    def location(self) -> Optional[_builtins.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[_builtins.bool] = None,
                 docker: Optional['outputs.ExportDocker'] = None,
                 image: Optional['outputs.ExportImage'] = None,
                 local: Optional['outputs.ExportLocal'] = None,
                 oci: Optional['outputs.ExportOCI'] = None,
                 raw: Optional[_builtins.str] = None,
                 registry: Optional['outputs.ExportRegistry'] = None,
                 tar: Optional['outputs.ExportTar'] = None):
        """
        :param 'ExportCacheOnly' cacheonly: A no-op export. Helpful for silencing the 'no exports' warning if you
               just want to populate caches.
        :param _builtins.bool disabled: When `true` this entry will be excluded. Defaults to `false`.
        :param 'ExportDocker' docker: Export as a Docker image layout.
        :param 'ExportImage' image: Outputs the build result into a container image format.
        :param 'ExportLocal' local: Export to a local directory as files and directories.
        :param 'ExportOCI' oci: Identical to the Docker exporter but uses OCI media types by default.
        :param _builtins.str raw: A raw string as you would provide it to the Docker CLI (e.g.,
               `type=docker`)
        :param 'ExportRegistry' registry: Identical to the Image exporter, but pushes by default.
        :param 'ExportTar' 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)

    @_builtins.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")

    @_builtins.property
    @pulumi.getter
    def disabled(self) -> Optional[_builtins.bool]:
        """
        When `true` this entry will be excluded. Defaults to `false`.
        """
        return pulumi.get(self, "disabled")

    @_builtins.property
    @pulumi.getter
    def docker(self) -> Optional['outputs.ExportDocker']:
        """
        Export as a Docker image layout.
        """
        return pulumi.get(self, "docker")

    @_builtins.property
    @pulumi.getter
    def image(self) -> Optional['outputs.ExportImage']:
        """
        Outputs the build result into a container image format.
        """
        return pulumi.get(self, "image")

    @_builtins.property
    @pulumi.getter
    def local(self) -> Optional['outputs.ExportLocal']:
        """
        Export to a local directory as files and directories.
        """
        return pulumi.get(self, "local")

    @_builtins.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")

    @_builtins.property
    @pulumi.getter
    def raw(self) -> Optional[_builtins.str]:
        """
        A raw string as you would provide it to the Docker CLI (e.g.,
        `type=docker`)
        """
        return pulumi.get(self, "raw")

    @_builtins.property
    @pulumi.getter
    def registry(self) -> Optional['outputs.ExportRegistry']:
        """
        Identical to the Image exporter, but pushes by default.
        """
        return pulumi.get(self, "registry")

    @_builtins.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 ExportCacheOnly(dict):
    def __init__(__self__):
        pass


@pulumi.output_type
class ExportDocker(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "compressionLevel":
            suggest = "compression_level"
        elif key == "forceCompression":
            suggest = "force_compression"
        elif key == "ociMediaTypes":
            suggest = "oci_media_types"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ExportDocker. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ExportDocker.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ExportDocker.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 annotations: Optional[Mapping[str, _builtins.str]] = None,
                 compression: Optional['CompressionType'] = None,
                 compression_level: Optional[_builtins.int] = None,
                 dest: Optional[_builtins.str] = None,
                 force_compression: Optional[_builtins.bool] = None,
                 names: Optional[Sequence[_builtins.str]] = None,
                 oci_media_types: Optional[_builtins.bool] = None,
                 tar: Optional[_builtins.bool] = None):
        """
        :param Mapping[str, _builtins.str] annotations: Attach an arbitrary key/value annotation to the image.
        :param 'CompressionType' compression: The compression type to use.
        :param _builtins.int compression_level: Compression level from 0 to 22.
        :param _builtins.str dest: The local export path.
        :param _builtins.bool force_compression: Forcefully apply compression.
        :param Sequence[_builtins.str] names: Specify images names to export. This is overridden if tags are already specified.
        :param _builtins.bool oci_media_types: Use OCI media types in exporter manifests.
        :param _builtins.bool tar: Bundle the output into a tarball layout.
        """
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if compression is None:
            compression = 'gzip'
        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)

    @_builtins.property
    @pulumi.getter
    def annotations(self) -> Optional[Mapping[str, _builtins.str]]:
        """
        Attach an arbitrary key/value annotation to the image.
        """
        return pulumi.get(self, "annotations")

    @_builtins.property
    @pulumi.getter
    def compression(self) -> Optional['CompressionType']:
        """
        The compression type to use.
        """
        return pulumi.get(self, "compression")

    @_builtins.property
    @pulumi.getter(name="compressionLevel")
    def compression_level(self) -> Optional[_builtins.int]:
        """
        Compression level from 0 to 22.
        """
        return pulumi.get(self, "compression_level")

    @_builtins.property
    @pulumi.getter
    def dest(self) -> Optional[_builtins.str]:
        """
        The local export path.
        """
        return pulumi.get(self, "dest")

    @_builtins.property
    @pulumi.getter(name="forceCompression")
    def force_compression(self) -> Optional[_builtins.bool]:
        """
        Forcefully apply compression.
        """
        return pulumi.get(self, "force_compression")

    @_builtins.property
    @pulumi.getter
    def names(self) -> Optional[Sequence[_builtins.str]]:
        """
        Specify images names to export. This is overridden if tags are already specified.
        """
        return pulumi.get(self, "names")

    @_builtins.property
    @pulumi.getter(name="ociMediaTypes")
    def oci_media_types(self) -> Optional[_builtins.bool]:
        """
        Use OCI media types in exporter manifests.
        """
        return pulumi.get(self, "oci_media_types")

    @_builtins.property
    @pulumi.getter
    def tar(self) -> Optional[_builtins.bool]:
        """
        Bundle the output into a tarball layout.
        """
        return pulumi.get(self, "tar")


@pulumi.output_type
class ExportImage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "compressionLevel":
            suggest = "compression_level"
        elif key == "danglingNamePrefix":
            suggest = "dangling_name_prefix"
        elif key == "forceCompression":
            suggest = "force_compression"
        elif key == "nameCanonical":
            suggest = "name_canonical"
        elif key == "ociMediaTypes":
            suggest = "oci_media_types"
        elif key == "pushByDigest":
            suggest = "push_by_digest"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ExportImage. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ExportImage.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ExportImage.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 annotations: Optional[Mapping[str, _builtins.str]] = None,
                 compression: Optional['CompressionType'] = None,
                 compression_level: Optional[_builtins.int] = None,
                 dangling_name_prefix: Optional[_builtins.str] = None,
                 force_compression: Optional[_builtins.bool] = None,
                 insecure: Optional[_builtins.bool] = None,
                 name_canonical: Optional[_builtins.bool] = None,
                 names: Optional[Sequence[_builtins.str]] = None,
                 oci_media_types: Optional[_builtins.bool] = None,
                 push: Optional[_builtins.bool] = None,
                 push_by_digest: Optional[_builtins.bool] = None,
                 store: Optional[_builtins.bool] = None,
                 unpack: Optional[_builtins.bool] = None):
        """
        :param Mapping[str, _builtins.str] annotations: Attach an arbitrary key/value annotation to the image.
        :param 'CompressionType' compression: The compression type to use.
        :param _builtins.int compression_level: Compression level from 0 to 22.
        :param _builtins.str dangling_name_prefix: Name image with `prefix@<digest>`, used for anonymous images.
        :param _builtins.bool force_compression: Forcefully apply compression.
        :param _builtins.bool insecure: Allow pushing to an insecure registry.
        :param _builtins.bool name_canonical: Add additional canonical name (`name@<digest>`).
        :param Sequence[_builtins.str] names: Specify images names to export. This is overridden if tags are already specified.
        :param _builtins.bool oci_media_types: Use OCI media types in exporter manifests.
        :param _builtins.bool push: Push after creating the image. Defaults to `false`.
        :param _builtins.bool push_by_digest: Push image without name.
        :param _builtins.bool store: Store resulting images to the worker's image store and ensure all of
               its blobs are in the content store.
               
               Defaults to `true`.
               
               Ignored if the worker doesn't have image store (when using OCI workers,
               for example).
        :param _builtins.bool unpack: Unpack image after creation (for use with containerd). Defaults to
               `false`.
        """
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if compression is None:
            compression = 'gzip'
        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 dangling_name_prefix is not None:
            pulumi.set(__self__, "dangling_name_prefix", dangling_name_prefix)
        if force_compression is None:
            force_compression = False
        if force_compression is not None:
            pulumi.set(__self__, "force_compression", force_compression)
        if insecure is not None:
            pulumi.set(__self__, "insecure", insecure)
        if name_canonical is not None:
            pulumi.set(__self__, "name_canonical", name_canonical)
        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 push is not None:
            pulumi.set(__self__, "push", push)
        if push_by_digest is not None:
            pulumi.set(__self__, "push_by_digest", push_by_digest)
        if store is None:
            store = True
        if store is not None:
            pulumi.set(__self__, "store", store)
        if unpack is not None:
            pulumi.set(__self__, "unpack", unpack)

    @_builtins.property
    @pulumi.getter
    def annotations(self) -> Optional[Mapping[str, _builtins.str]]:
        """
        Attach an arbitrary key/value annotation to the image.
        """
        return pulumi.get(self, "annotations")

    @_builtins.property
    @pulumi.getter
    def compression(self) -> Optional['CompressionType']:
        """
        The compression type to use.
        """
        return pulumi.get(self, "compression")

    @_builtins.property
    @pulumi.getter(name="compressionLevel")
    def compression_level(self) -> Optional[_builtins.int]:
        """
        Compression level from 0 to 22.
        """
        return pulumi.get(self, "compression_level")

    @_builtins.property
    @pulumi.getter(name="danglingNamePrefix")
    def dangling_name_prefix(self) -> Optional[_builtins.str]:
        """
        Name image with `prefix@<digest>`, used for anonymous images.
        """
        return pulumi.get(self, "dangling_name_prefix")

    @_builtins.property
    @pulumi.getter(name="forceCompression")
    def force_compression(self) -> Optional[_builtins.bool]:
        """
        Forcefully apply compression.
        """
        return pulumi.get(self, "force_compression")

    @_builtins.property
    @pulumi.getter
    def insecure(self) -> Optional[_builtins.bool]:
        """
        Allow pushing to an insecure registry.
        """
        return pulumi.get(self, "insecure")

    @_builtins.property
    @pulumi.getter(name="nameCanonical")
    def name_canonical(self) -> Optional[_builtins.bool]:
        """
        Add additional canonical name (`name@<digest>`).
        """
        return pulumi.get(self, "name_canonical")

    @_builtins.property
    @pulumi.getter
    def names(self) -> Optional[Sequence[_builtins.str]]:
        """
        Specify images names to export. This is overridden if tags are already specified.
        """
        return pulumi.get(self, "names")

    @_builtins.property
    @pulumi.getter(name="ociMediaTypes")
    def oci_media_types(self) -> Optional[_builtins.bool]:
        """
        Use OCI media types in exporter manifests.
        """
        return pulumi.get(self, "oci_media_types")

    @_builtins.property
    @pulumi.getter
    def push(self) -> Optional[_builtins.bool]:
        """
        Push after creating the image. Defaults to `false`.
        """
        return pulumi.get(self, "push")

    @_builtins.property
    @pulumi.getter(name="pushByDigest")
    def push_by_digest(self) -> Optional[_builtins.bool]:
        """
        Push image without name.
        """
        return pulumi.get(self, "push_by_digest")

    @_builtins.property
    @pulumi.getter
    def store(self) -> Optional[_builtins.bool]:
        """
        Store resulting images to the worker's image store and ensure all of
        its blobs are in the content store.

        Defaults to `true`.

        Ignored if the worker doesn't have image store (when using OCI workers,
        for example).
        """
        return pulumi.get(self, "store")

    @_builtins.property
    @pulumi.getter
    def unpack(self) -> Optional[_builtins.bool]:
        """
        Unpack image after creation (for use with containerd). Defaults to
        `false`.
        """
        return pulumi.get(self, "unpack")


@pulumi.output_type
class ExportLocal(dict):
    def __init__(__self__, *,
                 dest: _builtins.str):
        """
        :param _builtins.str dest: Output path.
        """
        pulumi.set(__self__, "dest", dest)

    @_builtins.property
    @pulumi.getter
    def dest(self) -> _builtins.str:
        """
        Output path.
        """
        return pulumi.get(self, "dest")


@pulumi.output_type
class ExportOCI(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "compressionLevel":
            suggest = "compression_level"
        elif key == "forceCompression":
            suggest = "force_compression"
        elif key == "ociMediaTypes":
            suggest = "oci_media_types"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ExportOCI. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ExportOCI.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ExportOCI.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 annotations: Optional[Mapping[str, _builtins.str]] = None,
                 compression: Optional['CompressionType'] = None,
                 compression_level: Optional[_builtins.int] = None,
                 dest: Optional[_builtins.str] = None,
                 force_compression: Optional[_builtins.bool] = None,
                 names: Optional[Sequence[_builtins.str]] = None,
                 oci_media_types: Optional[_builtins.bool] = None,
                 tar: Optional[_builtins.bool] = None):
        """
        :param Mapping[str, _builtins.str] annotations: Attach an arbitrary key/value annotation to the image.
        :param 'CompressionType' compression: The compression type to use.
        :param _builtins.int compression_level: Compression level from 0 to 22.
        :param _builtins.str dest: The local export path.
        :param _builtins.bool force_compression: Forcefully apply compression.
        :param Sequence[_builtins.str] names: Specify images names to export. This is overridden if tags are already specified.
        :param _builtins.bool oci_media_types: Use OCI media types in exporter manifests.
        :param _builtins.bool tar: Bundle the output into a tarball layout.
        """
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if compression is None:
            compression = 'gzip'
        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 = True
        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)

    @_builtins.property
    @pulumi.getter
    def annotations(self) -> Optional[Mapping[str, _builtins.str]]:
        """
        Attach an arbitrary key/value annotation to the image.
        """
        return pulumi.get(self, "annotations")

    @_builtins.property
    @pulumi.getter
    def compression(self) -> Optional['CompressionType']:
        """
        The compression type to use.
        """
        return pulumi.get(self, "compression")

    @_builtins.property
    @pulumi.getter(name="compressionLevel")
    def compression_level(self) -> Optional[_builtins.int]:
        """
        Compression level from 0 to 22.
        """
        return pulumi.get(self, "compression_level")

    @_builtins.property
    @pulumi.getter
    def dest(self) -> Optional[_builtins.str]:
        """
        The local export path.
        """
        return pulumi.get(self, "dest")

    @_builtins.property
    @pulumi.getter(name="forceCompression")
    def force_compression(self) -> Optional[_builtins.bool]:
        """
        Forcefully apply compression.
        """
        return pulumi.get(self, "force_compression")

    @_builtins.property
    @pulumi.getter
    def names(self) -> Optional[Sequence[_builtins.str]]:
        """
        Specify images names to export. This is overridden if tags are already specified.
        """
        return pulumi.get(self, "names")

    @_builtins.property
    @pulumi.getter(name="ociMediaTypes")
    def oci_media_types(self) -> Optional[_builtins.bool]:
        """
        Use OCI media types in exporter manifests.
        """
        return pulumi.get(self, "oci_media_types")

    @_builtins.property
    @pulumi.getter
    def tar(self) -> Optional[_builtins.bool]:
        """
        Bundle the output into a tarball layout.
        """
        return pulumi.get(self, "tar")


@pulumi.output_type
class ExportRegistry(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "compressionLevel":
            suggest = "compression_level"
        elif key == "danglingNamePrefix":
            suggest = "dangling_name_prefix"
        elif key == "forceCompression":
            suggest = "force_compression"
        elif key == "nameCanonical":
            suggest = "name_canonical"
        elif key == "ociMediaTypes":
            suggest = "oci_media_types"
        elif key == "pushByDigest":
            suggest = "push_by_digest"

        if suggest:
            pulumi.log.warn(f"Key '{key}' not found in ExportRegistry. Access the value via the '{suggest}' property getter instead.")

    def __getitem__(self, key: str) -> Any:
        ExportRegistry.__key_warning(key)
        return super().__getitem__(key)

    def get(self, key: str, default = None) -> Any:
        ExportRegistry.__key_warning(key)
        return super().get(key, default)

    def __init__(__self__, *,
                 annotations: Optional[Mapping[str, _builtins.str]] = None,
                 compression: Optional['CompressionType'] = None,
                 compression_level: Optional[_builtins.int] = None,
                 dangling_name_prefix: Optional[_builtins.str] = None,
                 force_compression: Optional[_builtins.bool] = None,
                 insecure: Optional[_builtins.bool] = None,
                 name_canonical: Optional[_builtins.bool] = None,
                 names: Optional[Sequence[_builtins.str]] = None,
                 oci_media_types: Optional[_builtins.bool] = None,
                 push: Optional[_builtins.bool] = None,
                 push_by_digest: Optional[_builtins.bool] = None,
                 store: Optional[_builtins.bool] = None,
                 unpack: Optional[_builtins.bool] = None):
        """
        :param Mapping[str, _builtins.str] annotations: Attach an arbitrary key/value annotation to the image.
        :param 'CompressionType' compression: The compression type to use.
        :param _builtins.int compression_level: Compression level from 0 to 22.
        :param _builtins.str dangling_name_prefix: Name image with `prefix@<digest>`, used for anonymous images.
        :param _builtins.bool force_compression: Forcefully apply compression.
        :param _builtins.bool insecure: Allow pushing to an insecure registry.
        :param _builtins.bool name_canonical: Add additional canonical name (`name@<digest>`).
        :param Sequence[_builtins.str] names: Specify images names to export. This is overridden if tags are already specified.
        :param _builtins.bool oci_media_types: Use OCI media types in exporter manifests.
        :param _builtins.bool push: Push after creating the image. Defaults to `true`.
        :param _builtins.bool push_by_digest: Push image without name.
        :param _builtins.bool store: Store resulting images to the worker's image store and ensure all of
               its blobs are in the content store.
               
               Defaults to `true`.
               
               Ignored if the worker doesn't have image store (when using OCI workers,
               for example).
        :param _builtins.bool unpack: Unpack image after creation (for use with containerd). Defaults to
               `false`.
        """
        if annotations is not None:
            pulumi.set(__self__, "annotations", annotations)
        if compression is None:
            compression = 'gzip'
        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 dangling_name_prefix is not None:
            pulumi.set(__self__, "dangling_name_prefix", dangling_name_prefix)
        if force_compression is None:
            force_compression = False
        if force_compression is not None:
            pulumi.set(__self__, "force_compression", force_compression)
        if insecure is not None:
            pulumi.set(__self__, "insecure", insecure)
        if name_canonical is not None:
            pulumi.set(__self__, "name_canonical", name_canonical)
        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 push is None:
            push = True
        if push is not None:
            pulumi.set(__self__, "push", push)
        if push_by_digest is not None:
            pulumi.set(__self__, "push_by_digest", push_by_digest)
        if store is None:
            store = True
        if store is not None:
            pulumi.set(__self__, "store", store)
        if unpack is not None:
            pulumi.set(__self__, "unpack", unpack)

    @_builtins.property
    @pulumi.getter
    def annotations(self) -> Optional[Mapping[str, _builtins.str]]:
        """
        Attach an arbitrary key/value annotation to the image.
        """
        return pulumi.get(self, "annotations")

    @_builtins.property
    @pulumi.getter
    def compression(self) -> Optional['CompressionType']:
        """
        The compression type to use.
        """
        return pulumi.get(self, "compression")

    @_builtins.property
    @pulumi.getter(name="compressionLevel")
    def compression_level(self) -> Optional[_builtins.int]:
        """
        Compression level from 0 to 22.
        """
        return pulumi.get(self, "compression_level")

    @_builtins.property
    @pulumi.getter(name="danglingNamePrefix")
    def dangling_name_prefix(self) -> Optional[_builtins.str]:
        """
        Name image with `prefix@<digest>`, used for anonymous images.
        """
        return pulumi.get(self, "dangling_name_prefix")

    @_builtins.property
    @pulumi.getter(name="forceCompression")
    def force_compression(self) -> Optional[_builtins.bool]:
        """
        Forcefully apply compression.
        """
        return pulumi.get(self, "force_compression")

    @_builtins.property
    @pulumi.getter
    def insecure(self) -> Optional[_builtins.bool]:
        """
        Allow pushing to an insecure registry.
        """
        return pulumi.get(self, "insecure")

    @_builtins.property
    @pulumi.getter(name="nameCanonical")
    def name_canonical(self) -> Optional[_builtins.bool]:
        """
        Add additional canonical name (`name@<digest>`).
        """
        return pulumi.get(self, "name_canonical")

    @_builtins.property
    @pulumi.getter
    def names(self) -> Optional[Sequence[_builtins.str]]:
        """
        Specify images names to export. This is overridden if tags are already specified.
        """
        return pulumi.get(self, "names")

    @_builtins.property
    @pulumi.getter(name="ociMediaTypes")
    def oci_media_types(self) -> Optional[_builtins.bool]:
        """
        Use OCI media types in exporter manifests.
        """
        return pulumi.get(self, "oci_media_types")

    @_builtins.property
    @pulumi.getter
    def push(self) -> Optional[_builtins.bool]:
        """
        Push after creating the image. Defaults to `true`.
        """
        return pulumi.get(self, "push")

    @_builtins.property
    @pulumi.getter(name="pushByDigest")
    def push_by_digest(self) -> Optional[_builtins.bool]:
        """
        Push image without name.
        """
        return pulumi.get(self, "push_by_digest")

    @_builtins.property
    @pulumi.getter
    def store(self) -> Optional[_builtins.bool]:
        """
        Store resulting images to the worker's image store and ensure all of
        its blobs are in the content store.

        Defaults to `true`.

        Ignored if the worker doesn't have image store (when using OCI workers,
        for example).
        """
        return pulumi.get(self, "store")

    @_builtins.property
    @pulumi.getter
    def unpack(self) -> Optional[_builtins.bool]:
        """
        Unpack image after creation (for use with containerd). Defaults to
        `false`.
        """
        return pulumi.get(self, "unpack")


@pulumi.output_type
class ExportTar(dict):
    def __init__(__self__, *,
                 dest: _builtins.str):
        """
        :param _builtins.str dest: Output path.
        """
        pulumi.set(__self__, "dest", dest)

    @_builtins.property
    @pulumi.getter
    def dest(self) -> _builtins.str:
        """
        Output path.
        """
        return pulumi.get(self, "dest")


@pulumi.output_type
class Registry(dict):
    def __init__(__self__, *,
                 address: _builtins.str,
                 password: Optional[_builtins.str] = None,
                 username: Optional[_builtins.str] = None):
        """
        :param _builtins.str address: The registry's address (e.g. "docker.io").
        :param _builtins.str password: Password or token for the registry.
        :param _builtins.str username: Username for the registry.
        """
        pulumi.set(__self__, "address", address)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @_builtins.property
    @pulumi.getter
    def address(self) -> _builtins.str:
        """
        The registry's address (e.g. "docker.io").
        """
        return pulumi.get(self, "address")

    @_builtins.property
    @pulumi.getter
    def password(self) -> Optional[_builtins.str]:
        """
        Password or token for the registry.
        """
        return pulumi.get(self, "password")

    @_builtins.property
    @pulumi.getter
    def username(self) -> Optional[_builtins.str]:
        """
        Username for the registry.
        """
        return pulumi.get(self, "username")


@pulumi.output_type
class SSH(dict):
    def __init__(__self__, *,
                 id: _builtins.str,
                 paths: Optional[Sequence[_builtins.str]] = None):
        """
        :param _builtins.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[_builtins.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)

    @_builtins.property
    @pulumi.getter
    def id(self) -> _builtins.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")

    @_builtins.property
    @pulumi.getter
    def paths(self) -> Optional[Sequence[_builtins.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")