# coding=utf-8
# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import copy
import warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'BitbucketServerConfigConnectedRepository',
    'BitbucketServerConfigSecrets',
    'TriggerApprovalConfig',
    'TriggerBitbucketServerTriggerConfig',
    'TriggerBitbucketServerTriggerConfigPullRequest',
    'TriggerBitbucketServerTriggerConfigPush',
    'TriggerBuild',
    'TriggerBuildArtifacts',
    'TriggerBuildArtifactsObjects',
    'TriggerBuildArtifactsObjectsTiming',
    'TriggerBuildAvailableSecrets',
    'TriggerBuildAvailableSecretsSecretManager',
    'TriggerBuildOptions',
    'TriggerBuildOptionsVolume',
    'TriggerBuildSecret',
    'TriggerBuildSource',
    'TriggerBuildSourceRepoSource',
    'TriggerBuildSourceStorageSource',
    'TriggerBuildStep',
    'TriggerBuildStepVolume',
    'TriggerGitFileSource',
    'TriggerGithub',
    'TriggerGithubPullRequest',
    'TriggerGithubPush',
    'TriggerPubsubConfig',
    'TriggerRepositoryEventConfig',
    'TriggerRepositoryEventConfigPullRequest',
    'TriggerRepositoryEventConfigPush',
    'TriggerSourceToBuild',
    'TriggerTriggerTemplate',
    'TriggerWebhookConfig',
    'WorkerPoolNetworkConfig',
    'WorkerPoolWorkerConfig',
    'GetTriggerApprovalConfigResult',
    'GetTriggerBitbucketServerTriggerConfigResult',
    'GetTriggerBitbucketServerTriggerConfigPullRequestResult',
    'GetTriggerBitbucketServerTriggerConfigPushResult',
    'GetTriggerBuildResult',
    'GetTriggerBuildArtifactResult',
    'GetTriggerBuildArtifactObjectResult',
    'GetTriggerBuildArtifactObjectTimingResult',
    'GetTriggerBuildAvailableSecretResult',
    'GetTriggerBuildAvailableSecretSecretManagerResult',
    'GetTriggerBuildOptionResult',
    'GetTriggerBuildOptionVolumeResult',
    'GetTriggerBuildSecretResult',
    'GetTriggerBuildSourceResult',
    'GetTriggerBuildSourceRepoSourceResult',
    'GetTriggerBuildSourceStorageSourceResult',
    'GetTriggerBuildStepResult',
    'GetTriggerBuildStepVolumeResult',
    'GetTriggerGitFileSourceResult',
    'GetTriggerGithubResult',
    'GetTriggerGithubPullRequestResult',
    'GetTriggerGithubPushResult',
    'GetTriggerPubsubConfigResult',
    'GetTriggerRepositoryEventConfigResult',
    'GetTriggerRepositoryEventConfigPullRequestResult',
    'GetTriggerRepositoryEventConfigPushResult',
    'GetTriggerSourceToBuildResult',
    'GetTriggerTriggerTemplateResult',
    'GetTriggerWebhookConfigResult',
]

@pulumi.output_type
class BitbucketServerConfigConnectedRepository(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "projectKey":
            suggest = "project_key"
        elif key == "repoSlug":
            suggest = "repo_slug"

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

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

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

    def __init__(__self__, *,
                 project_key: str,
                 repo_slug: str):
        """
        :param str project_key: Identifier for the project storing the repository.
        :param str repo_slug: Identifier for the repository.
        """
        pulumi.set(__self__, "project_key", project_key)
        pulumi.set(__self__, "repo_slug", repo_slug)

    @property
    @pulumi.getter(name="projectKey")
    def project_key(self) -> str:
        """
        Identifier for the project storing the repository.
        """
        return pulumi.get(self, "project_key")

    @property
    @pulumi.getter(name="repoSlug")
    def repo_slug(self) -> str:
        """
        Identifier for the repository.
        """
        return pulumi.get(self, "repo_slug")


@pulumi.output_type
class BitbucketServerConfigSecrets(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "adminAccessTokenVersionName":
            suggest = "admin_access_token_version_name"
        elif key == "readAccessTokenVersionName":
            suggest = "read_access_token_version_name"
        elif key == "webhookSecretVersionName":
            suggest = "webhook_secret_version_name"

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

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

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

    def __init__(__self__, *,
                 admin_access_token_version_name: str,
                 read_access_token_version_name: str,
                 webhook_secret_version_name: str):
        """
        :param str admin_access_token_version_name: The resource name for the admin access token's secret version.
        :param str read_access_token_version_name: The resource name for the read access token's secret version.
        :param str webhook_secret_version_name: Immutable. The resource name for the webhook secret's secret version. Once this field has been set, it cannot be changed.
               Changing this field will result in deleting/ recreating the resource.
        """
        pulumi.set(__self__, "admin_access_token_version_name", admin_access_token_version_name)
        pulumi.set(__self__, "read_access_token_version_name", read_access_token_version_name)
        pulumi.set(__self__, "webhook_secret_version_name", webhook_secret_version_name)

    @property
    @pulumi.getter(name="adminAccessTokenVersionName")
    def admin_access_token_version_name(self) -> str:
        """
        The resource name for the admin access token's secret version.
        """
        return pulumi.get(self, "admin_access_token_version_name")

    @property
    @pulumi.getter(name="readAccessTokenVersionName")
    def read_access_token_version_name(self) -> str:
        """
        The resource name for the read access token's secret version.
        """
        return pulumi.get(self, "read_access_token_version_name")

    @property
    @pulumi.getter(name="webhookSecretVersionName")
    def webhook_secret_version_name(self) -> str:
        """
        Immutable. The resource name for the webhook secret's secret version. Once this field has been set, it cannot be changed.
        Changing this field will result in deleting/ recreating the resource.
        """
        return pulumi.get(self, "webhook_secret_version_name")


@pulumi.output_type
class TriggerApprovalConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "approvalRequired":
            suggest = "approval_required"

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

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

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

    def __init__(__self__, *,
                 approval_required: Optional[bool] = None):
        """
        :param bool approval_required: Whether or not approval is needed. If this is set on a build, it will become pending when run,
               and will need to be explicitly approved to start.
        """
        if approval_required is not None:
            pulumi.set(__self__, "approval_required", approval_required)

    @property
    @pulumi.getter(name="approvalRequired")
    def approval_required(self) -> Optional[bool]:
        """
        Whether or not approval is needed. If this is set on a build, it will become pending when run,
        and will need to be explicitly approved to start.
        """
        return pulumi.get(self, "approval_required")


@pulumi.output_type
class TriggerBitbucketServerTriggerConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "bitbucketServerConfigResource":
            suggest = "bitbucket_server_config_resource"
        elif key == "projectKey":
            suggest = "project_key"
        elif key == "repoSlug":
            suggest = "repo_slug"
        elif key == "pullRequest":
            suggest = "pull_request"

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

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

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

    def __init__(__self__, *,
                 bitbucket_server_config_resource: str,
                 project_key: str,
                 repo_slug: str,
                 pull_request: Optional['outputs.TriggerBitbucketServerTriggerConfigPullRequest'] = None,
                 push: Optional['outputs.TriggerBitbucketServerTriggerConfigPush'] = None):
        """
        :param str bitbucket_server_config_resource: The Bitbucket server config resource that this trigger config maps to.
        :param str project_key: Key of the project that the repo is in. For example: The key for https://mybitbucket.server/projects/TEST/repos/test-repo is "TEST".
        :param str repo_slug: Slug of the repository. A repository slug is a URL-friendly version of a repository name, automatically generated by Bitbucket for use in the URL.
               For example, if the repository name is 'test repo', in the URL it would become 'test-repo' as in https://mybitbucket.server/projects/TEST/repos/test-repo.
        :param 'TriggerBitbucketServerTriggerConfigPullRequestArgs' pull_request: Filter to match changes in pull requests.
               Structure is documented below.
        :param 'TriggerBitbucketServerTriggerConfigPushArgs' push: Filter to match changes in refs like branches, tags.
               Structure is documented below.
        """
        pulumi.set(__self__, "bitbucket_server_config_resource", bitbucket_server_config_resource)
        pulumi.set(__self__, "project_key", project_key)
        pulumi.set(__self__, "repo_slug", repo_slug)
        if pull_request is not None:
            pulumi.set(__self__, "pull_request", pull_request)
        if push is not None:
            pulumi.set(__self__, "push", push)

    @property
    @pulumi.getter(name="bitbucketServerConfigResource")
    def bitbucket_server_config_resource(self) -> str:
        """
        The Bitbucket server config resource that this trigger config maps to.
        """
        return pulumi.get(self, "bitbucket_server_config_resource")

    @property
    @pulumi.getter(name="projectKey")
    def project_key(self) -> str:
        """
        Key of the project that the repo is in. For example: The key for https://mybitbucket.server/projects/TEST/repos/test-repo is "TEST".
        """
        return pulumi.get(self, "project_key")

    @property
    @pulumi.getter(name="repoSlug")
    def repo_slug(self) -> str:
        """
        Slug of the repository. A repository slug is a URL-friendly version of a repository name, automatically generated by Bitbucket for use in the URL.
        For example, if the repository name is 'test repo', in the URL it would become 'test-repo' as in https://mybitbucket.server/projects/TEST/repos/test-repo.
        """
        return pulumi.get(self, "repo_slug")

    @property
    @pulumi.getter(name="pullRequest")
    def pull_request(self) -> Optional['outputs.TriggerBitbucketServerTriggerConfigPullRequest']:
        """
        Filter to match changes in pull requests.
        Structure is documented below.
        """
        return pulumi.get(self, "pull_request")

    @property
    @pulumi.getter
    def push(self) -> Optional['outputs.TriggerBitbucketServerTriggerConfigPush']:
        """
        Filter to match changes in refs like branches, tags.
        Structure is documented below.
        """
        return pulumi.get(self, "push")


@pulumi.output_type
class TriggerBitbucketServerTriggerConfigPullRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "commentControl":
            suggest = "comment_control"
        elif key == "invertRegex":
            suggest = "invert_regex"

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

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

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

    def __init__(__self__, *,
                 branch: str,
                 comment_control: Optional[str] = None,
                 invert_regex: Optional[bool] = None):
        """
        :param str branch: Regex of branches to match.
               The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
        :param str comment_control: Configure builds to run whether a repository owner or collaborator need to comment /gcbrun.
               Possible values are `COMMENTS_DISABLED`, `COMMENTS_ENABLED`, and `COMMENTS_ENABLED_FOR_EXTERNAL_CONTRIBUTORS_ONLY`.
        :param bool invert_regex: If true, branches that do NOT match the git_ref will trigger a build.
        """
        pulumi.set(__self__, "branch", branch)
        if comment_control is not None:
            pulumi.set(__self__, "comment_control", comment_control)
        if invert_regex is not None:
            pulumi.set(__self__, "invert_regex", invert_regex)

    @property
    @pulumi.getter
    def branch(self) -> str:
        """
        Regex of branches to match.
        The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
        """
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter(name="commentControl")
    def comment_control(self) -> Optional[str]:
        """
        Configure builds to run whether a repository owner or collaborator need to comment /gcbrun.
        Possible values are `COMMENTS_DISABLED`, `COMMENTS_ENABLED`, and `COMMENTS_ENABLED_FOR_EXTERNAL_CONTRIBUTORS_ONLY`.
        """
        return pulumi.get(self, "comment_control")

    @property
    @pulumi.getter(name="invertRegex")
    def invert_regex(self) -> Optional[bool]:
        """
        If true, branches that do NOT match the git_ref will trigger a build.
        """
        return pulumi.get(self, "invert_regex")


@pulumi.output_type
class TriggerBitbucketServerTriggerConfigPush(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "invertRegex":
            suggest = "invert_regex"

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

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

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

    def __init__(__self__, *,
                 branch: Optional[str] = None,
                 invert_regex: Optional[bool] = None,
                 tag: Optional[str] = None):
        """
        :param str branch: Regex of branches to match.  Specify only one of branch or tag.
        :param bool invert_regex: When true, only trigger a build if the revision regex does NOT match the gitRef regex.
        :param str tag: Regex of tags to match.  Specify only one of branch or tag.
        """
        if branch is not None:
            pulumi.set(__self__, "branch", branch)
        if invert_regex is not None:
            pulumi.set(__self__, "invert_regex", invert_regex)
        if tag is not None:
            pulumi.set(__self__, "tag", tag)

    @property
    @pulumi.getter
    def branch(self) -> Optional[str]:
        """
        Regex of branches to match.  Specify only one of branch or tag.
        """
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter(name="invertRegex")
    def invert_regex(self) -> Optional[bool]:
        """
        When true, only trigger a build if the revision regex does NOT match the gitRef regex.
        """
        return pulumi.get(self, "invert_regex")

    @property
    @pulumi.getter
    def tag(self) -> Optional[str]:
        """
        Regex of tags to match.  Specify only one of branch or tag.
        """
        return pulumi.get(self, "tag")


@pulumi.output_type
class TriggerBuild(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "availableSecrets":
            suggest = "available_secrets"
        elif key == "logsBucket":
            suggest = "logs_bucket"
        elif key == "queueTtl":
            suggest = "queue_ttl"

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

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

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

    def __init__(__self__, *,
                 steps: Sequence['outputs.TriggerBuildStep'],
                 artifacts: Optional['outputs.TriggerBuildArtifacts'] = None,
                 available_secrets: Optional['outputs.TriggerBuildAvailableSecrets'] = None,
                 images: Optional[Sequence[str]] = None,
                 logs_bucket: Optional[str] = None,
                 options: Optional['outputs.TriggerBuildOptions'] = None,
                 queue_ttl: Optional[str] = None,
                 secrets: Optional[Sequence['outputs.TriggerBuildSecret']] = None,
                 source: Optional['outputs.TriggerBuildSource'] = None,
                 substitutions: Optional[Mapping[str, str]] = None,
                 tags: Optional[Sequence[str]] = None,
                 timeout: Optional[str] = None):
        """
        :param Sequence['TriggerBuildStepArgs'] steps: The operations to be performed on the workspace.
               Structure is documented below.
        :param 'TriggerBuildArtifactsArgs' artifacts: Artifacts produced by the build that should be uploaded upon successful completion of all build steps.
               Structure is documented below.
        :param 'TriggerBuildAvailableSecretsArgs' available_secrets: Secrets and secret environment variables.
               Structure is documented below.
        :param Sequence[str] images: A list of images to be pushed upon the successful completion of all build steps.
               The images are pushed using the builder service account's credentials.
               The digests of the pushed images will be stored in the Build resource's results field.
               If any of the images fail to be pushed, the build status is marked FAILURE.
        :param str logs_bucket: Google Cloud Storage bucket where logs should be written.
               Logs file names will be of the format ${logsBucket}/log-${build_id}.txt.
        :param 'TriggerBuildOptionsArgs' options: Special options for this build.
               Structure is documented below.
        :param str queue_ttl: TTL in queue for this build. If provided and the build is enqueued longer than this value,
               the build will expire and the build status will be EXPIRED.
               The TTL starts ticking from createTime.
               A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
        :param Sequence['TriggerBuildSecretArgs'] secrets: Secrets to decrypt using Cloud Key Management Service.
               Structure is documented below.
        :param 'TriggerBuildSourceArgs' source: The location of the source files to build.
               One of `storageSource` or `repoSource` must be provided.
               Structure is documented below.
        :param Mapping[str, str] substitutions: Substitutions data for Build resource.
        :param Sequence[str] tags: Tags for annotation of a Build. These are not docker tags.
        :param str timeout: Amount of time that this build should be allowed to run, to second granularity.
               If this amount of time elapses, work on the build will cease and the build status will be TIMEOUT.
               This timeout must be equal to or greater than the sum of the timeouts for build steps within the build.
               The expected format is the number of seconds followed by s.
               Default time is ten minutes (600s).
        """
        pulumi.set(__self__, "steps", steps)
        if artifacts is not None:
            pulumi.set(__self__, "artifacts", artifacts)
        if available_secrets is not None:
            pulumi.set(__self__, "available_secrets", available_secrets)
        if images is not None:
            pulumi.set(__self__, "images", images)
        if logs_bucket is not None:
            pulumi.set(__self__, "logs_bucket", logs_bucket)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if queue_ttl is not None:
            pulumi.set(__self__, "queue_ttl", queue_ttl)
        if secrets is not None:
            pulumi.set(__self__, "secrets", secrets)
        if source is not None:
            pulumi.set(__self__, "source", source)
        if substitutions is not None:
            pulumi.set(__self__, "substitutions", substitutions)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def steps(self) -> Sequence['outputs.TriggerBuildStep']:
        """
        The operations to be performed on the workspace.
        Structure is documented below.
        """
        return pulumi.get(self, "steps")

    @property
    @pulumi.getter
    def artifacts(self) -> Optional['outputs.TriggerBuildArtifacts']:
        """
        Artifacts produced by the build that should be uploaded upon successful completion of all build steps.
        Structure is documented below.
        """
        return pulumi.get(self, "artifacts")

    @property
    @pulumi.getter(name="availableSecrets")
    def available_secrets(self) -> Optional['outputs.TriggerBuildAvailableSecrets']:
        """
        Secrets and secret environment variables.
        Structure is documented below.
        """
        return pulumi.get(self, "available_secrets")

    @property
    @pulumi.getter
    def images(self) -> Optional[Sequence[str]]:
        """
        A list of images to be pushed upon the successful completion of all build steps.
        The images are pushed using the builder service account's credentials.
        The digests of the pushed images will be stored in the Build resource's results field.
        If any of the images fail to be pushed, the build status is marked FAILURE.
        """
        return pulumi.get(self, "images")

    @property
    @pulumi.getter(name="logsBucket")
    def logs_bucket(self) -> Optional[str]:
        """
        Google Cloud Storage bucket where logs should be written.
        Logs file names will be of the format ${logsBucket}/log-${build_id}.txt.
        """
        return pulumi.get(self, "logs_bucket")

    @property
    @pulumi.getter
    def options(self) -> Optional['outputs.TriggerBuildOptions']:
        """
        Special options for this build.
        Structure is documented below.
        """
        return pulumi.get(self, "options")

    @property
    @pulumi.getter(name="queueTtl")
    def queue_ttl(self) -> Optional[str]:
        """
        TTL in queue for this build. If provided and the build is enqueued longer than this value,
        the build will expire and the build status will be EXPIRED.
        The TTL starts ticking from createTime.
        A duration in seconds with up to nine fractional digits, terminated by 's'. Example: "3.5s".
        """
        return pulumi.get(self, "queue_ttl")

    @property
    @pulumi.getter
    def secrets(self) -> Optional[Sequence['outputs.TriggerBuildSecret']]:
        """
        Secrets to decrypt using Cloud Key Management Service.
        Structure is documented below.
        """
        return pulumi.get(self, "secrets")

    @property
    @pulumi.getter
    def source(self) -> Optional['outputs.TriggerBuildSource']:
        """
        The location of the source files to build.
        One of `storageSource` or `repoSource` must be provided.
        Structure is documented below.
        """
        return pulumi.get(self, "source")

    @property
    @pulumi.getter
    def substitutions(self) -> Optional[Mapping[str, str]]:
        """
        Substitutions data for Build resource.
        """
        return pulumi.get(self, "substitutions")

    @property
    @pulumi.getter
    def tags(self) -> Optional[Sequence[str]]:
        """
        Tags for annotation of a Build. These are not docker tags.
        """
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[str]:
        """
        Amount of time that this build should be allowed to run, to second granularity.
        If this amount of time elapses, work on the build will cease and the build status will be TIMEOUT.
        This timeout must be equal to or greater than the sum of the timeouts for build steps within the build.
        The expected format is the number of seconds followed by s.
        Default time is ten minutes (600s).
        """
        return pulumi.get(self, "timeout")


@pulumi.output_type
class TriggerBuildArtifacts(dict):
    def __init__(__self__, *,
                 images: Optional[Sequence[str]] = None,
                 objects: Optional['outputs.TriggerBuildArtifactsObjects'] = None):
        """
        :param Sequence[str] images: A list of images to be pushed upon the successful completion of all build steps.
               The images will be pushed using the builder service account's credentials.
               The digests of the pushed images will be stored in the Build resource's results field.
               If any of the images fail to be pushed, the build is marked FAILURE.
        :param 'TriggerBuildArtifactsObjectsArgs' objects: A list of objects to be uploaded to Cloud Storage upon successful completion of all build steps.
               Files in the workspace matching specified paths globs will be uploaded to the
               Cloud Storage location using the builder service account's credentials.
               The location and generation of the uploaded objects will be stored in the Build resource's results field.
               If any objects fail to be pushed, the build is marked FAILURE.
               Structure is documented below.
        """
        if images is not None:
            pulumi.set(__self__, "images", images)
        if objects is not None:
            pulumi.set(__self__, "objects", objects)

    @property
    @pulumi.getter
    def images(self) -> Optional[Sequence[str]]:
        """
        A list of images to be pushed upon the successful completion of all build steps.
        The images will be pushed using the builder service account's credentials.
        The digests of the pushed images will be stored in the Build resource's results field.
        If any of the images fail to be pushed, the build is marked FAILURE.
        """
        return pulumi.get(self, "images")

    @property
    @pulumi.getter
    def objects(self) -> Optional['outputs.TriggerBuildArtifactsObjects']:
        """
        A list of objects to be uploaded to Cloud Storage upon successful completion of all build steps.
        Files in the workspace matching specified paths globs will be uploaded to the
        Cloud Storage location using the builder service account's credentials.
        The location and generation of the uploaded objects will be stored in the Build resource's results field.
        If any objects fail to be pushed, the build is marked FAILURE.
        Structure is documented below.
        """
        return pulumi.get(self, "objects")


@pulumi.output_type
class TriggerBuildArtifactsObjects(dict):
    def __init__(__self__, *,
                 location: Optional[str] = None,
                 paths: Optional[Sequence[str]] = None,
                 timings: Optional[Sequence['outputs.TriggerBuildArtifactsObjectsTiming']] = None):
        """
        :param str location: Cloud Storage bucket and optional object path, in the form "gs://bucket/path/to/somewhere/".
               Files in the workspace matching any path pattern will be uploaded to Cloud Storage with
               this location as a prefix.
        :param Sequence[str] paths: Path globs used to match files in the build's workspace.
        :param Sequence['TriggerBuildArtifactsObjectsTimingArgs'] timings: (Output)
               Output only. Stores timing information for pushing all artifact objects.
               Structure is documented below.
        """
        if location is not None:
            pulumi.set(__self__, "location", location)
        if paths is not None:
            pulumi.set(__self__, "paths", paths)
        if timings is not None:
            pulumi.set(__self__, "timings", timings)

    @property
    @pulumi.getter
    def location(self) -> Optional[str]:
        """
        Cloud Storage bucket and optional object path, in the form "gs://bucket/path/to/somewhere/".
        Files in the workspace matching any path pattern will be uploaded to Cloud Storage with
        this location as a prefix.
        """
        return pulumi.get(self, "location")

    @property
    @pulumi.getter
    def paths(self) -> Optional[Sequence[str]]:
        """
        Path globs used to match files in the build's workspace.
        """
        return pulumi.get(self, "paths")

    @property
    @pulumi.getter
    def timings(self) -> Optional[Sequence['outputs.TriggerBuildArtifactsObjectsTiming']]:
        """
        (Output)
        Output only. Stores timing information for pushing all artifact objects.
        Structure is documented below.
        """
        return pulumi.get(self, "timings")


@pulumi.output_type
class TriggerBuildArtifactsObjectsTiming(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "endTime":
            suggest = "end_time"
        elif key == "startTime":
            suggest = "start_time"

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

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

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

    def __init__(__self__, *,
                 end_time: Optional[str] = None,
                 start_time: Optional[str] = None):
        """
        :param str end_time: End of time span.
               A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to
               nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
        :param str start_time: Start of time span.
               A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to
               nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
        """
        if end_time is not None:
            pulumi.set(__self__, "end_time", end_time)
        if start_time is not None:
            pulumi.set(__self__, "start_time", start_time)

    @property
    @pulumi.getter(name="endTime")
    def end_time(self) -> Optional[str]:
        """
        End of time span.
        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to
        nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
        """
        return pulumi.get(self, "end_time")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> Optional[str]:
        """
        Start of time span.
        A timestamp in RFC3339 UTC "Zulu" format, with nanosecond resolution and up to
        nine fractional digits. Examples: "2014-10-02T15:01:23Z" and "2014-10-02T15:01:23.045123456Z".
        """
        return pulumi.get(self, "start_time")


@pulumi.output_type
class TriggerBuildAvailableSecrets(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretManagers":
            suggest = "secret_managers"

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

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

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

    def __init__(__self__, *,
                 secret_managers: Sequence['outputs.TriggerBuildAvailableSecretsSecretManager']):
        """
        :param Sequence['TriggerBuildAvailableSecretsSecretManagerArgs'] secret_managers: Pairs a secret environment variable with a SecretVersion in Secret Manager.
               Structure is documented below.
        """
        pulumi.set(__self__, "secret_managers", secret_managers)

    @property
    @pulumi.getter(name="secretManagers")
    def secret_managers(self) -> Sequence['outputs.TriggerBuildAvailableSecretsSecretManager']:
        """
        Pairs a secret environment variable with a SecretVersion in Secret Manager.
        Structure is documented below.
        """
        return pulumi.get(self, "secret_managers")


@pulumi.output_type
class TriggerBuildAvailableSecretsSecretManager(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "versionName":
            suggest = "version_name"

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

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

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

    def __init__(__self__, *,
                 env: str,
                 version_name: str):
        """
        :param str env: Environment variable name to associate with the secret. Secret environment
               variables must be unique across all of a build's secrets, and must be used
               by at least one build step.
        :param str version_name: Resource name of the SecretVersion. In format: projects/*/secrets/*/versions/*
        """
        pulumi.set(__self__, "env", env)
        pulumi.set(__self__, "version_name", version_name)

    @property
    @pulumi.getter
    def env(self) -> str:
        """
        Environment variable name to associate with the secret. Secret environment
        variables must be unique across all of a build's secrets, and must be used
        by at least one build step.
        """
        return pulumi.get(self, "env")

    @property
    @pulumi.getter(name="versionName")
    def version_name(self) -> str:
        """
        Resource name of the SecretVersion. In format: projects/*/secrets/*/versions/*
        """
        return pulumi.get(self, "version_name")


@pulumi.output_type
class TriggerBuildOptions(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "diskSizeGb":
            suggest = "disk_size_gb"
        elif key == "dynamicSubstitutions":
            suggest = "dynamic_substitutions"
        elif key == "logStreamingOption":
            suggest = "log_streaming_option"
        elif key == "machineType":
            suggest = "machine_type"
        elif key == "requestedVerifyOption":
            suggest = "requested_verify_option"
        elif key == "secretEnvs":
            suggest = "secret_envs"
        elif key == "sourceProvenanceHashes":
            suggest = "source_provenance_hashes"
        elif key == "substitutionOption":
            suggest = "substitution_option"
        elif key == "workerPool":
            suggest = "worker_pool"

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

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

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

    def __init__(__self__, *,
                 disk_size_gb: Optional[int] = None,
                 dynamic_substitutions: Optional[bool] = None,
                 envs: Optional[Sequence[str]] = None,
                 log_streaming_option: Optional[str] = None,
                 logging: Optional[str] = None,
                 machine_type: Optional[str] = None,
                 requested_verify_option: Optional[str] = None,
                 secret_envs: Optional[Sequence[str]] = None,
                 source_provenance_hashes: Optional[Sequence[str]] = None,
                 substitution_option: Optional[str] = None,
                 volumes: Optional[Sequence['outputs.TriggerBuildOptionsVolume']] = None,
                 worker_pool: Optional[str] = None):
        """
        :param int disk_size_gb: Requested disk size for the VM that runs the build. Note that this is NOT "disk free";
               some of the space will be used by the operating system and build utilities.
               Also note that this is the minimum disk size that will be allocated for the build --
               the build may run with a larger disk than requested. At present, the maximum disk size
               is 1000GB; builds that request more than the maximum are rejected with an error.
        :param bool dynamic_substitutions: Option to specify whether or not to apply bash style string operations to the substitutions.
               NOTE this is always enabled for triggered builds and cannot be overridden in the build configuration file.
        :param Sequence[str] envs: A list of global environment variable definitions that will exist for all build steps
               in this build. If a variable is defined in both globally and in a build step,
               the variable will use the build step value.
               The elements are of the form "KEY=VALUE" for the environment variable "KEY" being given the value "VALUE".
        :param str log_streaming_option: Option to define build log streaming behavior to Google Cloud Storage.
               Possible values are `STREAM_DEFAULT`, `STREAM_ON`, and `STREAM_OFF`.
        :param str logging: Option to specify the logging mode, which determines if and where build logs are stored.
               Possible values are `LOGGING_UNSPECIFIED`, `LEGACY`, `GCS_ONLY`, `STACKDRIVER_ONLY`, `CLOUD_LOGGING_ONLY`, and `NONE`.
        :param str machine_type: Compute Engine machine type on which to run the build.
               Possible values are `UNSPECIFIED`, `N1_HIGHCPU_8`, `N1_HIGHCPU_32`, `E2_HIGHCPU_8`, and `E2_HIGHCPU_32`.
        :param str requested_verify_option: Requested verifiability options.
               Possible values are `NOT_VERIFIED` and `VERIFIED`.
        :param Sequence[str] secret_envs: A list of global environment variables, which are encrypted using a Cloud Key Management
               Service crypto key. These values must be specified in the build's Secret. These variables
               will be available to all build steps in this build.
        :param Sequence[str] source_provenance_hashes: Requested hash for SourceProvenance.
               Each value may be one of `NONE`, `SHA256`, and `MD5`.
        :param str substitution_option: Option to specify behavior when there is an error in the substitution checks.
               NOTE this is always set to ALLOW_LOOSE for triggered builds and cannot be overridden
               in the build configuration file.
               Possible values are `MUST_MATCH` and `ALLOW_LOOSE`.
        :param Sequence['TriggerBuildOptionsVolumeArgs'] volumes: Global list of volumes to mount for ALL build steps
               Each volume is created as an empty volume prior to starting the build process.
               Upon completion of the build, volumes and their contents are discarded. Global
               volume names and paths cannot conflict with the volumes defined a build step.
               Using a global volume in a build with only one step is not valid as it is indicative
               of a build request with an incorrect configuration.
               Structure is documented below.
        :param str worker_pool: Option to specify a WorkerPool for the build. Format projects/{project}/workerPools/{workerPool}
               This field is experimental.
        """
        if disk_size_gb is not None:
            pulumi.set(__self__, "disk_size_gb", disk_size_gb)
        if dynamic_substitutions is not None:
            pulumi.set(__self__, "dynamic_substitutions", dynamic_substitutions)
        if envs is not None:
            pulumi.set(__self__, "envs", envs)
        if log_streaming_option is not None:
            pulumi.set(__self__, "log_streaming_option", log_streaming_option)
        if logging is not None:
            pulumi.set(__self__, "logging", logging)
        if machine_type is not None:
            pulumi.set(__self__, "machine_type", machine_type)
        if requested_verify_option is not None:
            pulumi.set(__self__, "requested_verify_option", requested_verify_option)
        if secret_envs is not None:
            pulumi.set(__self__, "secret_envs", secret_envs)
        if source_provenance_hashes is not None:
            pulumi.set(__self__, "source_provenance_hashes", source_provenance_hashes)
        if substitution_option is not None:
            pulumi.set(__self__, "substitution_option", substitution_option)
        if volumes is not None:
            pulumi.set(__self__, "volumes", volumes)
        if worker_pool is not None:
            pulumi.set(__self__, "worker_pool", worker_pool)

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> Optional[int]:
        """
        Requested disk size for the VM that runs the build. Note that this is NOT "disk free";
        some of the space will be used by the operating system and build utilities.
        Also note that this is the minimum disk size that will be allocated for the build --
        the build may run with a larger disk than requested. At present, the maximum disk size
        is 1000GB; builds that request more than the maximum are rejected with an error.
        """
        return pulumi.get(self, "disk_size_gb")

    @property
    @pulumi.getter(name="dynamicSubstitutions")
    def dynamic_substitutions(self) -> Optional[bool]:
        """
        Option to specify whether or not to apply bash style string operations to the substitutions.
        NOTE this is always enabled for triggered builds and cannot be overridden in the build configuration file.
        """
        return pulumi.get(self, "dynamic_substitutions")

    @property
    @pulumi.getter
    def envs(self) -> Optional[Sequence[str]]:
        """
        A list of global environment variable definitions that will exist for all build steps
        in this build. If a variable is defined in both globally and in a build step,
        the variable will use the build step value.
        The elements are of the form "KEY=VALUE" for the environment variable "KEY" being given the value "VALUE".
        """
        return pulumi.get(self, "envs")

    @property
    @pulumi.getter(name="logStreamingOption")
    def log_streaming_option(self) -> Optional[str]:
        """
        Option to define build log streaming behavior to Google Cloud Storage.
        Possible values are `STREAM_DEFAULT`, `STREAM_ON`, and `STREAM_OFF`.
        """
        return pulumi.get(self, "log_streaming_option")

    @property
    @pulumi.getter
    def logging(self) -> Optional[str]:
        """
        Option to specify the logging mode, which determines if and where build logs are stored.
        Possible values are `LOGGING_UNSPECIFIED`, `LEGACY`, `GCS_ONLY`, `STACKDRIVER_ONLY`, `CLOUD_LOGGING_ONLY`, and `NONE`.
        """
        return pulumi.get(self, "logging")

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> Optional[str]:
        """
        Compute Engine machine type on which to run the build.
        Possible values are `UNSPECIFIED`, `N1_HIGHCPU_8`, `N1_HIGHCPU_32`, `E2_HIGHCPU_8`, and `E2_HIGHCPU_32`.
        """
        return pulumi.get(self, "machine_type")

    @property
    @pulumi.getter(name="requestedVerifyOption")
    def requested_verify_option(self) -> Optional[str]:
        """
        Requested verifiability options.
        Possible values are `NOT_VERIFIED` and `VERIFIED`.
        """
        return pulumi.get(self, "requested_verify_option")

    @property
    @pulumi.getter(name="secretEnvs")
    def secret_envs(self) -> Optional[Sequence[str]]:
        """
        A list of global environment variables, which are encrypted using a Cloud Key Management
        Service crypto key. These values must be specified in the build's Secret. These variables
        will be available to all build steps in this build.
        """
        return pulumi.get(self, "secret_envs")

    @property
    @pulumi.getter(name="sourceProvenanceHashes")
    def source_provenance_hashes(self) -> Optional[Sequence[str]]:
        """
        Requested hash for SourceProvenance.
        Each value may be one of `NONE`, `SHA256`, and `MD5`.
        """
        return pulumi.get(self, "source_provenance_hashes")

    @property
    @pulumi.getter(name="substitutionOption")
    def substitution_option(self) -> Optional[str]:
        """
        Option to specify behavior when there is an error in the substitution checks.
        NOTE this is always set to ALLOW_LOOSE for triggered builds and cannot be overridden
        in the build configuration file.
        Possible values are `MUST_MATCH` and `ALLOW_LOOSE`.
        """
        return pulumi.get(self, "substitution_option")

    @property
    @pulumi.getter
    def volumes(self) -> Optional[Sequence['outputs.TriggerBuildOptionsVolume']]:
        """
        Global list of volumes to mount for ALL build steps
        Each volume is created as an empty volume prior to starting the build process.
        Upon completion of the build, volumes and their contents are discarded. Global
        volume names and paths cannot conflict with the volumes defined a build step.
        Using a global volume in a build with only one step is not valid as it is indicative
        of a build request with an incorrect configuration.
        Structure is documented below.
        """
        return pulumi.get(self, "volumes")

    @property
    @pulumi.getter(name="workerPool")
    def worker_pool(self) -> Optional[str]:
        """
        Option to specify a WorkerPool for the build. Format projects/{project}/workerPools/{workerPool}
        This field is experimental.
        """
        return pulumi.get(self, "worker_pool")


@pulumi.output_type
class TriggerBuildOptionsVolume(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None,
                 path: Optional[str] = None):
        """
        :param str name: Name of the volume to mount.
               Volume names must be unique per build step and must be valid names for Docker volumes.
               Each named volume must be used by at least two build steps.
        :param str path: Path at which to mount the volume.
               Paths must be absolute and cannot conflict with other volume paths on the same
               build step or with certain reserved volume paths.
        """
        if name is not None:
            pulumi.set(__self__, "name", name)
        if path is not None:
            pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        Name of the volume to mount.
        Volume names must be unique per build step and must be valid names for Docker volumes.
        Each named volume must be used by at least two build steps.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def path(self) -> Optional[str]:
        """
        Path at which to mount the volume.
        Paths must be absolute and cannot conflict with other volume paths on the same
        build step or with certain reserved volume paths.
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class TriggerBuildSecret(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "kmsKeyName":
            suggest = "kms_key_name"
        elif key == "secretEnv":
            suggest = "secret_env"

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

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

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

    def __init__(__self__, *,
                 kms_key_name: str,
                 secret_env: Optional[Mapping[str, str]] = None):
        """
        :param str kms_key_name: Cloud KMS key name to use to decrypt these envs.
        :param Mapping[str, str] secret_env: Map of environment variable name to its encrypted value.
               Secret environment variables must be unique across all of a build's secrets,
               and must be used by at least one build step. Values can be at most 64 KB in size.
               There can be at most 100 secret values across all of a build's secrets.
        """
        pulumi.set(__self__, "kms_key_name", kms_key_name)
        if secret_env is not None:
            pulumi.set(__self__, "secret_env", secret_env)

    @property
    @pulumi.getter(name="kmsKeyName")
    def kms_key_name(self) -> str:
        """
        Cloud KMS key name to use to decrypt these envs.
        """
        return pulumi.get(self, "kms_key_name")

    @property
    @pulumi.getter(name="secretEnv")
    def secret_env(self) -> Optional[Mapping[str, str]]:
        """
        Map of environment variable name to its encrypted value.
        Secret environment variables must be unique across all of a build's secrets,
        and must be used by at least one build step. Values can be at most 64 KB in size.
        There can be at most 100 secret values across all of a build's secrets.
        """
        return pulumi.get(self, "secret_env")


@pulumi.output_type
class TriggerBuildSource(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "repoSource":
            suggest = "repo_source"
        elif key == "storageSource":
            suggest = "storage_source"

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

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

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

    def __init__(__self__, *,
                 repo_source: Optional['outputs.TriggerBuildSourceRepoSource'] = None,
                 storage_source: Optional['outputs.TriggerBuildSourceStorageSource'] = None):
        """
        :param 'TriggerBuildSourceRepoSourceArgs' repo_source: Location of the source in a Google Cloud Source Repository.
               Structure is documented below.
        :param 'TriggerBuildSourceStorageSourceArgs' storage_source: Location of the source in an archive file in Google Cloud Storage.
               Structure is documented below.
        """
        if repo_source is not None:
            pulumi.set(__self__, "repo_source", repo_source)
        if storage_source is not None:
            pulumi.set(__self__, "storage_source", storage_source)

    @property
    @pulumi.getter(name="repoSource")
    def repo_source(self) -> Optional['outputs.TriggerBuildSourceRepoSource']:
        """
        Location of the source in a Google Cloud Source Repository.
        Structure is documented below.
        """
        return pulumi.get(self, "repo_source")

    @property
    @pulumi.getter(name="storageSource")
    def storage_source(self) -> Optional['outputs.TriggerBuildSourceStorageSource']:
        """
        Location of the source in an archive file in Google Cloud Storage.
        Structure is documented below.
        """
        return pulumi.get(self, "storage_source")


@pulumi.output_type
class TriggerBuildSourceRepoSource(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "repoName":
            suggest = "repo_name"
        elif key == "branchName":
            suggest = "branch_name"
        elif key == "commitSha":
            suggest = "commit_sha"
        elif key == "invertRegex":
            suggest = "invert_regex"
        elif key == "projectId":
            suggest = "project_id"
        elif key == "tagName":
            suggest = "tag_name"

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

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

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

    def __init__(__self__, *,
                 repo_name: str,
                 branch_name: Optional[str] = None,
                 commit_sha: Optional[str] = None,
                 dir: Optional[str] = None,
                 invert_regex: Optional[bool] = None,
                 project_id: Optional[str] = None,
                 substitutions: Optional[Mapping[str, str]] = None,
                 tag_name: Optional[str] = None):
        """
        :param str repo_name: Name of the Cloud Source Repository.
        :param str branch_name: Regex matching branches to build. Exactly one a of branch name, tag, or commit SHA must be provided.
               The syntax of the regular expressions accepted is the syntax accepted by RE2 and
               described at https://github.com/google/re2/wiki/Syntax
        :param str commit_sha: Explicit commit SHA to build. Exactly one a of branch name, tag, or commit SHA must be provided.
        :param str dir: Directory, relative to the source root, in which to run the build.
               This must be a relative path. If a step's dir is specified and is an absolute path,
               this value is ignored for that step's execution.
        :param bool invert_regex: Only trigger a build if the revision regex does NOT match the revision regex.
        :param str project_id: ID of the project that owns the Cloud Source Repository.
               If omitted, the project ID requesting the build is assumed.
        :param Mapping[str, str] substitutions: Substitutions to use in a triggered build. Should only be used with triggers.run
        :param str tag_name: Regex matching tags to build. Exactly one a of branch name, tag, or commit SHA must be provided.
               The syntax of the regular expressions accepted is the syntax accepted by RE2 and
               described at https://github.com/google/re2/wiki/Syntax
        """
        pulumi.set(__self__, "repo_name", repo_name)
        if branch_name is not None:
            pulumi.set(__self__, "branch_name", branch_name)
        if commit_sha is not None:
            pulumi.set(__self__, "commit_sha", commit_sha)
        if dir is not None:
            pulumi.set(__self__, "dir", dir)
        if invert_regex is not None:
            pulumi.set(__self__, "invert_regex", invert_regex)
        if project_id is not None:
            pulumi.set(__self__, "project_id", project_id)
        if substitutions is not None:
            pulumi.set(__self__, "substitutions", substitutions)
        if tag_name is not None:
            pulumi.set(__self__, "tag_name", tag_name)

    @property
    @pulumi.getter(name="repoName")
    def repo_name(self) -> str:
        """
        Name of the Cloud Source Repository.
        """
        return pulumi.get(self, "repo_name")

    @property
    @pulumi.getter(name="branchName")
    def branch_name(self) -> Optional[str]:
        """
        Regex matching branches to build. Exactly one a of branch name, tag, or commit SHA must be provided.
        The syntax of the regular expressions accepted is the syntax accepted by RE2 and
        described at https://github.com/google/re2/wiki/Syntax
        """
        return pulumi.get(self, "branch_name")

    @property
    @pulumi.getter(name="commitSha")
    def commit_sha(self) -> Optional[str]:
        """
        Explicit commit SHA to build. Exactly one a of branch name, tag, or commit SHA must be provided.
        """
        return pulumi.get(self, "commit_sha")

    @property
    @pulumi.getter
    def dir(self) -> Optional[str]:
        """
        Directory, relative to the source root, in which to run the build.
        This must be a relative path. If a step's dir is specified and is an absolute path,
        this value is ignored for that step's execution.
        """
        return pulumi.get(self, "dir")

    @property
    @pulumi.getter(name="invertRegex")
    def invert_regex(self) -> Optional[bool]:
        """
        Only trigger a build if the revision regex does NOT match the revision regex.
        """
        return pulumi.get(self, "invert_regex")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> Optional[str]:
        """
        ID of the project that owns the Cloud Source Repository.
        If omitted, the project ID requesting the build is assumed.
        """
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter
    def substitutions(self) -> Optional[Mapping[str, str]]:
        """
        Substitutions to use in a triggered build. Should only be used with triggers.run
        """
        return pulumi.get(self, "substitutions")

    @property
    @pulumi.getter(name="tagName")
    def tag_name(self) -> Optional[str]:
        """
        Regex matching tags to build. Exactly one a of branch name, tag, or commit SHA must be provided.
        The syntax of the regular expressions accepted is the syntax accepted by RE2 and
        described at https://github.com/google/re2/wiki/Syntax
        """
        return pulumi.get(self, "tag_name")


@pulumi.output_type
class TriggerBuildSourceStorageSource(dict):
    def __init__(__self__, *,
                 bucket: str,
                 object: str,
                 generation: Optional[str] = None):
        """
        :param str bucket: Google Cloud Storage bucket containing the source.
        :param str object: Google Cloud Storage object containing the source.
               This object must be a gzipped archive file (.tar.gz) containing source to build.
        :param str generation: Google Cloud Storage generation for the object.
               If the generation is omitted, the latest generation will be used
        """
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "object", object)
        if generation is not None:
            pulumi.set(__self__, "generation", generation)

    @property
    @pulumi.getter
    def bucket(self) -> str:
        """
        Google Cloud Storage bucket containing the source.
        """
        return pulumi.get(self, "bucket")

    @property
    @pulumi.getter
    def object(self) -> str:
        """
        Google Cloud Storage object containing the source.
        This object must be a gzipped archive file (.tar.gz) containing source to build.
        """
        return pulumi.get(self, "object")

    @property
    @pulumi.getter
    def generation(self) -> Optional[str]:
        """
        Google Cloud Storage generation for the object.
        If the generation is omitted, the latest generation will be used
        """
        return pulumi.get(self, "generation")


@pulumi.output_type
class TriggerBuildStep(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "secretEnvs":
            suggest = "secret_envs"
        elif key == "waitFors":
            suggest = "wait_fors"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 args: Optional[Sequence[str]] = None,
                 dir: Optional[str] = None,
                 entrypoint: Optional[str] = None,
                 envs: Optional[Sequence[str]] = None,
                 id: Optional[str] = None,
                 script: Optional[str] = None,
                 secret_envs: Optional[Sequence[str]] = None,
                 timeout: Optional[str] = None,
                 timing: Optional[str] = None,
                 volumes: Optional[Sequence['outputs.TriggerBuildStepVolume']] = None,
                 wait_fors: Optional[Sequence[str]] = None):
        """
        :param str name: The name of the container image that will run this particular build step.
               If the image is available in the host's Docker daemon's cache, it will be
               run directly. If not, the host will attempt to pull the image first, using
               the builder service account's credentials if necessary.
               The Docker daemon's cache will already have the latest versions of all of
               the officially supported build steps (see https://github.com/GoogleCloudPlatform/cloud-builders
               for images and examples).
               The Docker daemon will also have cached many of the layers for some popular
               images, like "ubuntu", "debian", but they will be refreshed at the time
               you attempt to use them.
               If you built an image in a previous build step, it will be stored in the
               host's Docker daemon's cache and is available to use as the name for a
               later build step.
        :param Sequence[str] args: A list of arguments that will be presented to the step when it is started.
               If the image used to run the step's container has an entrypoint, the args
               are used as arguments to that entrypoint. If the image does not define an
               entrypoint, the first element in args is used as the entrypoint, and the
               remainder will be used as arguments.
        :param str dir: Working directory to use when running this step's container.
               If this value is a relative path, it is relative to the build's working
               directory. If this value is absolute, it may be outside the build's working
               directory, in which case the contents of the path may not be persisted
               across build step executions, unless a `volume` for that path is specified.
               If the build specifies a `RepoSource` with `dir` and a step with a
               `dir`,
               which specifies an absolute path, the `RepoSource` `dir` is ignored
               for the step's execution.
        :param str entrypoint: Entrypoint to be used instead of the build step image's
               default entrypoint.
               If unset, the image's default entrypoint is used
        :param Sequence[str] envs: A list of environment variable definitions to be used when
               running a step.
               The elements are of the form "KEY=VALUE" for the environment variable
               "KEY" being given the value "VALUE".
        :param str id: Unique identifier for this build step, used in `wait_for` to
               reference this build step as a dependency.
        :param str script: A shell script to be executed in the step.
               When script is provided, the user cannot specify the entrypoint or args.
        :param Sequence[str] secret_envs: A list of environment variables which are encrypted using
               a Cloud Key
               Management Service crypto key. These values must be specified in
               the build's `Secret`.
        :param str timeout: Time limit for executing this build step. If not defined,
               the step has no
               time limit and will be allowed to continue to run until either it
               completes or the build itself times out.
        :param str timing: Output only. Stores timing information for executing this
               build step.
        :param Sequence['TriggerBuildStepVolumeArgs'] volumes: List of volumes to mount into the build step.
               Each volume is created as an empty volume prior to execution of the
               build step. Upon completion of the build, volumes and their contents
               are discarded.
               Using a named volume in only one step is not valid as it is
               indicative of a build request with an incorrect configuration.
               Structure is documented below.
        :param Sequence[str] wait_fors: The ID(s) of the step(s) that this build step depends on.
               This build step will not start until all the build steps in `wait_for`
               have completed successfully. If `wait_for` is empty, this build step
               will start when all previous build steps in the `Build.Steps` list
               have completed successfully.
        """
        pulumi.set(__self__, "name", name)
        if args is not None:
            pulumi.set(__self__, "args", args)
        if dir is not None:
            pulumi.set(__self__, "dir", dir)
        if entrypoint is not None:
            pulumi.set(__self__, "entrypoint", entrypoint)
        if envs is not None:
            pulumi.set(__self__, "envs", envs)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if script is not None:
            pulumi.set(__self__, "script", script)
        if secret_envs is not None:
            pulumi.set(__self__, "secret_envs", secret_envs)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)
        if timing is not None:
            pulumi.set(__self__, "timing", timing)
        if volumes is not None:
            pulumi.set(__self__, "volumes", volumes)
        if wait_fors is not None:
            pulumi.set(__self__, "wait_fors", wait_fors)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the container image that will run this particular build step.
        If the image is available in the host's Docker daemon's cache, it will be
        run directly. If not, the host will attempt to pull the image first, using
        the builder service account's credentials if necessary.
        The Docker daemon's cache will already have the latest versions of all of
        the officially supported build steps (see https://github.com/GoogleCloudPlatform/cloud-builders
        for images and examples).
        The Docker daemon will also have cached many of the layers for some popular
        images, like "ubuntu", "debian", but they will be refreshed at the time
        you attempt to use them.
        If you built an image in a previous build step, it will be stored in the
        host's Docker daemon's cache and is available to use as the name for a
        later build step.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def args(self) -> Optional[Sequence[str]]:
        """
        A list of arguments that will be presented to the step when it is started.
        If the image used to run the step's container has an entrypoint, the args
        are used as arguments to that entrypoint. If the image does not define an
        entrypoint, the first element in args is used as the entrypoint, and the
        remainder will be used as arguments.
        """
        return pulumi.get(self, "args")

    @property
    @pulumi.getter
    def dir(self) -> Optional[str]:
        """
        Working directory to use when running this step's container.
        If this value is a relative path, it is relative to the build's working
        directory. If this value is absolute, it may be outside the build's working
        directory, in which case the contents of the path may not be persisted
        across build step executions, unless a `volume` for that path is specified.
        If the build specifies a `RepoSource` with `dir` and a step with a
        `dir`,
        which specifies an absolute path, the `RepoSource` `dir` is ignored
        for the step's execution.
        """
        return pulumi.get(self, "dir")

    @property
    @pulumi.getter
    def entrypoint(self) -> Optional[str]:
        """
        Entrypoint to be used instead of the build step image's
        default entrypoint.
        If unset, the image's default entrypoint is used
        """
        return pulumi.get(self, "entrypoint")

    @property
    @pulumi.getter
    def envs(self) -> Optional[Sequence[str]]:
        """
        A list of environment variable definitions to be used when
        running a step.
        The elements are of the form "KEY=VALUE" for the environment variable
        "KEY" being given the value "VALUE".
        """
        return pulumi.get(self, "envs")

    @property
    @pulumi.getter
    def id(self) -> Optional[str]:
        """
        Unique identifier for this build step, used in `wait_for` to
        reference this build step as a dependency.
        """
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def script(self) -> Optional[str]:
        """
        A shell script to be executed in the step.
        When script is provided, the user cannot specify the entrypoint or args.
        """
        return pulumi.get(self, "script")

    @property
    @pulumi.getter(name="secretEnvs")
    def secret_envs(self) -> Optional[Sequence[str]]:
        """
        A list of environment variables which are encrypted using
        a Cloud Key
        Management Service crypto key. These values must be specified in
        the build's `Secret`.
        """
        return pulumi.get(self, "secret_envs")

    @property
    @pulumi.getter
    def timeout(self) -> Optional[str]:
        """
        Time limit for executing this build step. If not defined,
        the step has no
        time limit and will be allowed to continue to run until either it
        completes or the build itself times out.
        """
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter
    def timing(self) -> Optional[str]:
        """
        Output only. Stores timing information for executing this
        build step.
        """
        return pulumi.get(self, "timing")

    @property
    @pulumi.getter
    def volumes(self) -> Optional[Sequence['outputs.TriggerBuildStepVolume']]:
        """
        List of volumes to mount into the build step.
        Each volume is created as an empty volume prior to execution of the
        build step. Upon completion of the build, volumes and their contents
        are discarded.
        Using a named volume in only one step is not valid as it is
        indicative of a build request with an incorrect configuration.
        Structure is documented below.
        """
        return pulumi.get(self, "volumes")

    @property
    @pulumi.getter(name="waitFors")
    def wait_fors(self) -> Optional[Sequence[str]]:
        """
        The ID(s) of the step(s) that this build step depends on.
        This build step will not start until all the build steps in `wait_for`
        have completed successfully. If `wait_for` is empty, this build step
        will start when all previous build steps in the `Build.Steps` list
        have completed successfully.
        """
        return pulumi.get(self, "wait_fors")


@pulumi.output_type
class TriggerBuildStepVolume(dict):
    def __init__(__self__, *,
                 name: str,
                 path: str):
        """
        :param str name: Name of the volume to mount.
               Volume names must be unique per build step and must be valid names for Docker volumes.
               Each named volume must be used by at least two build steps.
        :param str path: Path at which to mount the volume.
               Paths must be absolute and cannot conflict with other volume paths on the same
               build step or with certain reserved volume paths.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        Name of the volume to mount.
        Volume names must be unique per build step and must be valid names for Docker volumes.
        Each named volume must be used by at least two build steps.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def path(self) -> str:
        """
        Path at which to mount the volume.
        Paths must be absolute and cannot conflict with other volume paths on the same
        build step or with certain reserved volume paths.
        """
        return pulumi.get(self, "path")


@pulumi.output_type
class TriggerGitFileSource(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "repoType":
            suggest = "repo_type"
        elif key == "githubEnterpriseConfig":
            suggest = "github_enterprise_config"

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

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

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

    def __init__(__self__, *,
                 path: str,
                 repo_type: str,
                 github_enterprise_config: Optional[str] = None,
                 revision: Optional[str] = None,
                 uri: Optional[str] = None):
        """
        :param str path: The path of the file, with the repo root as the root of the path.
        :param str repo_type: The type of the repo, since it may not be explicit from the repo field (e.g from a URL).
               Values can be UNKNOWN, CLOUD_SOURCE_REPOSITORIES, GITHUB, BITBUCKET_SERVER
               Possible values are `UNKNOWN`, `CLOUD_SOURCE_REPOSITORIES`, `GITHUB`, and `BITBUCKET_SERVER`.
        :param str github_enterprise_config: The full resource name of the github enterprise config.
               Format: projects/{project}/locations/{location}/githubEnterpriseConfigs/{id}. projects/{project}/githubEnterpriseConfigs/{id}.
        :param str revision: The branch, tag, arbitrary ref, or SHA version of the repo to use when resolving the
               filename (optional). This field respects the same syntax/resolution as described here: https://git-scm.com/docs/gitrevisions
               If unspecified, the revision from which the trigger invocation originated is assumed to be the revision from which to read the specified path.
        :param str uri: The URI of the repo (optional). If unspecified, the repo from which the trigger
               invocation originated is assumed to be the repo from which to read the specified path.
        """
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "repo_type", repo_type)
        if github_enterprise_config is not None:
            pulumi.set(__self__, "github_enterprise_config", github_enterprise_config)
        if revision is not None:
            pulumi.set(__self__, "revision", revision)
        if uri is not None:
            pulumi.set(__self__, "uri", uri)

    @property
    @pulumi.getter
    def path(self) -> str:
        """
        The path of the file, with the repo root as the root of the path.
        """
        return pulumi.get(self, "path")

    @property
    @pulumi.getter(name="repoType")
    def repo_type(self) -> str:
        """
        The type of the repo, since it may not be explicit from the repo field (e.g from a URL).
        Values can be UNKNOWN, CLOUD_SOURCE_REPOSITORIES, GITHUB, BITBUCKET_SERVER
        Possible values are `UNKNOWN`, `CLOUD_SOURCE_REPOSITORIES`, `GITHUB`, and `BITBUCKET_SERVER`.
        """
        return pulumi.get(self, "repo_type")

    @property
    @pulumi.getter(name="githubEnterpriseConfig")
    def github_enterprise_config(self) -> Optional[str]:
        """
        The full resource name of the github enterprise config.
        Format: projects/{project}/locations/{location}/githubEnterpriseConfigs/{id}. projects/{project}/githubEnterpriseConfigs/{id}.
        """
        return pulumi.get(self, "github_enterprise_config")

    @property
    @pulumi.getter
    def revision(self) -> Optional[str]:
        """
        The branch, tag, arbitrary ref, or SHA version of the repo to use when resolving the
        filename (optional). This field respects the same syntax/resolution as described here: https://git-scm.com/docs/gitrevisions
        If unspecified, the revision from which the trigger invocation originated is assumed to be the revision from which to read the specified path.
        """
        return pulumi.get(self, "revision")

    @property
    @pulumi.getter
    def uri(self) -> Optional[str]:
        """
        The URI of the repo (optional). If unspecified, the repo from which the trigger
        invocation originated is assumed to be the repo from which to read the specified path.
        """
        return pulumi.get(self, "uri")


@pulumi.output_type
class TriggerGithub(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "enterpriseConfigResourceName":
            suggest = "enterprise_config_resource_name"
        elif key == "pullRequest":
            suggest = "pull_request"

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

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

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

    def __init__(__self__, *,
                 enterprise_config_resource_name: Optional[str] = None,
                 name: Optional[str] = None,
                 owner: Optional[str] = None,
                 pull_request: Optional['outputs.TriggerGithubPullRequest'] = None,
                 push: Optional['outputs.TriggerGithubPush'] = None):
        """
        :param str enterprise_config_resource_name: The resource name of the github enterprise config that should be applied to this installation.
               For example: "projects/{$projectId}/locations/{$locationId}/githubEnterpriseConfigs/{$configId}"
        :param str name: Name of the repository. For example: The name for
               https://github.com/googlecloudplatform/cloud-builders is "cloud-builders".
        :param str owner: Owner of the repository. For example: The owner for
               https://github.com/googlecloudplatform/cloud-builders is "googlecloudplatform".
        :param 'TriggerGithubPullRequestArgs' pull_request: filter to match changes in pull requests. Specify only one of `pull_request` or `push`.
               Structure is documented below.
        :param 'TriggerGithubPushArgs' push: filter to match changes in refs, like branches or tags. Specify only one of `pull_request` or `push`.
               Structure is documented below.
        """
        if enterprise_config_resource_name is not None:
            pulumi.set(__self__, "enterprise_config_resource_name", enterprise_config_resource_name)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if owner is not None:
            pulumi.set(__self__, "owner", owner)
        if pull_request is not None:
            pulumi.set(__self__, "pull_request", pull_request)
        if push is not None:
            pulumi.set(__self__, "push", push)

    @property
    @pulumi.getter(name="enterpriseConfigResourceName")
    def enterprise_config_resource_name(self) -> Optional[str]:
        """
        The resource name of the github enterprise config that should be applied to this installation.
        For example: "projects/{$projectId}/locations/{$locationId}/githubEnterpriseConfigs/{$configId}"
        """
        return pulumi.get(self, "enterprise_config_resource_name")

    @property
    @pulumi.getter
    def name(self) -> Optional[str]:
        """
        Name of the repository. For example: The name for
        https://github.com/googlecloudplatform/cloud-builders is "cloud-builders".
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def owner(self) -> Optional[str]:
        """
        Owner of the repository. For example: The owner for
        https://github.com/googlecloudplatform/cloud-builders is "googlecloudplatform".
        """
        return pulumi.get(self, "owner")

    @property
    @pulumi.getter(name="pullRequest")
    def pull_request(self) -> Optional['outputs.TriggerGithubPullRequest']:
        """
        filter to match changes in pull requests. Specify only one of `pull_request` or `push`.
        Structure is documented below.
        """
        return pulumi.get(self, "pull_request")

    @property
    @pulumi.getter
    def push(self) -> Optional['outputs.TriggerGithubPush']:
        """
        filter to match changes in refs, like branches or tags. Specify only one of `pull_request` or `push`.
        Structure is documented below.
        """
        return pulumi.get(self, "push")


@pulumi.output_type
class TriggerGithubPullRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "commentControl":
            suggest = "comment_control"
        elif key == "invertRegex":
            suggest = "invert_regex"

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

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

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

    def __init__(__self__, *,
                 branch: str,
                 comment_control: Optional[str] = None,
                 invert_regex: Optional[bool] = None):
        """
        :param str branch: Regex of branches to match.
               The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
        :param str comment_control: Configure builds to run whether a repository owner or collaborator need to comment /gcbrun.
               Possible values are `COMMENTS_DISABLED`, `COMMENTS_ENABLED`, and `COMMENTS_ENABLED_FOR_EXTERNAL_CONTRIBUTORS_ONLY`.
        :param bool invert_regex: If true, branches that do NOT match the git_ref will trigger a build.
        """
        pulumi.set(__self__, "branch", branch)
        if comment_control is not None:
            pulumi.set(__self__, "comment_control", comment_control)
        if invert_regex is not None:
            pulumi.set(__self__, "invert_regex", invert_regex)

    @property
    @pulumi.getter
    def branch(self) -> str:
        """
        Regex of branches to match.
        The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
        """
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter(name="commentControl")
    def comment_control(self) -> Optional[str]:
        """
        Configure builds to run whether a repository owner or collaborator need to comment /gcbrun.
        Possible values are `COMMENTS_DISABLED`, `COMMENTS_ENABLED`, and `COMMENTS_ENABLED_FOR_EXTERNAL_CONTRIBUTORS_ONLY`.
        """
        return pulumi.get(self, "comment_control")

    @property
    @pulumi.getter(name="invertRegex")
    def invert_regex(self) -> Optional[bool]:
        """
        If true, branches that do NOT match the git_ref will trigger a build.
        """
        return pulumi.get(self, "invert_regex")


@pulumi.output_type
class TriggerGithubPush(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "invertRegex":
            suggest = "invert_regex"

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

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

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

    def __init__(__self__, *,
                 branch: Optional[str] = None,
                 invert_regex: Optional[bool] = None,
                 tag: Optional[str] = None):
        """
        :param str branch: Regex of branches to match.  Specify only one of branch or tag.
        :param bool invert_regex: When true, only trigger a build if the revision regex does NOT match the gitRef regex.
        :param str tag: Regex of tags to match.  Specify only one of branch or tag.
        """
        if branch is not None:
            pulumi.set(__self__, "branch", branch)
        if invert_regex is not None:
            pulumi.set(__self__, "invert_regex", invert_regex)
        if tag is not None:
            pulumi.set(__self__, "tag", tag)

    @property
    @pulumi.getter
    def branch(self) -> Optional[str]:
        """
        Regex of branches to match.  Specify only one of branch or tag.
        """
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter(name="invertRegex")
    def invert_regex(self) -> Optional[bool]:
        """
        When true, only trigger a build if the revision regex does NOT match the gitRef regex.
        """
        return pulumi.get(self, "invert_regex")

    @property
    @pulumi.getter
    def tag(self) -> Optional[str]:
        """
        Regex of tags to match.  Specify only one of branch or tag.
        """
        return pulumi.get(self, "tag")


@pulumi.output_type
class TriggerPubsubConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "serviceAccountEmail":
            suggest = "service_account_email"

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

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

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

    def __init__(__self__, *,
                 topic: str,
                 service_account_email: Optional[str] = None,
                 state: Optional[str] = None,
                 subscription: Optional[str] = None):
        """
        :param str topic: The name of the topic from which this subscription is receiving messages.
        :param str service_account_email: Service account that will make the push request.
        :param str state: (Output)
               Potential issues with the underlying Pub/Sub subscription configuration.
               Only populated on get requests.
        :param str subscription: (Output)
               Output only. Name of the subscription.
        """
        pulumi.set(__self__, "topic", topic)
        if service_account_email is not None:
            pulumi.set(__self__, "service_account_email", service_account_email)
        if state is not None:
            pulumi.set(__self__, "state", state)
        if subscription is not None:
            pulumi.set(__self__, "subscription", subscription)

    @property
    @pulumi.getter
    def topic(self) -> str:
        """
        The name of the topic from which this subscription is receiving messages.
        """
        return pulumi.get(self, "topic")

    @property
    @pulumi.getter(name="serviceAccountEmail")
    def service_account_email(self) -> Optional[str]:
        """
        Service account that will make the push request.
        """
        return pulumi.get(self, "service_account_email")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        """
        (Output)
        Potential issues with the underlying Pub/Sub subscription configuration.
        Only populated on get requests.
        """
        return pulumi.get(self, "state")

    @property
    @pulumi.getter
    def subscription(self) -> Optional[str]:
        """
        (Output)
        Output only. Name of the subscription.
        """
        return pulumi.get(self, "subscription")


@pulumi.output_type
class TriggerRepositoryEventConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "pullRequest":
            suggest = "pull_request"

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

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

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

    def __init__(__self__, *,
                 pull_request: Optional['outputs.TriggerRepositoryEventConfigPullRequest'] = None,
                 push: Optional['outputs.TriggerRepositoryEventConfigPush'] = None,
                 repository: Optional[str] = None):
        """
        :param 'TriggerRepositoryEventConfigPullRequestArgs' pull_request: Contains filter properties for matching Pull Requests.
               Structure is documented below.
        :param 'TriggerRepositoryEventConfigPushArgs' push: Contains filter properties for matching git pushes.
               Structure is documented below.
        :param str repository: The resource name of the Repo API resource.
        """
        if pull_request is not None:
            pulumi.set(__self__, "pull_request", pull_request)
        if push is not None:
            pulumi.set(__self__, "push", push)
        if repository is not None:
            pulumi.set(__self__, "repository", repository)

    @property
    @pulumi.getter(name="pullRequest")
    def pull_request(self) -> Optional['outputs.TriggerRepositoryEventConfigPullRequest']:
        """
        Contains filter properties for matching Pull Requests.
        Structure is documented below.
        """
        return pulumi.get(self, "pull_request")

    @property
    @pulumi.getter
    def push(self) -> Optional['outputs.TriggerRepositoryEventConfigPush']:
        """
        Contains filter properties for matching git pushes.
        Structure is documented below.
        """
        return pulumi.get(self, "push")

    @property
    @pulumi.getter
    def repository(self) -> Optional[str]:
        """
        The resource name of the Repo API resource.
        """
        return pulumi.get(self, "repository")


@pulumi.output_type
class TriggerRepositoryEventConfigPullRequest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "commentControl":
            suggest = "comment_control"
        elif key == "invertRegex":
            suggest = "invert_regex"

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

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

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

    def __init__(__self__, *,
                 branch: Optional[str] = None,
                 comment_control: Optional[str] = None,
                 invert_regex: Optional[bool] = None):
        """
        :param str branch: Regex of branches to match.
               The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
        :param str comment_control: Configure builds to run whether a repository owner or collaborator need to comment /gcbrun.
               Possible values are `COMMENTS_DISABLED`, `COMMENTS_ENABLED`, and `COMMENTS_ENABLED_FOR_EXTERNAL_CONTRIBUTORS_ONLY`.
        :param bool invert_regex: If true, branches that do NOT match the git_ref will trigger a build.
        """
        if branch is not None:
            pulumi.set(__self__, "branch", branch)
        if comment_control is not None:
            pulumi.set(__self__, "comment_control", comment_control)
        if invert_regex is not None:
            pulumi.set(__self__, "invert_regex", invert_regex)

    @property
    @pulumi.getter
    def branch(self) -> Optional[str]:
        """
        Regex of branches to match.
        The syntax of the regular expressions accepted is the syntax accepted by RE2 and described at https://github.com/google/re2/wiki/Syntax
        """
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter(name="commentControl")
    def comment_control(self) -> Optional[str]:
        """
        Configure builds to run whether a repository owner or collaborator need to comment /gcbrun.
        Possible values are `COMMENTS_DISABLED`, `COMMENTS_ENABLED`, and `COMMENTS_ENABLED_FOR_EXTERNAL_CONTRIBUTORS_ONLY`.
        """
        return pulumi.get(self, "comment_control")

    @property
    @pulumi.getter(name="invertRegex")
    def invert_regex(self) -> Optional[bool]:
        """
        If true, branches that do NOT match the git_ref will trigger a build.
        """
        return pulumi.get(self, "invert_regex")


@pulumi.output_type
class TriggerRepositoryEventConfigPush(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "invertRegex":
            suggest = "invert_regex"

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

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

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

    def __init__(__self__, *,
                 branch: Optional[str] = None,
                 invert_regex: Optional[bool] = None,
                 tag: Optional[str] = None):
        """
        :param str branch: Regex of branches to match.  Specify only one of branch or tag.
        :param bool invert_regex: When true, only trigger a build if the revision regex does NOT match the gitRef regex.
        :param str tag: Regex of tags to match.  Specify only one of branch or tag.
        """
        if branch is not None:
            pulumi.set(__self__, "branch", branch)
        if invert_regex is not None:
            pulumi.set(__self__, "invert_regex", invert_regex)
        if tag is not None:
            pulumi.set(__self__, "tag", tag)

    @property
    @pulumi.getter
    def branch(self) -> Optional[str]:
        """
        Regex of branches to match.  Specify only one of branch or tag.
        """
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter(name="invertRegex")
    def invert_regex(self) -> Optional[bool]:
        """
        When true, only trigger a build if the revision regex does NOT match the gitRef regex.
        """
        return pulumi.get(self, "invert_regex")

    @property
    @pulumi.getter
    def tag(self) -> Optional[str]:
        """
        Regex of tags to match.  Specify only one of branch or tag.
        """
        return pulumi.get(self, "tag")


@pulumi.output_type
class TriggerSourceToBuild(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "repoType":
            suggest = "repo_type"
        elif key == "githubEnterpriseConfig":
            suggest = "github_enterprise_config"

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

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

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

    def __init__(__self__, *,
                 ref: str,
                 repo_type: str,
                 uri: str,
                 github_enterprise_config: Optional[str] = None):
        """
        :param str ref: The branch or tag to use. Must start with "refs/" (required).
        :param str repo_type: The type of the repo, since it may not be explicit from the repo field (e.g from a URL).
               Values can be UNKNOWN, CLOUD_SOURCE_REPOSITORIES, GITHUB, BITBUCKET_SERVER
               Possible values are `UNKNOWN`, `CLOUD_SOURCE_REPOSITORIES`, `GITHUB`, and `BITBUCKET_SERVER`.
        :param str uri: The URI of the repo (required).
        :param str github_enterprise_config: The full resource name of the github enterprise config.
               Format: projects/{project}/locations/{location}/githubEnterpriseConfigs/{id}. projects/{project}/githubEnterpriseConfigs/{id}.
        """
        pulumi.set(__self__, "ref", ref)
        pulumi.set(__self__, "repo_type", repo_type)
        pulumi.set(__self__, "uri", uri)
        if github_enterprise_config is not None:
            pulumi.set(__self__, "github_enterprise_config", github_enterprise_config)

    @property
    @pulumi.getter
    def ref(self) -> str:
        """
        The branch or tag to use. Must start with "refs/" (required).
        """
        return pulumi.get(self, "ref")

    @property
    @pulumi.getter(name="repoType")
    def repo_type(self) -> str:
        """
        The type of the repo, since it may not be explicit from the repo field (e.g from a URL).
        Values can be UNKNOWN, CLOUD_SOURCE_REPOSITORIES, GITHUB, BITBUCKET_SERVER
        Possible values are `UNKNOWN`, `CLOUD_SOURCE_REPOSITORIES`, `GITHUB`, and `BITBUCKET_SERVER`.
        """
        return pulumi.get(self, "repo_type")

    @property
    @pulumi.getter
    def uri(self) -> str:
        """
        The URI of the repo (required).
        """
        return pulumi.get(self, "uri")

    @property
    @pulumi.getter(name="githubEnterpriseConfig")
    def github_enterprise_config(self) -> Optional[str]:
        """
        The full resource name of the github enterprise config.
        Format: projects/{project}/locations/{location}/githubEnterpriseConfigs/{id}. projects/{project}/githubEnterpriseConfigs/{id}.
        """
        return pulumi.get(self, "github_enterprise_config")


@pulumi.output_type
class TriggerTriggerTemplate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "branchName":
            suggest = "branch_name"
        elif key == "commitSha":
            suggest = "commit_sha"
        elif key == "invertRegex":
            suggest = "invert_regex"
        elif key == "projectId":
            suggest = "project_id"
        elif key == "repoName":
            suggest = "repo_name"
        elif key == "tagName":
            suggest = "tag_name"

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

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

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

    def __init__(__self__, *,
                 branch_name: Optional[str] = None,
                 commit_sha: Optional[str] = None,
                 dir: Optional[str] = None,
                 invert_regex: Optional[bool] = None,
                 project_id: Optional[str] = None,
                 repo_name: Optional[str] = None,
                 tag_name: Optional[str] = None):
        """
        :param str branch_name: Name of the branch to build. Exactly one a of branch name, tag, or commit SHA must be provided.
               This field is a regular expression.
        :param str commit_sha: Explicit commit SHA to build. Exactly one of a branch name, tag, or commit SHA must be provided.
        :param str dir: Directory, relative to the source root, in which to run the build.
               This must be a relative path. If a step's dir is specified and
               is an absolute path, this value is ignored for that step's
               execution.
        :param bool invert_regex: Only trigger a build if the revision regex does NOT match the revision regex.
        :param str project_id: ID of the project that owns the Cloud Source Repository. If
               omitted, the project ID requesting the build is assumed.
        :param str repo_name: Name of the Cloud Source Repository. If omitted, the name "default" is assumed.
        :param str tag_name: Name of the tag to build. Exactly one of a branch name, tag, or commit SHA must be provided.
               This field is a regular expression.
        """
        if branch_name is not None:
            pulumi.set(__self__, "branch_name", branch_name)
        if commit_sha is not None:
            pulumi.set(__self__, "commit_sha", commit_sha)
        if dir is not None:
            pulumi.set(__self__, "dir", dir)
        if invert_regex is not None:
            pulumi.set(__self__, "invert_regex", invert_regex)
        if project_id is not None:
            pulumi.set(__self__, "project_id", project_id)
        if repo_name is not None:
            pulumi.set(__self__, "repo_name", repo_name)
        if tag_name is not None:
            pulumi.set(__self__, "tag_name", tag_name)

    @property
    @pulumi.getter(name="branchName")
    def branch_name(self) -> Optional[str]:
        """
        Name of the branch to build. Exactly one a of branch name, tag, or commit SHA must be provided.
        This field is a regular expression.
        """
        return pulumi.get(self, "branch_name")

    @property
    @pulumi.getter(name="commitSha")
    def commit_sha(self) -> Optional[str]:
        """
        Explicit commit SHA to build. Exactly one of a branch name, tag, or commit SHA must be provided.
        """
        return pulumi.get(self, "commit_sha")

    @property
    @pulumi.getter
    def dir(self) -> Optional[str]:
        """
        Directory, relative to the source root, in which to run the build.
        This must be a relative path. If a step's dir is specified and
        is an absolute path, this value is ignored for that step's
        execution.
        """
        return pulumi.get(self, "dir")

    @property
    @pulumi.getter(name="invertRegex")
    def invert_regex(self) -> Optional[bool]:
        """
        Only trigger a build if the revision regex does NOT match the revision regex.
        """
        return pulumi.get(self, "invert_regex")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> Optional[str]:
        """
        ID of the project that owns the Cloud Source Repository. If
        omitted, the project ID requesting the build is assumed.
        """
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter(name="repoName")
    def repo_name(self) -> Optional[str]:
        """
        Name of the Cloud Source Repository. If omitted, the name "default" is assumed.
        """
        return pulumi.get(self, "repo_name")

    @property
    @pulumi.getter(name="tagName")
    def tag_name(self) -> Optional[str]:
        """
        Name of the tag to build. Exactly one of a branch name, tag, or commit SHA must be provided.
        This field is a regular expression.
        """
        return pulumi.get(self, "tag_name")


@pulumi.output_type
class TriggerWebhookConfig(dict):
    def __init__(__self__, *,
                 secret: str,
                 state: Optional[str] = None):
        """
        :param str secret: Resource name for the secret required as a URL parameter.
        :param str state: (Output)
               Potential issues with the underlying Pub/Sub subscription configuration.
               Only populated on get requests.
        """
        pulumi.set(__self__, "secret", secret)
        if state is not None:
            pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter
    def secret(self) -> str:
        """
        Resource name for the secret required as a URL parameter.
        """
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter
    def state(self) -> Optional[str]:
        """
        (Output)
        Potential issues with the underlying Pub/Sub subscription configuration.
        Only populated on get requests.
        """
        return pulumi.get(self, "state")


@pulumi.output_type
class WorkerPoolNetworkConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "peeredNetwork":
            suggest = "peered_network"
        elif key == "peeredNetworkIpRange":
            suggest = "peered_network_ip_range"

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

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

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

    def __init__(__self__, *,
                 peered_network: str,
                 peered_network_ip_range: Optional[str] = None):
        """
        :param str peered_network: Immutable. The network definition that the workers are peered to. If this section is left empty, the workers will be peered to `WorkerPool.project_id` on the service producer network. Must be in the format `projects/{project}/global/networks/{network}`, where `{project}` is a project number, such as `12345`, and `{network}` is the name of a VPC network in the project. See (https://cloud.google.com/cloud-build/docs/custom-workers/set-up-custom-worker-pool-environment#understanding_the_network_configuration_options)
        :param str peered_network_ip_range: Immutable. Subnet IP range within the peered network. This is specified in CIDR notation with a slash and the subnet prefix size. You can optionally specify an IP address before the subnet prefix value. e.g. `192.168.0.0/29` would specify an IP range starting at 192.168.0.0 with a prefix size of 29 bits. `/16` would specify a prefix size of 16 bits, with an automatically determined IP within the peered VPC. If unspecified, a value of `/24` will be used.
        """
        pulumi.set(__self__, "peered_network", peered_network)
        if peered_network_ip_range is not None:
            pulumi.set(__self__, "peered_network_ip_range", peered_network_ip_range)

    @property
    @pulumi.getter(name="peeredNetwork")
    def peered_network(self) -> str:
        """
        Immutable. The network definition that the workers are peered to. If this section is left empty, the workers will be peered to `WorkerPool.project_id` on the service producer network. Must be in the format `projects/{project}/global/networks/{network}`, where `{project}` is a project number, such as `12345`, and `{network}` is the name of a VPC network in the project. See (https://cloud.google.com/cloud-build/docs/custom-workers/set-up-custom-worker-pool-environment#understanding_the_network_configuration_options)
        """
        return pulumi.get(self, "peered_network")

    @property
    @pulumi.getter(name="peeredNetworkIpRange")
    def peered_network_ip_range(self) -> Optional[str]:
        """
        Immutable. Subnet IP range within the peered network. This is specified in CIDR notation with a slash and the subnet prefix size. You can optionally specify an IP address before the subnet prefix value. e.g. `192.168.0.0/29` would specify an IP range starting at 192.168.0.0 with a prefix size of 29 bits. `/16` would specify a prefix size of 16 bits, with an automatically determined IP within the peered VPC. If unspecified, a value of `/24` will be used.
        """
        return pulumi.get(self, "peered_network_ip_range")


@pulumi.output_type
class WorkerPoolWorkerConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "diskSizeGb":
            suggest = "disk_size_gb"
        elif key == "machineType":
            suggest = "machine_type"
        elif key == "noExternalIp":
            suggest = "no_external_ip"

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

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

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

    def __init__(__self__, *,
                 disk_size_gb: Optional[int] = None,
                 machine_type: Optional[str] = None,
                 no_external_ip: Optional[bool] = None):
        """
        :param int disk_size_gb: Size of the disk attached to the worker, in GB. See (https://cloud.google.com/cloud-build/docs/custom-workers/worker-pool-config-file). Specify a value of up to 1000. If `0` is specified, Cloud Build will use a standard disk size.
        :param str machine_type: Machine type of a worker, such as `n1-standard-1`. See (https://cloud.google.com/cloud-build/docs/custom-workers/worker-pool-config-file). If left blank, Cloud Build will use `n1-standard-1`.
        :param bool no_external_ip: If true, workers are created without any public address, which prevents network egress to public IPs.
        """
        if disk_size_gb is not None:
            pulumi.set(__self__, "disk_size_gb", disk_size_gb)
        if machine_type is not None:
            pulumi.set(__self__, "machine_type", machine_type)
        if no_external_ip is not None:
            pulumi.set(__self__, "no_external_ip", no_external_ip)

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> Optional[int]:
        """
        Size of the disk attached to the worker, in GB. See (https://cloud.google.com/cloud-build/docs/custom-workers/worker-pool-config-file). Specify a value of up to 1000. If `0` is specified, Cloud Build will use a standard disk size.
        """
        return pulumi.get(self, "disk_size_gb")

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> Optional[str]:
        """
        Machine type of a worker, such as `n1-standard-1`. See (https://cloud.google.com/cloud-build/docs/custom-workers/worker-pool-config-file). If left blank, Cloud Build will use `n1-standard-1`.
        """
        return pulumi.get(self, "machine_type")

    @property
    @pulumi.getter(name="noExternalIp")
    def no_external_ip(self) -> Optional[bool]:
        """
        If true, workers are created without any public address, which prevents network egress to public IPs.
        """
        return pulumi.get(self, "no_external_ip")


@pulumi.output_type
class GetTriggerApprovalConfigResult(dict):
    def __init__(__self__, *,
                 approval_required: bool):
        pulumi.set(__self__, "approval_required", approval_required)

    @property
    @pulumi.getter(name="approvalRequired")
    def approval_required(self) -> bool:
        return pulumi.get(self, "approval_required")


@pulumi.output_type
class GetTriggerBitbucketServerTriggerConfigResult(dict):
    def __init__(__self__, *,
                 bitbucket_server_config_resource: str,
                 project_key: str,
                 pull_requests: Sequence['outputs.GetTriggerBitbucketServerTriggerConfigPullRequestResult'],
                 pushes: Sequence['outputs.GetTriggerBitbucketServerTriggerConfigPushResult'],
                 repo_slug: str):
        pulumi.set(__self__, "bitbucket_server_config_resource", bitbucket_server_config_resource)
        pulumi.set(__self__, "project_key", project_key)
        pulumi.set(__self__, "pull_requests", pull_requests)
        pulumi.set(__self__, "pushes", pushes)
        pulumi.set(__self__, "repo_slug", repo_slug)

    @property
    @pulumi.getter(name="bitbucketServerConfigResource")
    def bitbucket_server_config_resource(self) -> str:
        return pulumi.get(self, "bitbucket_server_config_resource")

    @property
    @pulumi.getter(name="projectKey")
    def project_key(self) -> str:
        return pulumi.get(self, "project_key")

    @property
    @pulumi.getter(name="pullRequests")
    def pull_requests(self) -> Sequence['outputs.GetTriggerBitbucketServerTriggerConfigPullRequestResult']:
        return pulumi.get(self, "pull_requests")

    @property
    @pulumi.getter
    def pushes(self) -> Sequence['outputs.GetTriggerBitbucketServerTriggerConfigPushResult']:
        return pulumi.get(self, "pushes")

    @property
    @pulumi.getter(name="repoSlug")
    def repo_slug(self) -> str:
        return pulumi.get(self, "repo_slug")


@pulumi.output_type
class GetTriggerBitbucketServerTriggerConfigPullRequestResult(dict):
    def __init__(__self__, *,
                 branch: str,
                 comment_control: str,
                 invert_regex: bool):
        pulumi.set(__self__, "branch", branch)
        pulumi.set(__self__, "comment_control", comment_control)
        pulumi.set(__self__, "invert_regex", invert_regex)

    @property
    @pulumi.getter
    def branch(self) -> str:
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter(name="commentControl")
    def comment_control(self) -> str:
        return pulumi.get(self, "comment_control")

    @property
    @pulumi.getter(name="invertRegex")
    def invert_regex(self) -> bool:
        return pulumi.get(self, "invert_regex")


@pulumi.output_type
class GetTriggerBitbucketServerTriggerConfigPushResult(dict):
    def __init__(__self__, *,
                 branch: str,
                 invert_regex: bool,
                 tag: str):
        pulumi.set(__self__, "branch", branch)
        pulumi.set(__self__, "invert_regex", invert_regex)
        pulumi.set(__self__, "tag", tag)

    @property
    @pulumi.getter
    def branch(self) -> str:
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter(name="invertRegex")
    def invert_regex(self) -> bool:
        return pulumi.get(self, "invert_regex")

    @property
    @pulumi.getter
    def tag(self) -> str:
        return pulumi.get(self, "tag")


@pulumi.output_type
class GetTriggerBuildResult(dict):
    def __init__(__self__, *,
                 artifacts: Sequence['outputs.GetTriggerBuildArtifactResult'],
                 available_secrets: Sequence['outputs.GetTriggerBuildAvailableSecretResult'],
                 images: Sequence[str],
                 logs_bucket: str,
                 options: Sequence['outputs.GetTriggerBuildOptionResult'],
                 queue_ttl: str,
                 secrets: Sequence['outputs.GetTriggerBuildSecretResult'],
                 sources: Sequence['outputs.GetTriggerBuildSourceResult'],
                 steps: Sequence['outputs.GetTriggerBuildStepResult'],
                 substitutions: Mapping[str, str],
                 tags: Sequence[str],
                 timeout: str):
        pulumi.set(__self__, "artifacts", artifacts)
        pulumi.set(__self__, "available_secrets", available_secrets)
        pulumi.set(__self__, "images", images)
        pulumi.set(__self__, "logs_bucket", logs_bucket)
        pulumi.set(__self__, "options", options)
        pulumi.set(__self__, "queue_ttl", queue_ttl)
        pulumi.set(__self__, "secrets", secrets)
        pulumi.set(__self__, "sources", sources)
        pulumi.set(__self__, "steps", steps)
        pulumi.set(__self__, "substitutions", substitutions)
        pulumi.set(__self__, "tags", tags)
        pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter
    def artifacts(self) -> Sequence['outputs.GetTriggerBuildArtifactResult']:
        return pulumi.get(self, "artifacts")

    @property
    @pulumi.getter(name="availableSecrets")
    def available_secrets(self) -> Sequence['outputs.GetTriggerBuildAvailableSecretResult']:
        return pulumi.get(self, "available_secrets")

    @property
    @pulumi.getter
    def images(self) -> Sequence[str]:
        return pulumi.get(self, "images")

    @property
    @pulumi.getter(name="logsBucket")
    def logs_bucket(self) -> str:
        return pulumi.get(self, "logs_bucket")

    @property
    @pulumi.getter
    def options(self) -> Sequence['outputs.GetTriggerBuildOptionResult']:
        return pulumi.get(self, "options")

    @property
    @pulumi.getter(name="queueTtl")
    def queue_ttl(self) -> str:
        return pulumi.get(self, "queue_ttl")

    @property
    @pulumi.getter
    def secrets(self) -> Sequence['outputs.GetTriggerBuildSecretResult']:
        return pulumi.get(self, "secrets")

    @property
    @pulumi.getter
    def sources(self) -> Sequence['outputs.GetTriggerBuildSourceResult']:
        return pulumi.get(self, "sources")

    @property
    @pulumi.getter
    def steps(self) -> Sequence['outputs.GetTriggerBuildStepResult']:
        return pulumi.get(self, "steps")

    @property
    @pulumi.getter
    def substitutions(self) -> Mapping[str, str]:
        return pulumi.get(self, "substitutions")

    @property
    @pulumi.getter
    def tags(self) -> Sequence[str]:
        return pulumi.get(self, "tags")

    @property
    @pulumi.getter
    def timeout(self) -> str:
        return pulumi.get(self, "timeout")


@pulumi.output_type
class GetTriggerBuildArtifactResult(dict):
    def __init__(__self__, *,
                 images: Sequence[str],
                 objects: Sequence['outputs.GetTriggerBuildArtifactObjectResult']):
        pulumi.set(__self__, "images", images)
        pulumi.set(__self__, "objects", objects)

    @property
    @pulumi.getter
    def images(self) -> Sequence[str]:
        return pulumi.get(self, "images")

    @property
    @pulumi.getter
    def objects(self) -> Sequence['outputs.GetTriggerBuildArtifactObjectResult']:
        return pulumi.get(self, "objects")


@pulumi.output_type
class GetTriggerBuildArtifactObjectResult(dict):
    def __init__(__self__, *,
                 location: str,
                 paths: Sequence[str],
                 timings: Sequence['outputs.GetTriggerBuildArtifactObjectTimingResult']):
        """
        :param str location: The Cloud Build location for the trigger.
        """
        pulumi.set(__self__, "location", location)
        pulumi.set(__self__, "paths", paths)
        pulumi.set(__self__, "timings", timings)

    @property
    @pulumi.getter
    def location(self) -> str:
        """
        The Cloud Build location for the trigger.
        """
        return pulumi.get(self, "location")

    @property
    @pulumi.getter
    def paths(self) -> Sequence[str]:
        return pulumi.get(self, "paths")

    @property
    @pulumi.getter
    def timings(self) -> Sequence['outputs.GetTriggerBuildArtifactObjectTimingResult']:
        return pulumi.get(self, "timings")


@pulumi.output_type
class GetTriggerBuildArtifactObjectTimingResult(dict):
    def __init__(__self__, *,
                 end_time: str,
                 start_time: str):
        pulumi.set(__self__, "end_time", end_time)
        pulumi.set(__self__, "start_time", start_time)

    @property
    @pulumi.getter(name="endTime")
    def end_time(self) -> str:
        return pulumi.get(self, "end_time")

    @property
    @pulumi.getter(name="startTime")
    def start_time(self) -> str:
        return pulumi.get(self, "start_time")


@pulumi.output_type
class GetTriggerBuildAvailableSecretResult(dict):
    def __init__(__self__, *,
                 secret_managers: Sequence['outputs.GetTriggerBuildAvailableSecretSecretManagerResult']):
        pulumi.set(__self__, "secret_managers", secret_managers)

    @property
    @pulumi.getter(name="secretManagers")
    def secret_managers(self) -> Sequence['outputs.GetTriggerBuildAvailableSecretSecretManagerResult']:
        return pulumi.get(self, "secret_managers")


@pulumi.output_type
class GetTriggerBuildAvailableSecretSecretManagerResult(dict):
    def __init__(__self__, *,
                 env: str,
                 version_name: str):
        pulumi.set(__self__, "env", env)
        pulumi.set(__self__, "version_name", version_name)

    @property
    @pulumi.getter
    def env(self) -> str:
        return pulumi.get(self, "env")

    @property
    @pulumi.getter(name="versionName")
    def version_name(self) -> str:
        return pulumi.get(self, "version_name")


@pulumi.output_type
class GetTriggerBuildOptionResult(dict):
    def __init__(__self__, *,
                 disk_size_gb: int,
                 dynamic_substitutions: bool,
                 envs: Sequence[str],
                 log_streaming_option: str,
                 logging: str,
                 machine_type: str,
                 requested_verify_option: str,
                 secret_envs: Sequence[str],
                 source_provenance_hashes: Sequence[str],
                 substitution_option: str,
                 volumes: Sequence['outputs.GetTriggerBuildOptionVolumeResult'],
                 worker_pool: str):
        pulumi.set(__self__, "disk_size_gb", disk_size_gb)
        pulumi.set(__self__, "dynamic_substitutions", dynamic_substitutions)
        pulumi.set(__self__, "envs", envs)
        pulumi.set(__self__, "log_streaming_option", log_streaming_option)
        pulumi.set(__self__, "logging", logging)
        pulumi.set(__self__, "machine_type", machine_type)
        pulumi.set(__self__, "requested_verify_option", requested_verify_option)
        pulumi.set(__self__, "secret_envs", secret_envs)
        pulumi.set(__self__, "source_provenance_hashes", source_provenance_hashes)
        pulumi.set(__self__, "substitution_option", substitution_option)
        pulumi.set(__self__, "volumes", volumes)
        pulumi.set(__self__, "worker_pool", worker_pool)

    @property
    @pulumi.getter(name="diskSizeGb")
    def disk_size_gb(self) -> int:
        return pulumi.get(self, "disk_size_gb")

    @property
    @pulumi.getter(name="dynamicSubstitutions")
    def dynamic_substitutions(self) -> bool:
        return pulumi.get(self, "dynamic_substitutions")

    @property
    @pulumi.getter
    def envs(self) -> Sequence[str]:
        return pulumi.get(self, "envs")

    @property
    @pulumi.getter(name="logStreamingOption")
    def log_streaming_option(self) -> str:
        return pulumi.get(self, "log_streaming_option")

    @property
    @pulumi.getter
    def logging(self) -> str:
        return pulumi.get(self, "logging")

    @property
    @pulumi.getter(name="machineType")
    def machine_type(self) -> str:
        return pulumi.get(self, "machine_type")

    @property
    @pulumi.getter(name="requestedVerifyOption")
    def requested_verify_option(self) -> str:
        return pulumi.get(self, "requested_verify_option")

    @property
    @pulumi.getter(name="secretEnvs")
    def secret_envs(self) -> Sequence[str]:
        return pulumi.get(self, "secret_envs")

    @property
    @pulumi.getter(name="sourceProvenanceHashes")
    def source_provenance_hashes(self) -> Sequence[str]:
        return pulumi.get(self, "source_provenance_hashes")

    @property
    @pulumi.getter(name="substitutionOption")
    def substitution_option(self) -> str:
        return pulumi.get(self, "substitution_option")

    @property
    @pulumi.getter
    def volumes(self) -> Sequence['outputs.GetTriggerBuildOptionVolumeResult']:
        return pulumi.get(self, "volumes")

    @property
    @pulumi.getter(name="workerPool")
    def worker_pool(self) -> str:
        return pulumi.get(self, "worker_pool")


@pulumi.output_type
class GetTriggerBuildOptionVolumeResult(dict):
    def __init__(__self__, *,
                 name: str,
                 path: str):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def name(self) -> str:
        return pulumi.get(self, "name")

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


@pulumi.output_type
class GetTriggerBuildSecretResult(dict):
    def __init__(__self__, *,
                 kms_key_name: str,
                 secret_env: Mapping[str, str]):
        pulumi.set(__self__, "kms_key_name", kms_key_name)
        pulumi.set(__self__, "secret_env", secret_env)

    @property
    @pulumi.getter(name="kmsKeyName")
    def kms_key_name(self) -> str:
        return pulumi.get(self, "kms_key_name")

    @property
    @pulumi.getter(name="secretEnv")
    def secret_env(self) -> Mapping[str, str]:
        return pulumi.get(self, "secret_env")


@pulumi.output_type
class GetTriggerBuildSourceResult(dict):
    def __init__(__self__, *,
                 repo_sources: Sequence['outputs.GetTriggerBuildSourceRepoSourceResult'],
                 storage_sources: Sequence['outputs.GetTriggerBuildSourceStorageSourceResult']):
        pulumi.set(__self__, "repo_sources", repo_sources)
        pulumi.set(__self__, "storage_sources", storage_sources)

    @property
    @pulumi.getter(name="repoSources")
    def repo_sources(self) -> Sequence['outputs.GetTriggerBuildSourceRepoSourceResult']:
        return pulumi.get(self, "repo_sources")

    @property
    @pulumi.getter(name="storageSources")
    def storage_sources(self) -> Sequence['outputs.GetTriggerBuildSourceStorageSourceResult']:
        return pulumi.get(self, "storage_sources")


@pulumi.output_type
class GetTriggerBuildSourceRepoSourceResult(dict):
    def __init__(__self__, *,
                 branch_name: str,
                 commit_sha: str,
                 dir: str,
                 invert_regex: bool,
                 project_id: str,
                 repo_name: str,
                 substitutions: Mapping[str, str],
                 tag_name: str):
        pulumi.set(__self__, "branch_name", branch_name)
        pulumi.set(__self__, "commit_sha", commit_sha)
        pulumi.set(__self__, "dir", dir)
        pulumi.set(__self__, "invert_regex", invert_regex)
        pulumi.set(__self__, "project_id", project_id)
        pulumi.set(__self__, "repo_name", repo_name)
        pulumi.set(__self__, "substitutions", substitutions)
        pulumi.set(__self__, "tag_name", tag_name)

    @property
    @pulumi.getter(name="branchName")
    def branch_name(self) -> str:
        return pulumi.get(self, "branch_name")

    @property
    @pulumi.getter(name="commitSha")
    def commit_sha(self) -> str:
        return pulumi.get(self, "commit_sha")

    @property
    @pulumi.getter
    def dir(self) -> str:
        return pulumi.get(self, "dir")

    @property
    @pulumi.getter(name="invertRegex")
    def invert_regex(self) -> bool:
        return pulumi.get(self, "invert_regex")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> str:
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter(name="repoName")
    def repo_name(self) -> str:
        return pulumi.get(self, "repo_name")

    @property
    @pulumi.getter
    def substitutions(self) -> Mapping[str, str]:
        return pulumi.get(self, "substitutions")

    @property
    @pulumi.getter(name="tagName")
    def tag_name(self) -> str:
        return pulumi.get(self, "tag_name")


@pulumi.output_type
class GetTriggerBuildSourceStorageSourceResult(dict):
    def __init__(__self__, *,
                 bucket: str,
                 generation: str,
                 object: str):
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "generation", generation)
        pulumi.set(__self__, "object", object)

    @property
    @pulumi.getter
    def bucket(self) -> str:
        return pulumi.get(self, "bucket")

    @property
    @pulumi.getter
    def generation(self) -> str:
        return pulumi.get(self, "generation")

    @property
    @pulumi.getter
    def object(self) -> str:
        return pulumi.get(self, "object")


@pulumi.output_type
class GetTriggerBuildStepResult(dict):
    def __init__(__self__, *,
                 args: Sequence[str],
                 dir: str,
                 entrypoint: str,
                 envs: Sequence[str],
                 id: str,
                 name: str,
                 script: str,
                 secret_envs: Sequence[str],
                 timeout: str,
                 timing: str,
                 volumes: Sequence['outputs.GetTriggerBuildStepVolumeResult'],
                 wait_fors: Sequence[str]):
        pulumi.set(__self__, "args", args)
        pulumi.set(__self__, "dir", dir)
        pulumi.set(__self__, "entrypoint", entrypoint)
        pulumi.set(__self__, "envs", envs)
        pulumi.set(__self__, "id", id)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "script", script)
        pulumi.set(__self__, "secret_envs", secret_envs)
        pulumi.set(__self__, "timeout", timeout)
        pulumi.set(__self__, "timing", timing)
        pulumi.set(__self__, "volumes", volumes)
        pulumi.set(__self__, "wait_fors", wait_fors)

    @property
    @pulumi.getter
    def args(self) -> Sequence[str]:
        return pulumi.get(self, "args")

    @property
    @pulumi.getter
    def dir(self) -> str:
        return pulumi.get(self, "dir")

    @property
    @pulumi.getter
    def entrypoint(self) -> str:
        return pulumi.get(self, "entrypoint")

    @property
    @pulumi.getter
    def envs(self) -> Sequence[str]:
        return pulumi.get(self, "envs")

    @property
    @pulumi.getter
    def id(self) -> str:
        return pulumi.get(self, "id")

    @property
    @pulumi.getter
    def name(self) -> str:
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def script(self) -> str:
        return pulumi.get(self, "script")

    @property
    @pulumi.getter(name="secretEnvs")
    def secret_envs(self) -> Sequence[str]:
        return pulumi.get(self, "secret_envs")

    @property
    @pulumi.getter
    def timeout(self) -> str:
        return pulumi.get(self, "timeout")

    @property
    @pulumi.getter
    def timing(self) -> str:
        return pulumi.get(self, "timing")

    @property
    @pulumi.getter
    def volumes(self) -> Sequence['outputs.GetTriggerBuildStepVolumeResult']:
        return pulumi.get(self, "volumes")

    @property
    @pulumi.getter(name="waitFors")
    def wait_fors(self) -> Sequence[str]:
        return pulumi.get(self, "wait_fors")


@pulumi.output_type
class GetTriggerBuildStepVolumeResult(dict):
    def __init__(__self__, *,
                 name: str,
                 path: str):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "path", path)

    @property
    @pulumi.getter
    def name(self) -> str:
        return pulumi.get(self, "name")

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


@pulumi.output_type
class GetTriggerGitFileSourceResult(dict):
    def __init__(__self__, *,
                 github_enterprise_config: str,
                 path: str,
                 repo_type: str,
                 revision: str,
                 uri: str):
        pulumi.set(__self__, "github_enterprise_config", github_enterprise_config)
        pulumi.set(__self__, "path", path)
        pulumi.set(__self__, "repo_type", repo_type)
        pulumi.set(__self__, "revision", revision)
        pulumi.set(__self__, "uri", uri)

    @property
    @pulumi.getter(name="githubEnterpriseConfig")
    def github_enterprise_config(self) -> str:
        return pulumi.get(self, "github_enterprise_config")

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

    @property
    @pulumi.getter(name="repoType")
    def repo_type(self) -> str:
        return pulumi.get(self, "repo_type")

    @property
    @pulumi.getter
    def revision(self) -> str:
        return pulumi.get(self, "revision")

    @property
    @pulumi.getter
    def uri(self) -> str:
        return pulumi.get(self, "uri")


@pulumi.output_type
class GetTriggerGithubResult(dict):
    def __init__(__self__, *,
                 enterprise_config_resource_name: str,
                 name: str,
                 owner: str,
                 pull_requests: Sequence['outputs.GetTriggerGithubPullRequestResult'],
                 pushes: Sequence['outputs.GetTriggerGithubPushResult']):
        pulumi.set(__self__, "enterprise_config_resource_name", enterprise_config_resource_name)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "owner", owner)
        pulumi.set(__self__, "pull_requests", pull_requests)
        pulumi.set(__self__, "pushes", pushes)

    @property
    @pulumi.getter(name="enterpriseConfigResourceName")
    def enterprise_config_resource_name(self) -> str:
        return pulumi.get(self, "enterprise_config_resource_name")

    @property
    @pulumi.getter
    def name(self) -> str:
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def owner(self) -> str:
        return pulumi.get(self, "owner")

    @property
    @pulumi.getter(name="pullRequests")
    def pull_requests(self) -> Sequence['outputs.GetTriggerGithubPullRequestResult']:
        return pulumi.get(self, "pull_requests")

    @property
    @pulumi.getter
    def pushes(self) -> Sequence['outputs.GetTriggerGithubPushResult']:
        return pulumi.get(self, "pushes")


@pulumi.output_type
class GetTriggerGithubPullRequestResult(dict):
    def __init__(__self__, *,
                 branch: str,
                 comment_control: str,
                 invert_regex: bool):
        pulumi.set(__self__, "branch", branch)
        pulumi.set(__self__, "comment_control", comment_control)
        pulumi.set(__self__, "invert_regex", invert_regex)

    @property
    @pulumi.getter
    def branch(self) -> str:
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter(name="commentControl")
    def comment_control(self) -> str:
        return pulumi.get(self, "comment_control")

    @property
    @pulumi.getter(name="invertRegex")
    def invert_regex(self) -> bool:
        return pulumi.get(self, "invert_regex")


@pulumi.output_type
class GetTriggerGithubPushResult(dict):
    def __init__(__self__, *,
                 branch: str,
                 invert_regex: bool,
                 tag: str):
        pulumi.set(__self__, "branch", branch)
        pulumi.set(__self__, "invert_regex", invert_regex)
        pulumi.set(__self__, "tag", tag)

    @property
    @pulumi.getter
    def branch(self) -> str:
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter(name="invertRegex")
    def invert_regex(self) -> bool:
        return pulumi.get(self, "invert_regex")

    @property
    @pulumi.getter
    def tag(self) -> str:
        return pulumi.get(self, "tag")


@pulumi.output_type
class GetTriggerPubsubConfigResult(dict):
    def __init__(__self__, *,
                 service_account_email: str,
                 state: str,
                 subscription: str,
                 topic: str):
        pulumi.set(__self__, "service_account_email", service_account_email)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "subscription", subscription)
        pulumi.set(__self__, "topic", topic)

    @property
    @pulumi.getter(name="serviceAccountEmail")
    def service_account_email(self) -> str:
        return pulumi.get(self, "service_account_email")

    @property
    @pulumi.getter
    def state(self) -> str:
        return pulumi.get(self, "state")

    @property
    @pulumi.getter
    def subscription(self) -> str:
        return pulumi.get(self, "subscription")

    @property
    @pulumi.getter
    def topic(self) -> str:
        return pulumi.get(self, "topic")


@pulumi.output_type
class GetTriggerRepositoryEventConfigResult(dict):
    def __init__(__self__, *,
                 pull_requests: Sequence['outputs.GetTriggerRepositoryEventConfigPullRequestResult'],
                 pushes: Sequence['outputs.GetTriggerRepositoryEventConfigPushResult'],
                 repository: str):
        pulumi.set(__self__, "pull_requests", pull_requests)
        pulumi.set(__self__, "pushes", pushes)
        pulumi.set(__self__, "repository", repository)

    @property
    @pulumi.getter(name="pullRequests")
    def pull_requests(self) -> Sequence['outputs.GetTriggerRepositoryEventConfigPullRequestResult']:
        return pulumi.get(self, "pull_requests")

    @property
    @pulumi.getter
    def pushes(self) -> Sequence['outputs.GetTriggerRepositoryEventConfigPushResult']:
        return pulumi.get(self, "pushes")

    @property
    @pulumi.getter
    def repository(self) -> str:
        return pulumi.get(self, "repository")


@pulumi.output_type
class GetTriggerRepositoryEventConfigPullRequestResult(dict):
    def __init__(__self__, *,
                 branch: str,
                 comment_control: str,
                 invert_regex: bool):
        pulumi.set(__self__, "branch", branch)
        pulumi.set(__self__, "comment_control", comment_control)
        pulumi.set(__self__, "invert_regex", invert_regex)

    @property
    @pulumi.getter
    def branch(self) -> str:
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter(name="commentControl")
    def comment_control(self) -> str:
        return pulumi.get(self, "comment_control")

    @property
    @pulumi.getter(name="invertRegex")
    def invert_regex(self) -> bool:
        return pulumi.get(self, "invert_regex")


@pulumi.output_type
class GetTriggerRepositoryEventConfigPushResult(dict):
    def __init__(__self__, *,
                 branch: str,
                 invert_regex: bool,
                 tag: str):
        pulumi.set(__self__, "branch", branch)
        pulumi.set(__self__, "invert_regex", invert_regex)
        pulumi.set(__self__, "tag", tag)

    @property
    @pulumi.getter
    def branch(self) -> str:
        return pulumi.get(self, "branch")

    @property
    @pulumi.getter(name="invertRegex")
    def invert_regex(self) -> bool:
        return pulumi.get(self, "invert_regex")

    @property
    @pulumi.getter
    def tag(self) -> str:
        return pulumi.get(self, "tag")


@pulumi.output_type
class GetTriggerSourceToBuildResult(dict):
    def __init__(__self__, *,
                 github_enterprise_config: str,
                 ref: str,
                 repo_type: str,
                 uri: str):
        pulumi.set(__self__, "github_enterprise_config", github_enterprise_config)
        pulumi.set(__self__, "ref", ref)
        pulumi.set(__self__, "repo_type", repo_type)
        pulumi.set(__self__, "uri", uri)

    @property
    @pulumi.getter(name="githubEnterpriseConfig")
    def github_enterprise_config(self) -> str:
        return pulumi.get(self, "github_enterprise_config")

    @property
    @pulumi.getter
    def ref(self) -> str:
        return pulumi.get(self, "ref")

    @property
    @pulumi.getter(name="repoType")
    def repo_type(self) -> str:
        return pulumi.get(self, "repo_type")

    @property
    @pulumi.getter
    def uri(self) -> str:
        return pulumi.get(self, "uri")


@pulumi.output_type
class GetTriggerTriggerTemplateResult(dict):
    def __init__(__self__, *,
                 branch_name: str,
                 commit_sha: str,
                 dir: str,
                 invert_regex: bool,
                 project_id: str,
                 repo_name: str,
                 tag_name: str):
        pulumi.set(__self__, "branch_name", branch_name)
        pulumi.set(__self__, "commit_sha", commit_sha)
        pulumi.set(__self__, "dir", dir)
        pulumi.set(__self__, "invert_regex", invert_regex)
        pulumi.set(__self__, "project_id", project_id)
        pulumi.set(__self__, "repo_name", repo_name)
        pulumi.set(__self__, "tag_name", tag_name)

    @property
    @pulumi.getter(name="branchName")
    def branch_name(self) -> str:
        return pulumi.get(self, "branch_name")

    @property
    @pulumi.getter(name="commitSha")
    def commit_sha(self) -> str:
        return pulumi.get(self, "commit_sha")

    @property
    @pulumi.getter
    def dir(self) -> str:
        return pulumi.get(self, "dir")

    @property
    @pulumi.getter(name="invertRegex")
    def invert_regex(self) -> bool:
        return pulumi.get(self, "invert_regex")

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> str:
        return pulumi.get(self, "project_id")

    @property
    @pulumi.getter(name="repoName")
    def repo_name(self) -> str:
        return pulumi.get(self, "repo_name")

    @property
    @pulumi.getter(name="tagName")
    def tag_name(self) -> str:
        return pulumi.get(self, "tag_name")


@pulumi.output_type
class GetTriggerWebhookConfigResult(dict):
    def __init__(__self__, *,
                 secret: str,
                 state: str):
        pulumi.set(__self__, "secret", secret)
        pulumi.set(__self__, "state", state)

    @property
    @pulumi.getter
    def secret(self) -> str:
        return pulumi.get(self, "secret")

    @property
    @pulumi.getter
    def state(self) -> str:
        return pulumi.get(self, "state")


