# 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__ = [
    'DeliveryPipelineCondition',
    'DeliveryPipelineConditionPipelineReadyCondition',
    'DeliveryPipelineConditionTargetsPresentCondition',
    'DeliveryPipelineConditionTargetsTypeCondition',
    'DeliveryPipelineSerialPipeline',
    'DeliveryPipelineSerialPipelineStage',
    'DeliveryPipelineSerialPipelineStageStrategy',
    'DeliveryPipelineSerialPipelineStageStrategyCanary',
    'DeliveryPipelineSerialPipelineStageStrategyCanaryCanaryDeployment',
    'DeliveryPipelineSerialPipelineStageStrategyCanaryCustomCanaryDeployment',
    'DeliveryPipelineSerialPipelineStageStrategyCanaryCustomCanaryDeploymentPhaseConfig',
    'DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfig',
    'DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigCloudRun',
    'DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetes',
    'DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetesGatewayServiceMesh',
    'DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetesServiceNetworking',
    'DeliveryPipelineSerialPipelineStageStrategyStandard',
    'TargetAnthosCluster',
    'TargetExecutionConfig',
    'TargetGke',
    'TargetMultiTarget',
    'TargetRun',
]

@pulumi.output_type
class DeliveryPipelineCondition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "pipelineReadyConditions":
            suggest = "pipeline_ready_conditions"
        elif key == "targetsPresentConditions":
            suggest = "targets_present_conditions"
        elif key == "targetsTypeConditions":
            suggest = "targets_type_conditions"

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

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

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

    def __init__(__self__, *,
                 pipeline_ready_conditions: Optional[Sequence['outputs.DeliveryPipelineConditionPipelineReadyCondition']] = None,
                 targets_present_conditions: Optional[Sequence['outputs.DeliveryPipelineConditionTargetsPresentCondition']] = None,
                 targets_type_conditions: Optional[Sequence['outputs.DeliveryPipelineConditionTargetsTypeCondition']] = None):
        if pipeline_ready_conditions is not None:
            pulumi.set(__self__, "pipeline_ready_conditions", pipeline_ready_conditions)
        if targets_present_conditions is not None:
            pulumi.set(__self__, "targets_present_conditions", targets_present_conditions)
        if targets_type_conditions is not None:
            pulumi.set(__self__, "targets_type_conditions", targets_type_conditions)

    @property
    @pulumi.getter(name="pipelineReadyConditions")
    def pipeline_ready_conditions(self) -> Optional[Sequence['outputs.DeliveryPipelineConditionPipelineReadyCondition']]:
        return pulumi.get(self, "pipeline_ready_conditions")

    @property
    @pulumi.getter(name="targetsPresentConditions")
    def targets_present_conditions(self) -> Optional[Sequence['outputs.DeliveryPipelineConditionTargetsPresentCondition']]:
        return pulumi.get(self, "targets_present_conditions")

    @property
    @pulumi.getter(name="targetsTypeConditions")
    def targets_type_conditions(self) -> Optional[Sequence['outputs.DeliveryPipelineConditionTargetsTypeCondition']]:
        return pulumi.get(self, "targets_type_conditions")


@pulumi.output_type
class DeliveryPipelineConditionPipelineReadyCondition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "updateTime":
            suggest = "update_time"

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

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

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

    def __init__(__self__, *,
                 status: Optional[bool] = None,
                 update_time: Optional[str] = None):
        """
        :param str update_time: Output only. Most recent time at which the pipeline was updated.
        """
        if status is not None:
            pulumi.set(__self__, "status", status)
        if update_time is not None:
            pulumi.set(__self__, "update_time", update_time)

    @property
    @pulumi.getter
    def status(self) -> Optional[bool]:
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="updateTime")
    def update_time(self) -> Optional[str]:
        """
        Output only. Most recent time at which the pipeline was updated.
        """
        return pulumi.get(self, "update_time")


@pulumi.output_type
class DeliveryPipelineConditionTargetsPresentCondition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "missingTargets":
            suggest = "missing_targets"
        elif key == "updateTime":
            suggest = "update_time"

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

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

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

    def __init__(__self__, *,
                 missing_targets: Optional[Sequence[str]] = None,
                 status: Optional[bool] = None,
                 update_time: Optional[str] = None):
        """
        :param str update_time: Output only. Most recent time at which the pipeline was updated.
        """
        if missing_targets is not None:
            pulumi.set(__self__, "missing_targets", missing_targets)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if update_time is not None:
            pulumi.set(__self__, "update_time", update_time)

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

    @property
    @pulumi.getter
    def status(self) -> Optional[bool]:
        return pulumi.get(self, "status")

    @property
    @pulumi.getter(name="updateTime")
    def update_time(self) -> Optional[str]:
        """
        Output only. Most recent time at which the pipeline was updated.
        """
        return pulumi.get(self, "update_time")


@pulumi.output_type
class DeliveryPipelineConditionTargetsTypeCondition(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "errorDetails":
            suggest = "error_details"

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

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

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

    def __init__(__self__, *,
                 error_details: Optional[str] = None,
                 status: Optional[bool] = None):
        if error_details is not None:
            pulumi.set(__self__, "error_details", error_details)
        if status is not None:
            pulumi.set(__self__, "status", status)

    @property
    @pulumi.getter(name="errorDetails")
    def error_details(self) -> Optional[str]:
        return pulumi.get(self, "error_details")

    @property
    @pulumi.getter
    def status(self) -> Optional[bool]:
        return pulumi.get(self, "status")


@pulumi.output_type
class DeliveryPipelineSerialPipeline(dict):
    def __init__(__self__, *,
                 stages: Optional[Sequence['outputs.DeliveryPipelineSerialPipelineStage']] = None):
        """
        :param Sequence['DeliveryPipelineSerialPipelineStageArgs'] stages: Each stage specifies configuration for a `Target`. The ordering of this list defines the promotion flow.
        """
        if stages is not None:
            pulumi.set(__self__, "stages", stages)

    @property
    @pulumi.getter
    def stages(self) -> Optional[Sequence['outputs.DeliveryPipelineSerialPipelineStage']]:
        """
        Each stage specifies configuration for a `Target`. The ordering of this list defines the promotion flow.
        """
        return pulumi.get(self, "stages")


@pulumi.output_type
class DeliveryPipelineSerialPipelineStage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetId":
            suggest = "target_id"

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

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

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

    def __init__(__self__, *,
                 profiles: Optional[Sequence[str]] = None,
                 strategy: Optional['outputs.DeliveryPipelineSerialPipelineStageStrategy'] = None,
                 target_id: Optional[str] = None):
        """
        :param Sequence[str] profiles: Skaffold profiles to use when rendering the manifest for this stage's `Target`.
        :param 'DeliveryPipelineSerialPipelineStageStrategyArgs' strategy: Optional. The strategy to use for a `Rollout` to this stage.
        :param str target_id: The target_id to which this stage points. This field refers exclusively to the last segment of a target name. For example, this field would just be `my-target` (rather than `projects/project/locations/location/targets/my-target`). The location of the `Target` is inferred to be the same as the location of the `DeliveryPipeline` that contains this `Stage`.
        """
        if profiles is not None:
            pulumi.set(__self__, "profiles", profiles)
        if strategy is not None:
            pulumi.set(__self__, "strategy", strategy)
        if target_id is not None:
            pulumi.set(__self__, "target_id", target_id)

    @property
    @pulumi.getter
    def profiles(self) -> Optional[Sequence[str]]:
        """
        Skaffold profiles to use when rendering the manifest for this stage's `Target`.
        """
        return pulumi.get(self, "profiles")

    @property
    @pulumi.getter
    def strategy(self) -> Optional['outputs.DeliveryPipelineSerialPipelineStageStrategy']:
        """
        Optional. The strategy to use for a `Rollout` to this stage.
        """
        return pulumi.get(self, "strategy")

    @property
    @pulumi.getter(name="targetId")
    def target_id(self) -> Optional[str]:
        """
        The target_id to which this stage points. This field refers exclusively to the last segment of a target name. For example, this field would just be `my-target` (rather than `projects/project/locations/location/targets/my-target`). The location of the `Target` is inferred to be the same as the location of the `DeliveryPipeline` that contains this `Stage`.
        """
        return pulumi.get(self, "target_id")


@pulumi.output_type
class DeliveryPipelineSerialPipelineStageStrategy(dict):
    def __init__(__self__, *,
                 canary: Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyCanary'] = None,
                 standard: Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyStandard'] = None):
        """
        :param 'DeliveryPipelineSerialPipelineStageStrategyCanaryArgs' canary: (Beta only) Canary deployment strategy provides progressive percentage based deployments to a Target.
        :param 'DeliveryPipelineSerialPipelineStageStrategyStandardArgs' standard: Standard deployment strategy executes a single deploy and allows verifying the deployment.
        """
        if canary is not None:
            pulumi.set(__self__, "canary", canary)
        if standard is not None:
            pulumi.set(__self__, "standard", standard)

    @property
    @pulumi.getter
    def canary(self) -> Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyCanary']:
        """
        (Beta only) Canary deployment strategy provides progressive percentage based deployments to a Target.
        """
        return pulumi.get(self, "canary")

    @property
    @pulumi.getter
    def standard(self) -> Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyStandard']:
        """
        Standard deployment strategy executes a single deploy and allows verifying the deployment.
        """
        return pulumi.get(self, "standard")


@pulumi.output_type
class DeliveryPipelineSerialPipelineStageStrategyCanary(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "canaryDeployment":
            suggest = "canary_deployment"
        elif key == "customCanaryDeployment":
            suggest = "custom_canary_deployment"
        elif key == "runtimeConfig":
            suggest = "runtime_config"

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

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

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

    def __init__(__self__, *,
                 canary_deployment: Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyCanaryCanaryDeployment'] = None,
                 custom_canary_deployment: Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyCanaryCustomCanaryDeployment'] = None,
                 runtime_config: Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfig'] = None):
        """
        :param 'DeliveryPipelineSerialPipelineStageStrategyCanaryCanaryDeploymentArgs' canary_deployment: Configures the progressive based deployment for a Target.
        :param 'DeliveryPipelineSerialPipelineStageStrategyCanaryCustomCanaryDeploymentArgs' custom_canary_deployment: Configures the progressive based deployment for a Target, but allows customizing at the phase level where a phase represents each of the percentage deployments.
        :param 'DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigArgs' runtime_config: Optional. Runtime specific configurations for the deployment strategy. The runtime configuration is used to determine how Cloud Deploy will split traffic to enable a progressive deployment.
        """
        if canary_deployment is not None:
            pulumi.set(__self__, "canary_deployment", canary_deployment)
        if custom_canary_deployment is not None:
            pulumi.set(__self__, "custom_canary_deployment", custom_canary_deployment)
        if runtime_config is not None:
            pulumi.set(__self__, "runtime_config", runtime_config)

    @property
    @pulumi.getter(name="canaryDeployment")
    def canary_deployment(self) -> Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyCanaryCanaryDeployment']:
        """
        Configures the progressive based deployment for a Target.
        """
        return pulumi.get(self, "canary_deployment")

    @property
    @pulumi.getter(name="customCanaryDeployment")
    def custom_canary_deployment(self) -> Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyCanaryCustomCanaryDeployment']:
        """
        Configures the progressive based deployment for a Target, but allows customizing at the phase level where a phase represents each of the percentage deployments.
        """
        return pulumi.get(self, "custom_canary_deployment")

    @property
    @pulumi.getter(name="runtimeConfig")
    def runtime_config(self) -> Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfig']:
        """
        Optional. Runtime specific configurations for the deployment strategy. The runtime configuration is used to determine how Cloud Deploy will split traffic to enable a progressive deployment.
        """
        return pulumi.get(self, "runtime_config")


@pulumi.output_type
class DeliveryPipelineSerialPipelineStageStrategyCanaryCanaryDeployment(dict):
    def __init__(__self__, *,
                 percentages: Sequence[int],
                 verify: Optional[bool] = None):
        """
        :param Sequence[int] percentages: Required. The percentage based deployments that will occur as a part of a `Rollout`. List is expected in ascending order and each integer n is 0 <= n < 100.
        :param bool verify: Whether to run verify tests after each percentage deployment.
        """
        pulumi.set(__self__, "percentages", percentages)
        if verify is not None:
            pulumi.set(__self__, "verify", verify)

    @property
    @pulumi.getter
    def percentages(self) -> Sequence[int]:
        """
        Required. The percentage based deployments that will occur as a part of a `Rollout`. List is expected in ascending order and each integer n is 0 <= n < 100.
        """
        return pulumi.get(self, "percentages")

    @property
    @pulumi.getter
    def verify(self) -> Optional[bool]:
        """
        Whether to run verify tests after each percentage deployment.
        """
        return pulumi.get(self, "verify")


@pulumi.output_type
class DeliveryPipelineSerialPipelineStageStrategyCanaryCustomCanaryDeployment(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "phaseConfigs":
            suggest = "phase_configs"

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

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

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

    def __init__(__self__, *,
                 phase_configs: Sequence['outputs.DeliveryPipelineSerialPipelineStageStrategyCanaryCustomCanaryDeploymentPhaseConfig']):
        """
        :param Sequence['DeliveryPipelineSerialPipelineStageStrategyCanaryCustomCanaryDeploymentPhaseConfigArgs'] phase_configs: Required. Configuration for each phase in the canary deployment in the order executed.
        """
        pulumi.set(__self__, "phase_configs", phase_configs)

    @property
    @pulumi.getter(name="phaseConfigs")
    def phase_configs(self) -> Sequence['outputs.DeliveryPipelineSerialPipelineStageStrategyCanaryCustomCanaryDeploymentPhaseConfig']:
        """
        Required. Configuration for each phase in the canary deployment in the order executed.
        """
        return pulumi.get(self, "phase_configs")


@pulumi.output_type
class DeliveryPipelineSerialPipelineStageStrategyCanaryCustomCanaryDeploymentPhaseConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "phaseId":
            suggest = "phase_id"

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

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

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

    def __init__(__self__, *,
                 percentage: int,
                 phase_id: str,
                 profiles: Optional[Sequence[str]] = None,
                 verify: Optional[bool] = None):
        """
        :param int percentage: Required. Percentage deployment for the phase.
        :param str phase_id: Required. The ID to assign to the `Rollout` phase. This value must consist of lower-case letters, numbers, and hyphens, start with a letter and end with a letter or a number, and have a max length of 63 characters. In other words, it must match the following regex: `^a-z?$`.
        :param Sequence[str] profiles: Skaffold profiles to use when rendering the manifest for this phase. These are in addition to the profiles list specified in the `DeliveryPipeline` stage.
        :param bool verify: Whether to run verify tests after the deployment.
               
               - - -
        """
        pulumi.set(__self__, "percentage", percentage)
        pulumi.set(__self__, "phase_id", phase_id)
        if profiles is not None:
            pulumi.set(__self__, "profiles", profiles)
        if verify is not None:
            pulumi.set(__self__, "verify", verify)

    @property
    @pulumi.getter
    def percentage(self) -> int:
        """
        Required. Percentage deployment for the phase.
        """
        return pulumi.get(self, "percentage")

    @property
    @pulumi.getter(name="phaseId")
    def phase_id(self) -> str:
        """
        Required. The ID to assign to the `Rollout` phase. This value must consist of lower-case letters, numbers, and hyphens, start with a letter and end with a letter or a number, and have a max length of 63 characters. In other words, it must match the following regex: `^a-z?$`.
        """
        return pulumi.get(self, "phase_id")

    @property
    @pulumi.getter
    def profiles(self) -> Optional[Sequence[str]]:
        """
        Skaffold profiles to use when rendering the manifest for this phase. These are in addition to the profiles list specified in the `DeliveryPipeline` stage.
        """
        return pulumi.get(self, "profiles")

    @property
    @pulumi.getter
    def verify(self) -> Optional[bool]:
        """
        Whether to run verify tests after the deployment.

        - - -
        """
        return pulumi.get(self, "verify")


@pulumi.output_type
class DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cloudRun":
            suggest = "cloud_run"

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

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

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

    def __init__(__self__, *,
                 cloud_run: Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigCloudRun'] = None,
                 kubernetes: Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetes'] = None):
        """
        :param 'DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigCloudRunArgs' cloud_run: Cloud Run runtime configuration.
        :param 'DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetesArgs' kubernetes: Kubernetes runtime configuration.
        """
        if cloud_run is not None:
            pulumi.set(__self__, "cloud_run", cloud_run)
        if kubernetes is not None:
            pulumi.set(__self__, "kubernetes", kubernetes)

    @property
    @pulumi.getter(name="cloudRun")
    def cloud_run(self) -> Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigCloudRun']:
        """
        Cloud Run runtime configuration.
        """
        return pulumi.get(self, "cloud_run")

    @property
    @pulumi.getter
    def kubernetes(self) -> Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetes']:
        """
        Kubernetes runtime configuration.
        """
        return pulumi.get(self, "kubernetes")


@pulumi.output_type
class DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigCloudRun(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "automaticTrafficControl":
            suggest = "automatic_traffic_control"

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

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

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

    def __init__(__self__, *,
                 automatic_traffic_control: Optional[bool] = None):
        """
        :param bool automatic_traffic_control: Whether Cloud Deploy should update the traffic stanza in a Cloud Run Service on the user's behalf to facilitate traffic splitting. This is required to be true for CanaryDeployments, but optional for CustomCanaryDeployments.
        """
        if automatic_traffic_control is not None:
            pulumi.set(__self__, "automatic_traffic_control", automatic_traffic_control)

    @property
    @pulumi.getter(name="automaticTrafficControl")
    def automatic_traffic_control(self) -> Optional[bool]:
        """
        Whether Cloud Deploy should update the traffic stanza in a Cloud Run Service on the user's behalf to facilitate traffic splitting. This is required to be true for CanaryDeployments, but optional for CustomCanaryDeployments.
        """
        return pulumi.get(self, "automatic_traffic_control")


@pulumi.output_type
class DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetes(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "gatewayServiceMesh":
            suggest = "gateway_service_mesh"
        elif key == "serviceNetworking":
            suggest = "service_networking"

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

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

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

    def __init__(__self__, *,
                 gateway_service_mesh: Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetesGatewayServiceMesh'] = None,
                 service_networking: Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetesServiceNetworking'] = None):
        """
        :param 'DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetesGatewayServiceMeshArgs' gateway_service_mesh: Kubernetes Gateway API service mesh configuration.
        :param 'DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetesServiceNetworkingArgs' service_networking: Kubernetes Service networking configuration.
        """
        if gateway_service_mesh is not None:
            pulumi.set(__self__, "gateway_service_mesh", gateway_service_mesh)
        if service_networking is not None:
            pulumi.set(__self__, "service_networking", service_networking)

    @property
    @pulumi.getter(name="gatewayServiceMesh")
    def gateway_service_mesh(self) -> Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetesGatewayServiceMesh']:
        """
        Kubernetes Gateway API service mesh configuration.
        """
        return pulumi.get(self, "gateway_service_mesh")

    @property
    @pulumi.getter(name="serviceNetworking")
    def service_networking(self) -> Optional['outputs.DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetesServiceNetworking']:
        """
        Kubernetes Service networking configuration.
        """
        return pulumi.get(self, "service_networking")


@pulumi.output_type
class DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetesGatewayServiceMesh(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "httpRoute":
            suggest = "http_route"

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

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

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

    def __init__(__self__, *,
                 deployment: str,
                 http_route: str,
                 service: str):
        """
        :param str deployment: Required. Name of the Kubernetes Deployment whose traffic is managed by the specified HTTPRoute and Service.
        :param str http_route: Required. Name of the Gateway API HTTPRoute.
        :param str service: Required. Name of the Kubernetes Service.
        """
        pulumi.set(__self__, "deployment", deployment)
        pulumi.set(__self__, "http_route", http_route)
        pulumi.set(__self__, "service", service)

    @property
    @pulumi.getter
    def deployment(self) -> str:
        """
        Required. Name of the Kubernetes Deployment whose traffic is managed by the specified HTTPRoute and Service.
        """
        return pulumi.get(self, "deployment")

    @property
    @pulumi.getter(name="httpRoute")
    def http_route(self) -> str:
        """
        Required. Name of the Gateway API HTTPRoute.
        """
        return pulumi.get(self, "http_route")

    @property
    @pulumi.getter
    def service(self) -> str:
        """
        Required. Name of the Kubernetes Service.
        """
        return pulumi.get(self, "service")


@pulumi.output_type
class DeliveryPipelineSerialPipelineStageStrategyCanaryRuntimeConfigKubernetesServiceNetworking(dict):
    def __init__(__self__, *,
                 deployment: str,
                 service: str):
        """
        :param str deployment: Required. Name of the Kubernetes Deployment whose traffic is managed by the specified Service.
        :param str service: Required. Name of the Kubernetes Service.
        """
        pulumi.set(__self__, "deployment", deployment)
        pulumi.set(__self__, "service", service)

    @property
    @pulumi.getter
    def deployment(self) -> str:
        """
        Required. Name of the Kubernetes Deployment whose traffic is managed by the specified Service.
        """
        return pulumi.get(self, "deployment")

    @property
    @pulumi.getter
    def service(self) -> str:
        """
        Required. Name of the Kubernetes Service.
        """
        return pulumi.get(self, "service")


@pulumi.output_type
class DeliveryPipelineSerialPipelineStageStrategyStandard(dict):
    def __init__(__self__, *,
                 verify: Optional[bool] = None):
        """
        :param bool verify: Whether to verify a deployment.
        """
        if verify is not None:
            pulumi.set(__self__, "verify", verify)

    @property
    @pulumi.getter
    def verify(self) -> Optional[bool]:
        """
        Whether to verify a deployment.
        """
        return pulumi.get(self, "verify")


@pulumi.output_type
class TargetAnthosCluster(dict):
    def __init__(__self__, *,
                 membership: Optional[str] = None):
        """
        :param str membership: Membership of the GKE Hub-registered cluster to which to apply the Skaffold configuration. Format is `projects/{project}/locations/{location}/memberships/{membership_name}`.
        """
        if membership is not None:
            pulumi.set(__self__, "membership", membership)

    @property
    @pulumi.getter
    def membership(self) -> Optional[str]:
        """
        Membership of the GKE Hub-registered cluster to which to apply the Skaffold configuration. Format is `projects/{project}/locations/{location}/memberships/{membership_name}`.
        """
        return pulumi.get(self, "membership")


@pulumi.output_type
class TargetExecutionConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "artifactStorage":
            suggest = "artifact_storage"
        elif key == "executionTimeout":
            suggest = "execution_timeout"
        elif key == "serviceAccount":
            suggest = "service_account"
        elif key == "workerPool":
            suggest = "worker_pool"

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

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

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

    def __init__(__self__, *,
                 usages: Sequence[str],
                 artifact_storage: Optional[str] = None,
                 execution_timeout: Optional[str] = None,
                 service_account: Optional[str] = None,
                 worker_pool: Optional[str] = None):
        """
        :param Sequence[str] usages: Required. Usages when this configuration should be applied.
        :param str artifact_storage: Optional. Cloud Storage location in which to store execution outputs. This can either be a bucket ("gs://my-bucket") or a path within a bucket ("gs://my-bucket/my-dir"). If unspecified, a default bucket located in the same region will be used.
        :param str execution_timeout: Optional. Execution timeout for a Cloud Build Execution. This must be between 10m and 24h in seconds format. If unspecified, a default timeout of 1h is used.
        :param str service_account: Optional. Google service account to use for execution. If unspecified, the project execution service account (-compute@developer.gserviceaccount.com) is used.
        :param str worker_pool: Optional. The resource name of the `WorkerPool`, with the format `projects/{project}/locations/{location}/workerPools/{worker_pool}`. If this optional field is unspecified, the default Cloud Build pool will be used.
        """
        pulumi.set(__self__, "usages", usages)
        if artifact_storage is not None:
            pulumi.set(__self__, "artifact_storage", artifact_storage)
        if execution_timeout is not None:
            pulumi.set(__self__, "execution_timeout", execution_timeout)
        if service_account is not None:
            pulumi.set(__self__, "service_account", service_account)
        if worker_pool is not None:
            pulumi.set(__self__, "worker_pool", worker_pool)

    @property
    @pulumi.getter
    def usages(self) -> Sequence[str]:
        """
        Required. Usages when this configuration should be applied.
        """
        return pulumi.get(self, "usages")

    @property
    @pulumi.getter(name="artifactStorage")
    def artifact_storage(self) -> Optional[str]:
        """
        Optional. Cloud Storage location in which to store execution outputs. This can either be a bucket ("gs://my-bucket") or a path within a bucket ("gs://my-bucket/my-dir"). If unspecified, a default bucket located in the same region will be used.
        """
        return pulumi.get(self, "artifact_storage")

    @property
    @pulumi.getter(name="executionTimeout")
    def execution_timeout(self) -> Optional[str]:
        """
        Optional. Execution timeout for a Cloud Build Execution. This must be between 10m and 24h in seconds format. If unspecified, a default timeout of 1h is used.
        """
        return pulumi.get(self, "execution_timeout")

    @property
    @pulumi.getter(name="serviceAccount")
    def service_account(self) -> Optional[str]:
        """
        Optional. Google service account to use for execution. If unspecified, the project execution service account (-compute@developer.gserviceaccount.com) is used.
        """
        return pulumi.get(self, "service_account")

    @property
    @pulumi.getter(name="workerPool")
    def worker_pool(self) -> Optional[str]:
        """
        Optional. The resource name of the `WorkerPool`, with the format `projects/{project}/locations/{location}/workerPools/{worker_pool}`. If this optional field is unspecified, the default Cloud Build pool will be used.
        """
        return pulumi.get(self, "worker_pool")


@pulumi.output_type
class TargetGke(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "internalIp":
            suggest = "internal_ip"

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

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

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

    def __init__(__self__, *,
                 cluster: Optional[str] = None,
                 internal_ip: Optional[bool] = None):
        """
        :param str cluster: Information specifying a GKE Cluster. Format is `projects/{project_id}/locations/{location_id}/clusters/{cluster_id}.
        :param bool internal_ip: Optional. If true, `cluster` is accessed using the private IP address of the control plane endpoint. Otherwise, the default IP address of the control plane endpoint is used. The default IP address is the private IP address for clusters with private control-plane endpoints and the public IP address otherwise. Only specify this option when `cluster` is a [private GKE cluster](https://cloud.google.com/kubernetes-engine/docs/concepts/private-cluster-concept).
        """
        if cluster is not None:
            pulumi.set(__self__, "cluster", cluster)
        if internal_ip is not None:
            pulumi.set(__self__, "internal_ip", internal_ip)

    @property
    @pulumi.getter
    def cluster(self) -> Optional[str]:
        """
        Information specifying a GKE Cluster. Format is `projects/{project_id}/locations/{location_id}/clusters/{cluster_id}.
        """
        return pulumi.get(self, "cluster")

    @property
    @pulumi.getter(name="internalIp")
    def internal_ip(self) -> Optional[bool]:
        """
        Optional. If true, `cluster` is accessed using the private IP address of the control plane endpoint. Otherwise, the default IP address of the control plane endpoint is used. The default IP address is the private IP address for clusters with private control-plane endpoints and the public IP address otherwise. Only specify this option when `cluster` is a [private GKE cluster](https://cloud.google.com/kubernetes-engine/docs/concepts/private-cluster-concept).
        """
        return pulumi.get(self, "internal_ip")


@pulumi.output_type
class TargetMultiTarget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "targetIds":
            suggest = "target_ids"

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

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

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

    def __init__(__self__, *,
                 target_ids: Sequence[str]):
        """
        :param Sequence[str] target_ids: Required. The target_ids of this multiTarget.
        """
        pulumi.set(__self__, "target_ids", target_ids)

    @property
    @pulumi.getter(name="targetIds")
    def target_ids(self) -> Sequence[str]:
        """
        Required. The target_ids of this multiTarget.
        """
        return pulumi.get(self, "target_ids")


@pulumi.output_type
class TargetRun(dict):
    def __init__(__self__, *,
                 location: str):
        """
        :param str location: Required. The location where the Cloud Run Service should be located. Format is `projects/{project}/locations/{location}`.
        """
        pulumi.set(__self__, "location", location)

    @property
    @pulumi.getter
    def location(self) -> str:
        """
        Required. The location where the Cloud Run Service should be located. Format is `projects/{project}/locations/{location}`.
        """
        return pulumi.get(self, "location")


