# 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 builtins
import copy
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from .. import _utilities

__all__ = [
    'RolloutSpecFailurePolicyArgs',
    'RolloutSpecFailurePolicyArgsDict',
    'RolloutSpecSpotDeploymentArgs',
    'RolloutSpecSpotDeploymentArgsDict',
    'RolloutSpecStrategyArgs',
    'RolloutSpecStrategyArgsDict',
    'RolloutSpecStrategyArgArgs',
    'RolloutSpecStrategyArgArgsDict',
    'RolloutSpecStrategyArgValueFromArgs',
    'RolloutSpecStrategyArgValueFromArgsDict',
    'RolloutSpecStrategyArgValueFromFieldRefArgs',
    'RolloutSpecStrategyArgValueFromFieldRefArgsDict',
    'RolloutSpecTrafficArgs',
    'RolloutSpecTrafficArgsDict',
    'RolloutSpecTrafficAlbArgs',
    'RolloutSpecTrafficAlbArgsDict',
    'RolloutSpecTrafficAlbStickinessConfigArgs',
    'RolloutSpecTrafficAlbStickinessConfigArgsDict',
    'RolloutSpecTrafficAmbassadorArgs',
    'RolloutSpecTrafficAmbassadorArgsDict',
    'RolloutSpecTrafficIstioArgs',
    'RolloutSpecTrafficIstioArgsDict',
    'RolloutSpecTrafficIstioDestinationRuleArgs',
    'RolloutSpecTrafficIstioDestinationRuleArgsDict',
    'RolloutSpecTrafficIstioVirtualServiceArgs',
    'RolloutSpecTrafficIstioVirtualServiceArgsDict',
    'RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs',
    'RolloutSpecTrafficIstioVirtualServiceTlsRouteArgsDict',
    'RolloutSpecTrafficNginxArgs',
    'RolloutSpecTrafficNginxArgsDict',
    'RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs',
    'RolloutSpecTrafficNginxAdditionalIngressAnnotationArgsDict',
    'RolloutSpecTrafficPingPongArgs',
    'RolloutSpecTrafficPingPongArgsDict',
    'RolloutSpecTrafficSmiArgs',
    'RolloutSpecTrafficSmiArgsDict',
    'StrategyCanaryArgs',
    'StrategyCanaryArgsDict',
    'StrategyCanaryBackgroundVerificationArgs',
    'StrategyCanaryBackgroundVerificationArgsDict',
    'StrategyCanaryStepArgs',
    'StrategyCanaryStepArgsDict',
    'StrategyCanaryStepPauseArgs',
    'StrategyCanaryStepPauseArgsDict',
    'StrategyCanaryStepSetCanaryScaleArgs',
    'StrategyCanaryStepSetCanaryScaleArgsDict',
    'StrategyCanaryStepSetHeaderRouteArgs',
    'StrategyCanaryStepSetHeaderRouteArgsDict',
    'StrategyCanaryStepSetHeaderRouteMatchArgs',
    'StrategyCanaryStepSetHeaderRouteMatchArgsDict',
    'StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs',
    'StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgsDict',
    'StrategyCanaryStepVerificationArgs',
    'StrategyCanaryStepVerificationArgsDict',
    'StrategyRollingArgs',
    'StrategyRollingArgsDict',
    'StrategyRollingStepArgs',
    'StrategyRollingStepArgsDict',
    'StrategyRollingStepPauseArgs',
    'StrategyRollingStepPauseArgsDict',
    'StrategyRollingStepVerificationArgs',
    'StrategyRollingStepVerificationArgsDict',
    'VerificationProviderCloudWatchArgs',
    'VerificationProviderCloudWatchArgsDict',
    'VerificationProviderDatadogArgs',
    'VerificationProviderDatadogArgsDict',
    'VerificationProviderJenkinsArgs',
    'VerificationProviderJenkinsArgsDict',
    'VerificationProviderNewRelicArgs',
    'VerificationProviderNewRelicArgsDict',
    'VerificationProviderPrometheusArgs',
    'VerificationProviderPrometheusArgsDict',
    'VerificationTemplateArgArgs',
    'VerificationTemplateArgArgsDict',
    'VerificationTemplateArgValueFromArgs',
    'VerificationTemplateArgValueFromArgsDict',
    'VerificationTemplateArgValueFromSecretKeyRefArgs',
    'VerificationTemplateArgValueFromSecretKeyRefArgsDict',
    'VerificationTemplateMetricArgs',
    'VerificationTemplateMetricArgsDict',
    'VerificationTemplateMetricBaselineArgs',
    'VerificationTemplateMetricBaselineArgsDict',
    'VerificationTemplateMetricBaselineBaselineProviderArgs',
    'VerificationTemplateMetricBaselineBaselineProviderArgsDict',
    'VerificationTemplateMetricBaselineBaselineProviderDatadogArgs',
    'VerificationTemplateMetricBaselineBaselineProviderDatadogArgsDict',
    'VerificationTemplateMetricBaselineBaselineProviderNewRelicArgs',
    'VerificationTemplateMetricBaselineBaselineProviderNewRelicArgsDict',
    'VerificationTemplateMetricBaselineBaselineProviderPrometheusArgs',
    'VerificationTemplateMetricBaselineBaselineProviderPrometheusArgsDict',
    'VerificationTemplateMetricProviderArgs',
    'VerificationTemplateMetricProviderArgsDict',
    'VerificationTemplateMetricProviderCloudWatchArgs',
    'VerificationTemplateMetricProviderCloudWatchArgsDict',
    'VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs',
    'VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgsDict',
    'VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs',
    'VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgsDict',
    'VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs',
    'VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgsDict',
    'VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs',
    'VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgsDict',
    'VerificationTemplateMetricProviderDatadogArgs',
    'VerificationTemplateMetricProviderDatadogArgsDict',
    'VerificationTemplateMetricProviderJenkinsArgs',
    'VerificationTemplateMetricProviderJenkinsArgsDict',
    'VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs',
    'VerificationTemplateMetricProviderJenkinsJenkinsParametersArgsDict',
    'VerificationTemplateMetricProviderJobArgs',
    'VerificationTemplateMetricProviderJobArgsDict',
    'VerificationTemplateMetricProviderJobSpecArgs',
    'VerificationTemplateMetricProviderJobSpecArgsDict',
    'VerificationTemplateMetricProviderJobSpecJobTemplateArgs',
    'VerificationTemplateMetricProviderJobSpecJobTemplateArgsDict',
    'VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgs',
    'VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgsDict',
    'VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs',
    'VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgsDict',
    'VerificationTemplateMetricProviderNewRelicArgs',
    'VerificationTemplateMetricProviderNewRelicArgsDict',
    'VerificationTemplateMetricProviderPrometheusArgs',
    'VerificationTemplateMetricProviderPrometheusArgsDict',
    'VerificationTemplateMetricProviderWebArgs',
    'VerificationTemplateMetricProviderWebArgsDict',
    'VerificationTemplateMetricProviderWebWebHeaderArgs',
    'VerificationTemplateMetricProviderWebWebHeaderArgsDict',
]

MYPY = False

if not MYPY:
    class RolloutSpecFailurePolicyArgsDict(TypedDict):
        action: pulumi.Input[builtins.str]
        """
        Choose an action to perform on failure. Default is `abort`.  Enum: "abort" "pause" "promote".
        """
elif False:
    RolloutSpecFailurePolicyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecFailurePolicyArgs:
    def __init__(__self__, *,
                 action: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] action: Choose an action to perform on failure. Default is `abort`.  Enum: "abort" "pause" "promote".
        """
        pulumi.set(__self__, "action", action)

    @property
    @pulumi.getter
    def action(self) -> pulumi.Input[builtins.str]:
        """
        Choose an action to perform on failure. Default is `abort`.  Enum: "abort" "pause" "promote".
        """
        return pulumi.get(self, "action")

    @action.setter
    def action(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "action", value)


if not MYPY:
    class RolloutSpecSpotDeploymentArgsDict(TypedDict):
        spot_deployments_cluster_id: NotRequired[pulumi.Input[builtins.str]]
        """
        Ocean CD cluster identifier for the references `SpotDeployment`.
        """
        spot_deployments_name: NotRequired[pulumi.Input[builtins.str]]
        """
        The name of the `SpotDeployment` resource
        """
        spot_deployments_namespace: NotRequired[pulumi.Input[builtins.str]]
        """
        The namespace which the `SpotDeployment` resource exists within.
        """
elif False:
    RolloutSpecSpotDeploymentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecSpotDeploymentArgs:
    def __init__(__self__, *,
                 spot_deployments_cluster_id: Optional[pulumi.Input[builtins.str]] = None,
                 spot_deployments_name: Optional[pulumi.Input[builtins.str]] = None,
                 spot_deployments_namespace: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] spot_deployments_cluster_id: Ocean CD cluster identifier for the references `SpotDeployment`.
        :param pulumi.Input[builtins.str] spot_deployments_name: The name of the `SpotDeployment` resource
        :param pulumi.Input[builtins.str] spot_deployments_namespace: The namespace which the `SpotDeployment` resource exists within.
        """
        if spot_deployments_cluster_id is not None:
            pulumi.set(__self__, "spot_deployments_cluster_id", spot_deployments_cluster_id)
        if spot_deployments_name is not None:
            pulumi.set(__self__, "spot_deployments_name", spot_deployments_name)
        if spot_deployments_namespace is not None:
            pulumi.set(__self__, "spot_deployments_namespace", spot_deployments_namespace)

    @property
    @pulumi.getter(name="spotDeploymentsClusterId")
    def spot_deployments_cluster_id(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Ocean CD cluster identifier for the references `SpotDeployment`.
        """
        return pulumi.get(self, "spot_deployments_cluster_id")

    @spot_deployments_cluster_id.setter
    def spot_deployments_cluster_id(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "spot_deployments_cluster_id", value)

    @property
    @pulumi.getter(name="spotDeploymentsName")
    def spot_deployments_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The name of the `SpotDeployment` resource
        """
        return pulumi.get(self, "spot_deployments_name")

    @spot_deployments_name.setter
    def spot_deployments_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "spot_deployments_name", value)

    @property
    @pulumi.getter(name="spotDeploymentsNamespace")
    def spot_deployments_namespace(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The namespace which the `SpotDeployment` resource exists within.
        """
        return pulumi.get(self, "spot_deployments_namespace")

    @spot_deployments_namespace.setter
    def spot_deployments_namespace(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "spot_deployments_namespace", value)


if not MYPY:
    class RolloutSpecStrategyArgsDict(TypedDict):
        strategy_name: pulumi.Input[builtins.str]
        """
        Ocean CD strategy name identifier.
        """
        args: NotRequired[pulumi.Input[Sequence[pulumi.Input['RolloutSpecStrategyArgArgsDict']]]]
        """
        Arguments defined in Verification Templates.
        """
elif False:
    RolloutSpecStrategyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecStrategyArgs:
    def __init__(__self__, *,
                 strategy_name: pulumi.Input[builtins.str],
                 args: Optional[pulumi.Input[Sequence[pulumi.Input['RolloutSpecStrategyArgArgs']]]] = None):
        """
        :param pulumi.Input[builtins.str] strategy_name: Ocean CD strategy name identifier.
        :param pulumi.Input[Sequence[pulumi.Input['RolloutSpecStrategyArgArgs']]] args: Arguments defined in Verification Templates.
        """
        pulumi.set(__self__, "strategy_name", strategy_name)
        if args is not None:
            pulumi.set(__self__, "args", args)

    @property
    @pulumi.getter(name="strategyName")
    def strategy_name(self) -> pulumi.Input[builtins.str]:
        """
        Ocean CD strategy name identifier.
        """
        return pulumi.get(self, "strategy_name")

    @strategy_name.setter
    def strategy_name(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "strategy_name", value)

    @property
    @pulumi.getter
    def args(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RolloutSpecStrategyArgArgs']]]]:
        """
        Arguments defined in Verification Templates.
        """
        return pulumi.get(self, "args")

    @args.setter
    def args(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RolloutSpecStrategyArgArgs']]]]):
        pulumi.set(self, "args", value)


if not MYPY:
    class RolloutSpecStrategyArgArgsDict(TypedDict):
        arg_name: pulumi.Input[builtins.str]
        """
        Name of an argument.
        """
        arg_value: NotRequired[pulumi.Input[builtins.str]]
        """
        Value of an argument.
        """
        value_from: NotRequired[pulumi.Input['RolloutSpecStrategyArgValueFromArgsDict']]
        """
        Defines from where to get the value of an argument.
        """
elif False:
    RolloutSpecStrategyArgArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecStrategyArgArgs:
    def __init__(__self__, *,
                 arg_name: pulumi.Input[builtins.str],
                 arg_value: Optional[pulumi.Input[builtins.str]] = None,
                 value_from: Optional[pulumi.Input['RolloutSpecStrategyArgValueFromArgs']] = None):
        """
        :param pulumi.Input[builtins.str] arg_name: Name of an argument.
        :param pulumi.Input[builtins.str] arg_value: Value of an argument.
        :param pulumi.Input['RolloutSpecStrategyArgValueFromArgs'] value_from: Defines from where to get the value of an argument.
        """
        pulumi.set(__self__, "arg_name", arg_name)
        if arg_value is not None:
            pulumi.set(__self__, "arg_value", arg_value)
        if value_from is not None:
            pulumi.set(__self__, "value_from", value_from)

    @property
    @pulumi.getter(name="argName")
    def arg_name(self) -> pulumi.Input[builtins.str]:
        """
        Name of an argument.
        """
        return pulumi.get(self, "arg_name")

    @arg_name.setter
    def arg_name(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "arg_name", value)

    @property
    @pulumi.getter(name="argValue")
    def arg_value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Value of an argument.
        """
        return pulumi.get(self, "arg_value")

    @arg_value.setter
    def arg_value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "arg_value", value)

    @property
    @pulumi.getter(name="valueFrom")
    def value_from(self) -> Optional[pulumi.Input['RolloutSpecStrategyArgValueFromArgs']]:
        """
        Defines from where to get the value of an argument.
        """
        return pulumi.get(self, "value_from")

    @value_from.setter
    def value_from(self, value: Optional[pulumi.Input['RolloutSpecStrategyArgValueFromArgs']]):
        pulumi.set(self, "value_from", value)


if not MYPY:
    class RolloutSpecStrategyArgValueFromArgsDict(TypedDict):
        field_ref: pulumi.Input['RolloutSpecStrategyArgValueFromFieldRefArgsDict']
        """
        Defines the field path from where to get the value of an argument.
        """
elif False:
    RolloutSpecStrategyArgValueFromArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecStrategyArgValueFromArgs:
    def __init__(__self__, *,
                 field_ref: pulumi.Input['RolloutSpecStrategyArgValueFromFieldRefArgs']):
        """
        :param pulumi.Input['RolloutSpecStrategyArgValueFromFieldRefArgs'] field_ref: Defines the field path from where to get the value of an argument.
        """
        pulumi.set(__self__, "field_ref", field_ref)

    @property
    @pulumi.getter(name="fieldRef")
    def field_ref(self) -> pulumi.Input['RolloutSpecStrategyArgValueFromFieldRefArgs']:
        """
        Defines the field path from where to get the value of an argument.
        """
        return pulumi.get(self, "field_ref")

    @field_ref.setter
    def field_ref(self, value: pulumi.Input['RolloutSpecStrategyArgValueFromFieldRefArgs']):
        pulumi.set(self, "field_ref", value)


if not MYPY:
    class RolloutSpecStrategyArgValueFromFieldRefArgsDict(TypedDict):
        field_path: pulumi.Input[builtins.str]
        """
        Path to SpotDeployment's field from where to get the value of an argument.
        """
elif False:
    RolloutSpecStrategyArgValueFromFieldRefArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecStrategyArgValueFromFieldRefArgs:
    def __init__(__self__, *,
                 field_path: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] field_path: Path to SpotDeployment's field from where to get the value of an argument.
        """
        pulumi.set(__self__, "field_path", field_path)

    @property
    @pulumi.getter(name="fieldPath")
    def field_path(self) -> pulumi.Input[builtins.str]:
        """
        Path to SpotDeployment's field from where to get the value of an argument.
        """
        return pulumi.get(self, "field_path")

    @field_path.setter
    def field_path(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "field_path", value)


if not MYPY:
    class RolloutSpecTrafficArgsDict(TypedDict):
        alb: NotRequired[pulumi.Input['RolloutSpecTrafficAlbArgsDict']]
        """
        Holds ALB Ingress specific configuration to route traffic.
        """
        ambassador: NotRequired[pulumi.Input['RolloutSpecTrafficAmbassadorArgsDict']]
        """
        Holds specific configuration to use Ambassador to route traffic.
        """
        canary_service: NotRequired[pulumi.Input[builtins.str]]
        """
        The canary service name.
        """
        istio: NotRequired[pulumi.Input['RolloutSpecTrafficIstioArgsDict']]
        """
        Holds Istio specific configuration to route traffic.
        """
        nginx: NotRequired[pulumi.Input['RolloutSpecTrafficNginxArgsDict']]
        """
        Holds Nginx Ingress specific configuration to route traffic.
        """
        ping_pong: NotRequired[pulumi.Input['RolloutSpecTrafficPingPongArgsDict']]
        """
        Holds the ping and pong services. You can use `pingPong` field only when using ALB as a traffic manager with the IP Mode approach.
        """
        smi: NotRequired[pulumi.Input['RolloutSpecTrafficSmiArgsDict']]
        """
        Holds TrafficSplit specific configuration to route traffic.
        """
        stable_service: NotRequired[pulumi.Input[builtins.str]]
        """
        The stable service name.
        """
elif False:
    RolloutSpecTrafficArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecTrafficArgs:
    def __init__(__self__, *,
                 alb: Optional[pulumi.Input['RolloutSpecTrafficAlbArgs']] = None,
                 ambassador: Optional[pulumi.Input['RolloutSpecTrafficAmbassadorArgs']] = None,
                 canary_service: Optional[pulumi.Input[builtins.str]] = None,
                 istio: Optional[pulumi.Input['RolloutSpecTrafficIstioArgs']] = None,
                 nginx: Optional[pulumi.Input['RolloutSpecTrafficNginxArgs']] = None,
                 ping_pong: Optional[pulumi.Input['RolloutSpecTrafficPingPongArgs']] = None,
                 smi: Optional[pulumi.Input['RolloutSpecTrafficSmiArgs']] = None,
                 stable_service: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input['RolloutSpecTrafficAlbArgs'] alb: Holds ALB Ingress specific configuration to route traffic.
        :param pulumi.Input['RolloutSpecTrafficAmbassadorArgs'] ambassador: Holds specific configuration to use Ambassador to route traffic.
        :param pulumi.Input[builtins.str] canary_service: The canary service name.
        :param pulumi.Input['RolloutSpecTrafficIstioArgs'] istio: Holds Istio specific configuration to route traffic.
        :param pulumi.Input['RolloutSpecTrafficNginxArgs'] nginx: Holds Nginx Ingress specific configuration to route traffic.
        :param pulumi.Input['RolloutSpecTrafficPingPongArgs'] ping_pong: Holds the ping and pong services. You can use `pingPong` field only when using ALB as a traffic manager with the IP Mode approach.
        :param pulumi.Input['RolloutSpecTrafficSmiArgs'] smi: Holds TrafficSplit specific configuration to route traffic.
        :param pulumi.Input[builtins.str] stable_service: The stable service name.
        """
        if alb is not None:
            pulumi.set(__self__, "alb", alb)
        if ambassador is not None:
            pulumi.set(__self__, "ambassador", ambassador)
        if canary_service is not None:
            pulumi.set(__self__, "canary_service", canary_service)
        if istio is not None:
            pulumi.set(__self__, "istio", istio)
        if nginx is not None:
            pulumi.set(__self__, "nginx", nginx)
        if ping_pong is not None:
            pulumi.set(__self__, "ping_pong", ping_pong)
        if smi is not None:
            pulumi.set(__self__, "smi", smi)
        if stable_service is not None:
            pulumi.set(__self__, "stable_service", stable_service)

    @property
    @pulumi.getter
    def alb(self) -> Optional[pulumi.Input['RolloutSpecTrafficAlbArgs']]:
        """
        Holds ALB Ingress specific configuration to route traffic.
        """
        return pulumi.get(self, "alb")

    @alb.setter
    def alb(self, value: Optional[pulumi.Input['RolloutSpecTrafficAlbArgs']]):
        pulumi.set(self, "alb", value)

    @property
    @pulumi.getter
    def ambassador(self) -> Optional[pulumi.Input['RolloutSpecTrafficAmbassadorArgs']]:
        """
        Holds specific configuration to use Ambassador to route traffic.
        """
        return pulumi.get(self, "ambassador")

    @ambassador.setter
    def ambassador(self, value: Optional[pulumi.Input['RolloutSpecTrafficAmbassadorArgs']]):
        pulumi.set(self, "ambassador", value)

    @property
    @pulumi.getter(name="canaryService")
    def canary_service(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The canary service name.
        """
        return pulumi.get(self, "canary_service")

    @canary_service.setter
    def canary_service(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "canary_service", value)

    @property
    @pulumi.getter
    def istio(self) -> Optional[pulumi.Input['RolloutSpecTrafficIstioArgs']]:
        """
        Holds Istio specific configuration to route traffic.
        """
        return pulumi.get(self, "istio")

    @istio.setter
    def istio(self, value: Optional[pulumi.Input['RolloutSpecTrafficIstioArgs']]):
        pulumi.set(self, "istio", value)

    @property
    @pulumi.getter
    def nginx(self) -> Optional[pulumi.Input['RolloutSpecTrafficNginxArgs']]:
        """
        Holds Nginx Ingress specific configuration to route traffic.
        """
        return pulumi.get(self, "nginx")

    @nginx.setter
    def nginx(self, value: Optional[pulumi.Input['RolloutSpecTrafficNginxArgs']]):
        pulumi.set(self, "nginx", value)

    @property
    @pulumi.getter(name="pingPong")
    def ping_pong(self) -> Optional[pulumi.Input['RolloutSpecTrafficPingPongArgs']]:
        """
        Holds the ping and pong services. You can use `pingPong` field only when using ALB as a traffic manager with the IP Mode approach.
        """
        return pulumi.get(self, "ping_pong")

    @ping_pong.setter
    def ping_pong(self, value: Optional[pulumi.Input['RolloutSpecTrafficPingPongArgs']]):
        pulumi.set(self, "ping_pong", value)

    @property
    @pulumi.getter
    def smi(self) -> Optional[pulumi.Input['RolloutSpecTrafficSmiArgs']]:
        """
        Holds TrafficSplit specific configuration to route traffic.
        """
        return pulumi.get(self, "smi")

    @smi.setter
    def smi(self, value: Optional[pulumi.Input['RolloutSpecTrafficSmiArgs']]):
        pulumi.set(self, "smi", value)

    @property
    @pulumi.getter(name="stableService")
    def stable_service(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The stable service name.
        """
        return pulumi.get(self, "stable_service")

    @stable_service.setter
    def stable_service(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "stable_service", value)


if not MYPY:
    class RolloutSpecTrafficAlbArgsDict(TypedDict):
        alb_ingress: pulumi.Input[builtins.str]
        """
        Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
        """
        alb_root_service: pulumi.Input[builtins.str]
        """
        References the service in the ingress to the controller should add the action to.
        """
        service_port: pulumi.Input[builtins.int]
        """
        Refers to the port that the Ingress action should route traffic to.
        """
        alb_annotation_prefix: NotRequired[pulumi.Input[builtins.str]]
        """
        Has to match the configured annotation prefix on the alb ingress controller.
        """
        stickiness_config: NotRequired[pulumi.Input['RolloutSpecTrafficAlbStickinessConfigArgsDict']]
        """
        Allows to specify further settings on the ForwardConfig.
        """
elif False:
    RolloutSpecTrafficAlbArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecTrafficAlbArgs:
    def __init__(__self__, *,
                 alb_ingress: pulumi.Input[builtins.str],
                 alb_root_service: pulumi.Input[builtins.str],
                 service_port: pulumi.Input[builtins.int],
                 alb_annotation_prefix: Optional[pulumi.Input[builtins.str]] = None,
                 stickiness_config: Optional[pulumi.Input['RolloutSpecTrafficAlbStickinessConfigArgs']] = None):
        """
        :param pulumi.Input[builtins.str] alb_ingress: Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
        :param pulumi.Input[builtins.str] alb_root_service: References the service in the ingress to the controller should add the action to.
        :param pulumi.Input[builtins.int] service_port: Refers to the port that the Ingress action should route traffic to.
        :param pulumi.Input[builtins.str] alb_annotation_prefix: Has to match the configured annotation prefix on the alb ingress controller.
        :param pulumi.Input['RolloutSpecTrafficAlbStickinessConfigArgs'] stickiness_config: Allows to specify further settings on the ForwardConfig.
        """
        pulumi.set(__self__, "alb_ingress", alb_ingress)
        pulumi.set(__self__, "alb_root_service", alb_root_service)
        pulumi.set(__self__, "service_port", service_port)
        if alb_annotation_prefix is not None:
            pulumi.set(__self__, "alb_annotation_prefix", alb_annotation_prefix)
        if stickiness_config is not None:
            pulumi.set(__self__, "stickiness_config", stickiness_config)

    @property
    @pulumi.getter(name="albIngress")
    def alb_ingress(self) -> pulumi.Input[builtins.str]:
        """
        Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
        """
        return pulumi.get(self, "alb_ingress")

    @alb_ingress.setter
    def alb_ingress(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "alb_ingress", value)

    @property
    @pulumi.getter(name="albRootService")
    def alb_root_service(self) -> pulumi.Input[builtins.str]:
        """
        References the service in the ingress to the controller should add the action to.
        """
        return pulumi.get(self, "alb_root_service")

    @alb_root_service.setter
    def alb_root_service(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "alb_root_service", value)

    @property
    @pulumi.getter(name="servicePort")
    def service_port(self) -> pulumi.Input[builtins.int]:
        """
        Refers to the port that the Ingress action should route traffic to.
        """
        return pulumi.get(self, "service_port")

    @service_port.setter
    def service_port(self, value: pulumi.Input[builtins.int]):
        pulumi.set(self, "service_port", value)

    @property
    @pulumi.getter(name="albAnnotationPrefix")
    def alb_annotation_prefix(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Has to match the configured annotation prefix on the alb ingress controller.
        """
        return pulumi.get(self, "alb_annotation_prefix")

    @alb_annotation_prefix.setter
    def alb_annotation_prefix(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "alb_annotation_prefix", value)

    @property
    @pulumi.getter(name="stickinessConfig")
    def stickiness_config(self) -> Optional[pulumi.Input['RolloutSpecTrafficAlbStickinessConfigArgs']]:
        """
        Allows to specify further settings on the ForwardConfig.
        """
        return pulumi.get(self, "stickiness_config")

    @stickiness_config.setter
    def stickiness_config(self, value: Optional[pulumi.Input['RolloutSpecTrafficAlbStickinessConfigArgs']]):
        pulumi.set(self, "stickiness_config", value)


if not MYPY:
    class RolloutSpecTrafficAlbStickinessConfigArgsDict(TypedDict):
        duration_seconds: NotRequired[pulumi.Input[builtins.int]]
        """
        Defines how long the load balancer should consistently route the user's request to the same target.
        """
        enabled: NotRequired[pulumi.Input[builtins.bool]]
        """
        Enables the load balancer to bind a user's session to a specific target.
        """
elif False:
    RolloutSpecTrafficAlbStickinessConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecTrafficAlbStickinessConfigArgs:
    def __init__(__self__, *,
                 duration_seconds: Optional[pulumi.Input[builtins.int]] = None,
                 enabled: Optional[pulumi.Input[builtins.bool]] = None):
        """
        :param pulumi.Input[builtins.int] duration_seconds: Defines how long the load balancer should consistently route the user's request to the same target.
        :param pulumi.Input[builtins.bool] enabled: Enables the load balancer to bind a user's session to a specific target.
        """
        if duration_seconds is not None:
            pulumi.set(__self__, "duration_seconds", duration_seconds)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @property
    @pulumi.getter(name="durationSeconds")
    def duration_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Defines how long the load balancer should consistently route the user's request to the same target.
        """
        return pulumi.get(self, "duration_seconds")

    @duration_seconds.setter
    def duration_seconds(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "duration_seconds", value)

    @property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Enables the load balancer to bind a user's session to a specific target.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "enabled", value)


if not MYPY:
    class RolloutSpecTrafficAmbassadorArgsDict(TypedDict):
        mappings: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
        """
        A list of names of the Ambassador Mappings used to route traffic to the service.
        """
elif False:
    RolloutSpecTrafficAmbassadorArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecTrafficAmbassadorArgs:
    def __init__(__self__, *,
                 mappings: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] mappings: A list of names of the Ambassador Mappings used to route traffic to the service.
        """
        pulumi.set(__self__, "mappings", mappings)

    @property
    @pulumi.getter
    def mappings(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
        """
        A list of names of the Ambassador Mappings used to route traffic to the service.
        """
        return pulumi.get(self, "mappings")

    @mappings.setter
    def mappings(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
        pulumi.set(self, "mappings", value)


if not MYPY:
    class RolloutSpecTrafficIstioArgsDict(TypedDict):
        virtual_services: pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceArgsDict']]]
        """
        Defines a set of traffic routing rules to apply when a host is addressed.
        """
        destination_rule: NotRequired[pulumi.Input['RolloutSpecTrafficIstioDestinationRuleArgsDict']]
        """
        It references to an Istio DestinationRule to modify and shape traffic. `DestinationRule` field belongs only to the Subset Level approach.
        """
elif False:
    RolloutSpecTrafficIstioArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecTrafficIstioArgs:
    def __init__(__self__, *,
                 virtual_services: pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceArgs']]],
                 destination_rule: Optional[pulumi.Input['RolloutSpecTrafficIstioDestinationRuleArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceArgs']]] virtual_services: Defines a set of traffic routing rules to apply when a host is addressed.
        :param pulumi.Input['RolloutSpecTrafficIstioDestinationRuleArgs'] destination_rule: It references to an Istio DestinationRule to modify and shape traffic. `DestinationRule` field belongs only to the Subset Level approach.
        """
        pulumi.set(__self__, "virtual_services", virtual_services)
        if destination_rule is not None:
            pulumi.set(__self__, "destination_rule", destination_rule)

    @property
    @pulumi.getter(name="virtualServices")
    def virtual_services(self) -> pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceArgs']]]:
        """
        Defines a set of traffic routing rules to apply when a host is addressed.
        """
        return pulumi.get(self, "virtual_services")

    @virtual_services.setter
    def virtual_services(self, value: pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceArgs']]]):
        pulumi.set(self, "virtual_services", value)

    @property
    @pulumi.getter(name="destinationRule")
    def destination_rule(self) -> Optional[pulumi.Input['RolloutSpecTrafficIstioDestinationRuleArgs']]:
        """
        It references to an Istio DestinationRule to modify and shape traffic. `DestinationRule` field belongs only to the Subset Level approach.
        """
        return pulumi.get(self, "destination_rule")

    @destination_rule.setter
    def destination_rule(self, value: Optional[pulumi.Input['RolloutSpecTrafficIstioDestinationRuleArgs']]):
        pulumi.set(self, "destination_rule", value)


if not MYPY:
    class RolloutSpecTrafficIstioDestinationRuleArgsDict(TypedDict):
        canary_subset_name: pulumi.Input[builtins.str]
        """
        The subset name to modify labels with the canary version.
        """
        destination_rule_name: pulumi.Input[builtins.str]
        """
        Holds the name of the DestinationRule.
        """
        stable_subset_name: pulumi.Input[builtins.str]
        """
        The subset name to modify labels with the stable version.
        """
elif False:
    RolloutSpecTrafficIstioDestinationRuleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecTrafficIstioDestinationRuleArgs:
    def __init__(__self__, *,
                 canary_subset_name: pulumi.Input[builtins.str],
                 destination_rule_name: pulumi.Input[builtins.str],
                 stable_subset_name: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] canary_subset_name: The subset name to modify labels with the canary version.
        :param pulumi.Input[builtins.str] destination_rule_name: Holds the name of the DestinationRule.
        :param pulumi.Input[builtins.str] stable_subset_name: The subset name to modify labels with the stable version.
        """
        pulumi.set(__self__, "canary_subset_name", canary_subset_name)
        pulumi.set(__self__, "destination_rule_name", destination_rule_name)
        pulumi.set(__self__, "stable_subset_name", stable_subset_name)

    @property
    @pulumi.getter(name="canarySubsetName")
    def canary_subset_name(self) -> pulumi.Input[builtins.str]:
        """
        The subset name to modify labels with the canary version.
        """
        return pulumi.get(self, "canary_subset_name")

    @canary_subset_name.setter
    def canary_subset_name(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "canary_subset_name", value)

    @property
    @pulumi.getter(name="destinationRuleName")
    def destination_rule_name(self) -> pulumi.Input[builtins.str]:
        """
        Holds the name of the DestinationRule.
        """
        return pulumi.get(self, "destination_rule_name")

    @destination_rule_name.setter
    def destination_rule_name(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "destination_rule_name", value)

    @property
    @pulumi.getter(name="stableSubsetName")
    def stable_subset_name(self) -> pulumi.Input[builtins.str]:
        """
        The subset name to modify labels with the stable version.
        """
        return pulumi.get(self, "stable_subset_name")

    @stable_subset_name.setter
    def stable_subset_name(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "stable_subset_name", value)


if not MYPY:
    class RolloutSpecTrafficIstioVirtualServiceArgsDict(TypedDict):
        virtual_service_name: pulumi.Input[builtins.str]
        """
        Holds the name of the VirtualService.
        """
        tls_routes: NotRequired[pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceTlsRouteArgsDict']]]]
        """
        A list of HTTPS routes within VirtualService.
        """
        virtual_service_routes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        A list of HTTP routes within VirtualService.
        """
elif False:
    RolloutSpecTrafficIstioVirtualServiceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecTrafficIstioVirtualServiceArgs:
    def __init__(__self__, *,
                 virtual_service_name: pulumi.Input[builtins.str],
                 tls_routes: Optional[pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs']]]] = None,
                 virtual_service_routes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
        """
        :param pulumi.Input[builtins.str] virtual_service_name: Holds the name of the VirtualService.
        :param pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs']]] tls_routes: A list of HTTPS routes within VirtualService.
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] virtual_service_routes: A list of HTTP routes within VirtualService.
        """
        pulumi.set(__self__, "virtual_service_name", virtual_service_name)
        if tls_routes is not None:
            pulumi.set(__self__, "tls_routes", tls_routes)
        if virtual_service_routes is not None:
            pulumi.set(__self__, "virtual_service_routes", virtual_service_routes)

    @property
    @pulumi.getter(name="virtualServiceName")
    def virtual_service_name(self) -> pulumi.Input[builtins.str]:
        """
        Holds the name of the VirtualService.
        """
        return pulumi.get(self, "virtual_service_name")

    @virtual_service_name.setter
    def virtual_service_name(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "virtual_service_name", value)

    @property
    @pulumi.getter(name="tlsRoutes")
    def tls_routes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs']]]]:
        """
        A list of HTTPS routes within VirtualService.
        """
        return pulumi.get(self, "tls_routes")

    @tls_routes.setter
    def tls_routes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs']]]]):
        pulumi.set(self, "tls_routes", value)

    @property
    @pulumi.getter(name="virtualServiceRoutes")
    def virtual_service_routes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        A list of HTTP routes within VirtualService.
        """
        return pulumi.get(self, "virtual_service_routes")

    @virtual_service_routes.setter
    def virtual_service_routes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "virtual_service_routes", value)


if not MYPY:
    class RolloutSpecTrafficIstioVirtualServiceTlsRouteArgsDict(TypedDict):
        port: NotRequired[pulumi.Input[builtins.int]]
        """
        The port of the TLS Route desired to be matched in the given Istio VirtualService.
        """
        sni_hosts: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
        """
        A list of all the SNI Hosts of the TLS Route desired to be matched in the given Istio VirtualService.
        """
elif False:
    RolloutSpecTrafficIstioVirtualServiceTlsRouteArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs:
    def __init__(__self__, *,
                 port: Optional[pulumi.Input[builtins.int]] = None,
                 sni_hosts: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
        """
        :param pulumi.Input[builtins.int] port: The port of the TLS Route desired to be matched in the given Istio VirtualService.
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] sni_hosts: A list of all the SNI Hosts of the TLS Route desired to be matched in the given Istio VirtualService.
        """
        if port is not None:
            pulumi.set(__self__, "port", port)
        if sni_hosts is not None:
            pulumi.set(__self__, "sni_hosts", sni_hosts)

    @property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The port of the TLS Route desired to be matched in the given Istio VirtualService.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="sniHosts")
    def sni_hosts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
        """
        A list of all the SNI Hosts of the TLS Route desired to be matched in the given Istio VirtualService.
        """
        return pulumi.get(self, "sni_hosts")

    @sni_hosts.setter
    def sni_hosts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
        pulumi.set(self, "sni_hosts", value)


if not MYPY:
    class RolloutSpecTrafficNginxArgsDict(TypedDict):
        stable_ingress: pulumi.Input[builtins.str]
        """
        Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
        """
        additional_ingress_annotation: NotRequired[pulumi.Input['RolloutSpecTrafficNginxAdditionalIngressAnnotationArgsDict']]
        """
        Provides additional features to add to the canary ingress (such as routing by header, cookie, etc). You can add these Kubernetes annotations to specific Ingress objects to customize their behavior. Above are found examples of accepted k8s keys.For the full list of supported keys, you may reach the following documentation - https://kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/annotations/#canary.
        """
        nginx_annotation_prefix: NotRequired[pulumi.Input[builtins.str]]
        """
        Has to match the configured annotation prefix on the Nginx ingress controller.
        """
elif False:
    RolloutSpecTrafficNginxArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecTrafficNginxArgs:
    def __init__(__self__, *,
                 stable_ingress: pulumi.Input[builtins.str],
                 additional_ingress_annotation: Optional[pulumi.Input['RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs']] = None,
                 nginx_annotation_prefix: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] stable_ingress: Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
        :param pulumi.Input['RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs'] additional_ingress_annotation: Provides additional features to add to the canary ingress (such as routing by header, cookie, etc). You can add these Kubernetes annotations to specific Ingress objects to customize their behavior. Above are found examples of accepted k8s keys.For the full list of supported keys, you may reach the following documentation - https://kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/annotations/#canary.
        :param pulumi.Input[builtins.str] nginx_annotation_prefix: Has to match the configured annotation prefix on the Nginx ingress controller.
        """
        pulumi.set(__self__, "stable_ingress", stable_ingress)
        if additional_ingress_annotation is not None:
            pulumi.set(__self__, "additional_ingress_annotation", additional_ingress_annotation)
        if nginx_annotation_prefix is not None:
            pulumi.set(__self__, "nginx_annotation_prefix", nginx_annotation_prefix)

    @property
    @pulumi.getter(name="stableIngress")
    def stable_ingress(self) -> pulumi.Input[builtins.str]:
        """
        Refers to the name of an `Ingress` resource in the same namespace as the `SpotDeployment`.
        """
        return pulumi.get(self, "stable_ingress")

    @stable_ingress.setter
    def stable_ingress(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "stable_ingress", value)

    @property
    @pulumi.getter(name="additionalIngressAnnotation")
    def additional_ingress_annotation(self) -> Optional[pulumi.Input['RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs']]:
        """
        Provides additional features to add to the canary ingress (such as routing by header, cookie, etc). You can add these Kubernetes annotations to specific Ingress objects to customize their behavior. Above are found examples of accepted k8s keys.For the full list of supported keys, you may reach the following documentation - https://kubernetes.github.io/ingress-nginx/user-guide/nginx-configuration/annotations/#canary.
        """
        return pulumi.get(self, "additional_ingress_annotation")

    @additional_ingress_annotation.setter
    def additional_ingress_annotation(self, value: Optional[pulumi.Input['RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs']]):
        pulumi.set(self, "additional_ingress_annotation", value)

    @property
    @pulumi.getter(name="nginxAnnotationPrefix")
    def nginx_annotation_prefix(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Has to match the configured annotation prefix on the Nginx ingress controller.
        """
        return pulumi.get(self, "nginx_annotation_prefix")

    @nginx_annotation_prefix.setter
    def nginx_annotation_prefix(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "nginx_annotation_prefix", value)


if not MYPY:
    class RolloutSpecTrafficNginxAdditionalIngressAnnotationArgsDict(TypedDict):
        canary_by_header: NotRequired[pulumi.Input[builtins.str]]
        """
        Allows customizing the header value instead of using hardcoded values.
        """
        key1: NotRequired[pulumi.Input[builtins.str]]
        """
        Any of supported annotations.
        """
elif False:
    RolloutSpecTrafficNginxAdditionalIngressAnnotationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs:
    def __init__(__self__, *,
                 canary_by_header: Optional[pulumi.Input[builtins.str]] = None,
                 key1: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] canary_by_header: Allows customizing the header value instead of using hardcoded values.
        :param pulumi.Input[builtins.str] key1: Any of supported annotations.
        """
        if canary_by_header is not None:
            pulumi.set(__self__, "canary_by_header", canary_by_header)
        if key1 is not None:
            pulumi.set(__self__, "key1", key1)

    @property
    @pulumi.getter(name="canaryByHeader")
    def canary_by_header(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Allows customizing the header value instead of using hardcoded values.
        """
        return pulumi.get(self, "canary_by_header")

    @canary_by_header.setter
    def canary_by_header(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "canary_by_header", value)

    @property
    @pulumi.getter
    def key1(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Any of supported annotations.
        """
        return pulumi.get(self, "key1")

    @key1.setter
    def key1(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "key1", value)


if not MYPY:
    class RolloutSpecTrafficPingPongArgsDict(TypedDict):
        ping_service: pulumi.Input[builtins.str]
        """
        Holds the name of the ping service.
        """
        pong_service: pulumi.Input[builtins.str]
        """
        Holds the name of the pong service.
        """
elif False:
    RolloutSpecTrafficPingPongArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecTrafficPingPongArgs:
    def __init__(__self__, *,
                 ping_service: pulumi.Input[builtins.str],
                 pong_service: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] ping_service: Holds the name of the ping service.
        :param pulumi.Input[builtins.str] pong_service: Holds the name of the pong service.
        """
        pulumi.set(__self__, "ping_service", ping_service)
        pulumi.set(__self__, "pong_service", pong_service)

    @property
    @pulumi.getter(name="pingService")
    def ping_service(self) -> pulumi.Input[builtins.str]:
        """
        Holds the name of the ping service.
        """
        return pulumi.get(self, "ping_service")

    @ping_service.setter
    def ping_service(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "ping_service", value)

    @property
    @pulumi.getter(name="pongService")
    def pong_service(self) -> pulumi.Input[builtins.str]:
        """
        Holds the name of the pong service.
        """
        return pulumi.get(self, "pong_service")

    @pong_service.setter
    def pong_service(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "pong_service", value)


if not MYPY:
    class RolloutSpecTrafficSmiArgsDict(TypedDict):
        smi_root_service: NotRequired[pulumi.Input[builtins.str]]
        """
        Holds the name of service that clients use to communicate.
        """
        traffic_split_name: NotRequired[pulumi.Input[builtins.str]]
        """
        Holds the name of the TrafficSplit.
        """
elif False:
    RolloutSpecTrafficSmiArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RolloutSpecTrafficSmiArgs:
    def __init__(__self__, *,
                 smi_root_service: Optional[pulumi.Input[builtins.str]] = None,
                 traffic_split_name: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] smi_root_service: Holds the name of service that clients use to communicate.
        :param pulumi.Input[builtins.str] traffic_split_name: Holds the name of the TrafficSplit.
        """
        if smi_root_service is not None:
            pulumi.set(__self__, "smi_root_service", smi_root_service)
        if traffic_split_name is not None:
            pulumi.set(__self__, "traffic_split_name", traffic_split_name)

    @property
    @pulumi.getter(name="smiRootService")
    def smi_root_service(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Holds the name of service that clients use to communicate.
        """
        return pulumi.get(self, "smi_root_service")

    @smi_root_service.setter
    def smi_root_service(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "smi_root_service", value)

    @property
    @pulumi.getter(name="trafficSplitName")
    def traffic_split_name(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Holds the name of the TrafficSplit.
        """
        return pulumi.get(self, "traffic_split_name")

    @traffic_split_name.setter
    def traffic_split_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "traffic_split_name", value)


if not MYPY:
    class StrategyCanaryArgsDict(TypedDict):
        steps: pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepArgsDict']]]
        """
        A set of separate conditions of rollout processing.
        """
        background_verification: NotRequired[pulumi.Input['StrategyCanaryBackgroundVerificationArgsDict']]
        """
        A list of background verifications.
        """
elif False:
    StrategyCanaryArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class StrategyCanaryArgs:
    def __init__(__self__, *,
                 steps: pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepArgs']]],
                 background_verification: Optional[pulumi.Input['StrategyCanaryBackgroundVerificationArgs']] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepArgs']]] steps: A set of separate conditions of rollout processing.
        :param pulumi.Input['StrategyCanaryBackgroundVerificationArgs'] background_verification: A list of background verifications.
        """
        pulumi.set(__self__, "steps", steps)
        if background_verification is not None:
            pulumi.set(__self__, "background_verification", background_verification)

    @property
    @pulumi.getter
    def steps(self) -> pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepArgs']]]:
        """
        A set of separate conditions of rollout processing.
        """
        return pulumi.get(self, "steps")

    @steps.setter
    def steps(self, value: pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepArgs']]]):
        pulumi.set(self, "steps", value)

    @property
    @pulumi.getter(name="backgroundVerification")
    def background_verification(self) -> Optional[pulumi.Input['StrategyCanaryBackgroundVerificationArgs']]:
        """
        A list of background verifications.
        """
        return pulumi.get(self, "background_verification")

    @background_verification.setter
    def background_verification(self, value: Optional[pulumi.Input['StrategyCanaryBackgroundVerificationArgs']]):
        pulumi.set(self, "background_verification", value)


if not MYPY:
    class StrategyCanaryBackgroundVerificationArgsDict(TypedDict):
        template_names: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
        """
        List of Verification Template names.
        """
elif False:
    StrategyCanaryBackgroundVerificationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class StrategyCanaryBackgroundVerificationArgs:
    def __init__(__self__, *,
                 template_names: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] template_names: List of Verification Template names.
        """
        pulumi.set(__self__, "template_names", template_names)

    @property
    @pulumi.getter(name="templateNames")
    def template_names(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
        """
        List of Verification Template names.
        """
        return pulumi.get(self, "template_names")

    @template_names.setter
    def template_names(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
        pulumi.set(self, "template_names", value)


if not MYPY:
    class StrategyCanaryStepArgsDict(TypedDict):
        pause: NotRequired[pulumi.Input['StrategyCanaryStepPauseArgsDict']]
        """
        Defines the duration of time to freeze the rollout.
        """
        set_canary_scale: NotRequired[pulumi.Input['StrategyCanaryStepSetCanaryScaleArgsDict']]
        """
        Defines how to scale the version without traffic weight changing.
        """
        set_header_route: NotRequired[pulumi.Input['StrategyCanaryStepSetHeaderRouteArgsDict']]
        """
        Defines the list of HeaderRoutes to add to the Rollout.
        """
        set_weight: NotRequired[pulumi.Input[builtins.int]]
        """
        Defines the percentage that the new version should receive.
        """
        step_name: NotRequired[pulumi.Input[builtins.str]]
        verification: NotRequired[pulumi.Input['StrategyCanaryStepVerificationArgsDict']]
        """
        Represents the list of verifications to run in a step.
        """
elif False:
    StrategyCanaryStepArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class StrategyCanaryStepArgs:
    def __init__(__self__, *,
                 pause: Optional[pulumi.Input['StrategyCanaryStepPauseArgs']] = None,
                 set_canary_scale: Optional[pulumi.Input['StrategyCanaryStepSetCanaryScaleArgs']] = None,
                 set_header_route: Optional[pulumi.Input['StrategyCanaryStepSetHeaderRouteArgs']] = None,
                 set_weight: Optional[pulumi.Input[builtins.int]] = None,
                 step_name: Optional[pulumi.Input[builtins.str]] = None,
                 verification: Optional[pulumi.Input['StrategyCanaryStepVerificationArgs']] = None):
        """
        :param pulumi.Input['StrategyCanaryStepPauseArgs'] pause: Defines the duration of time to freeze the rollout.
        :param pulumi.Input['StrategyCanaryStepSetCanaryScaleArgs'] set_canary_scale: Defines how to scale the version without traffic weight changing.
        :param pulumi.Input['StrategyCanaryStepSetHeaderRouteArgs'] set_header_route: Defines the list of HeaderRoutes to add to the Rollout.
        :param pulumi.Input[builtins.int] set_weight: Defines the percentage that the new version should receive.
        :param pulumi.Input['StrategyCanaryStepVerificationArgs'] verification: Represents the list of verifications to run in a step.
        """
        if pause is not None:
            pulumi.set(__self__, "pause", pause)
        if set_canary_scale is not None:
            pulumi.set(__self__, "set_canary_scale", set_canary_scale)
        if set_header_route is not None:
            pulumi.set(__self__, "set_header_route", set_header_route)
        if set_weight is not None:
            pulumi.set(__self__, "set_weight", set_weight)
        if step_name is not None:
            pulumi.set(__self__, "step_name", step_name)
        if verification is not None:
            pulumi.set(__self__, "verification", verification)

    @property
    @pulumi.getter
    def pause(self) -> Optional[pulumi.Input['StrategyCanaryStepPauseArgs']]:
        """
        Defines the duration of time to freeze the rollout.
        """
        return pulumi.get(self, "pause")

    @pause.setter
    def pause(self, value: Optional[pulumi.Input['StrategyCanaryStepPauseArgs']]):
        pulumi.set(self, "pause", value)

    @property
    @pulumi.getter(name="setCanaryScale")
    def set_canary_scale(self) -> Optional[pulumi.Input['StrategyCanaryStepSetCanaryScaleArgs']]:
        """
        Defines how to scale the version without traffic weight changing.
        """
        return pulumi.get(self, "set_canary_scale")

    @set_canary_scale.setter
    def set_canary_scale(self, value: Optional[pulumi.Input['StrategyCanaryStepSetCanaryScaleArgs']]):
        pulumi.set(self, "set_canary_scale", value)

    @property
    @pulumi.getter(name="setHeaderRoute")
    def set_header_route(self) -> Optional[pulumi.Input['StrategyCanaryStepSetHeaderRouteArgs']]:
        """
        Defines the list of HeaderRoutes to add to the Rollout.
        """
        return pulumi.get(self, "set_header_route")

    @set_header_route.setter
    def set_header_route(self, value: Optional[pulumi.Input['StrategyCanaryStepSetHeaderRouteArgs']]):
        pulumi.set(self, "set_header_route", value)

    @property
    @pulumi.getter(name="setWeight")
    def set_weight(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Defines the percentage that the new version should receive.
        """
        return pulumi.get(self, "set_weight")

    @set_weight.setter
    def set_weight(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "set_weight", value)

    @property
    @pulumi.getter(name="stepName")
    def step_name(self) -> Optional[pulumi.Input[builtins.str]]:
        return pulumi.get(self, "step_name")

    @step_name.setter
    def step_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "step_name", value)

    @property
    @pulumi.getter
    def verification(self) -> Optional[pulumi.Input['StrategyCanaryStepVerificationArgs']]:
        """
        Represents the list of verifications to run in a step.
        """
        return pulumi.get(self, "verification")

    @verification.setter
    def verification(self, value: Optional[pulumi.Input['StrategyCanaryStepVerificationArgs']]):
        pulumi.set(self, "verification", value)


if not MYPY:
    class StrategyCanaryStepPauseArgsDict(TypedDict):
        duration: NotRequired[pulumi.Input[builtins.str]]
        """
        The amount of time to wait before moving to the next step.
        """
elif False:
    StrategyCanaryStepPauseArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class StrategyCanaryStepPauseArgs:
    def __init__(__self__, *,
                 duration: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] duration: The amount of time to wait before moving to the next step.
        """
        if duration is not None:
            pulumi.set(__self__, "duration", duration)

    @property
    @pulumi.getter
    def duration(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The amount of time to wait before moving to the next step.
        """
        return pulumi.get(self, "duration")

    @duration.setter
    def duration(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "duration", value)


if not MYPY:
    class StrategyCanaryStepSetCanaryScaleArgsDict(TypedDict):
        match_traffic_weight: NotRequired[pulumi.Input[builtins.bool]]
        """
        Defines whether a rollout should match the current canary's setWeight step.
        """
        replicas: NotRequired[pulumi.Input[builtins.int]]
        """
        Sets the number of replicas the new version should have.
        """
        weight: NotRequired[pulumi.Input[builtins.int]]
        """
        Sets the percentage of replicas the new version should have.
        """
elif False:
    StrategyCanaryStepSetCanaryScaleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class StrategyCanaryStepSetCanaryScaleArgs:
    def __init__(__self__, *,
                 match_traffic_weight: Optional[pulumi.Input[builtins.bool]] = None,
                 replicas: Optional[pulumi.Input[builtins.int]] = None,
                 weight: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[builtins.bool] match_traffic_weight: Defines whether a rollout should match the current canary's setWeight step.
        :param pulumi.Input[builtins.int] replicas: Sets the number of replicas the new version should have.
        :param pulumi.Input[builtins.int] weight: Sets the percentage of replicas the new version should have.
        """
        if match_traffic_weight is not None:
            pulumi.set(__self__, "match_traffic_weight", match_traffic_weight)
        if replicas is not None:
            pulumi.set(__self__, "replicas", replicas)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

    @property
    @pulumi.getter(name="matchTrafficWeight")
    def match_traffic_weight(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Defines whether a rollout should match the current canary's setWeight step.
        """
        return pulumi.get(self, "match_traffic_weight")

    @match_traffic_weight.setter
    def match_traffic_weight(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "match_traffic_weight", value)

    @property
    @pulumi.getter
    def replicas(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Sets the number of replicas the new version should have.
        """
        return pulumi.get(self, "replicas")

    @replicas.setter
    def replicas(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "replicas", value)

    @property
    @pulumi.getter
    def weight(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Sets the percentage of replicas the new version should have.
        """
        return pulumi.get(self, "weight")

    @weight.setter
    def weight(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "weight", value)


if not MYPY:
    class StrategyCanaryStepSetHeaderRouteArgsDict(TypedDict):
        header_route_name: pulumi.Input[builtins.str]
        """
        The name of the HeaderRoute group.
        """
        matches: pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchArgsDict']]]
        """
        The matching rules for the header route.
        """
elif False:
    StrategyCanaryStepSetHeaderRouteArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class StrategyCanaryStepSetHeaderRouteArgs:
    def __init__(__self__, *,
                 header_route_name: pulumi.Input[builtins.str],
                 matches: pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchArgs']]]):
        """
        :param pulumi.Input[builtins.str] header_route_name: The name of the HeaderRoute group.
        :param pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchArgs']]] matches: The matching rules for the header route.
        """
        pulumi.set(__self__, "header_route_name", header_route_name)
        pulumi.set(__self__, "matches", matches)

    @property
    @pulumi.getter(name="headerRouteName")
    def header_route_name(self) -> pulumi.Input[builtins.str]:
        """
        The name of the HeaderRoute group.
        """
        return pulumi.get(self, "header_route_name")

    @header_route_name.setter
    def header_route_name(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "header_route_name", value)

    @property
    @pulumi.getter
    def matches(self) -> pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchArgs']]]:
        """
        The matching rules for the header route.
        """
        return pulumi.get(self, "matches")

    @matches.setter
    def matches(self, value: pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchArgs']]]):
        pulumi.set(self, "matches", value)


if not MYPY:
    class StrategyCanaryStepSetHeaderRouteMatchArgsDict(TypedDict):
        header_name: pulumi.Input[builtins.str]
        """
        The name of the header.
        """
        header_value: pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgsDict']
        """
        Defines a single header to add to the Rollout. Must be only one initialized from the following (exact, prefix, regex).
        """
elif False:
    StrategyCanaryStepSetHeaderRouteMatchArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class StrategyCanaryStepSetHeaderRouteMatchArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[builtins.str],
                 header_value: pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs']):
        """
        :param pulumi.Input[builtins.str] header_name: The name of the header.
        :param pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs'] header_value: Defines a single header to add to the Rollout. Must be only one initialized from the following (exact, prefix, regex).
        """
        pulumi.set(__self__, "header_name", header_name)
        pulumi.set(__self__, "header_value", header_value)

    @property
    @pulumi.getter(name="headerName")
    def header_name(self) -> pulumi.Input[builtins.str]:
        """
        The name of the header.
        """
        return pulumi.get(self, "header_name")

    @header_name.setter
    def header_name(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "header_name", value)

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs']:
        """
        Defines a single header to add to the Rollout. Must be only one initialized from the following (exact, prefix, regex).
        """
        return pulumi.get(self, "header_value")

    @header_value.setter
    def header_value(self, value: pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs']):
        pulumi.set(self, "header_value", value)


if not MYPY:
    class StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgsDict(TypedDict):
        exact: NotRequired[pulumi.Input[builtins.str]]
        """
        The exact header value.
        """
        prefix: NotRequired[pulumi.Input[builtins.str]]
        """
        The prefix of the value.
        """
        regex: NotRequired[pulumi.Input[builtins.str]]
        """
        The value in a regex format.
        """
elif False:
    StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs:
    def __init__(__self__, *,
                 exact: Optional[pulumi.Input[builtins.str]] = None,
                 prefix: Optional[pulumi.Input[builtins.str]] = None,
                 regex: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] exact: The exact header value.
        :param pulumi.Input[builtins.str] prefix: The prefix of the value.
        :param pulumi.Input[builtins.str] regex: The value in a regex format.
        """
        if exact is not None:
            pulumi.set(__self__, "exact", exact)
        if prefix is not None:
            pulumi.set(__self__, "prefix", prefix)
        if regex is not None:
            pulumi.set(__self__, "regex", regex)

    @property
    @pulumi.getter
    def exact(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The exact header value.
        """
        return pulumi.get(self, "exact")

    @exact.setter
    def exact(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "exact", value)

    @property
    @pulumi.getter
    def prefix(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The prefix of the value.
        """
        return pulumi.get(self, "prefix")

    @prefix.setter
    def prefix(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "prefix", value)

    @property
    @pulumi.getter
    def regex(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The value in a regex format.
        """
        return pulumi.get(self, "regex")

    @regex.setter
    def regex(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "regex", value)


if not MYPY:
    class StrategyCanaryStepVerificationArgsDict(TypedDict):
        template_names: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
        """
        List of Verification Template names.
        """
elif False:
    StrategyCanaryStepVerificationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class StrategyCanaryStepVerificationArgs:
    def __init__(__self__, *,
                 template_names: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] template_names: List of Verification Template names.
        """
        pulumi.set(__self__, "template_names", template_names)

    @property
    @pulumi.getter(name="templateNames")
    def template_names(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
        """
        List of Verification Template names.
        """
        return pulumi.get(self, "template_names")

    @template_names.setter
    def template_names(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
        pulumi.set(self, "template_names", value)


if not MYPY:
    class StrategyRollingArgsDict(TypedDict):
        steps: pulumi.Input[Sequence[pulumi.Input['StrategyRollingStepArgsDict']]]
        """
        A set of separate conditions of rollout processing.
        """
elif False:
    StrategyRollingArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class StrategyRollingArgs:
    def __init__(__self__, *,
                 steps: pulumi.Input[Sequence[pulumi.Input['StrategyRollingStepArgs']]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['StrategyRollingStepArgs']]] steps: A set of separate conditions of rollout processing.
        """
        pulumi.set(__self__, "steps", steps)

    @property
    @pulumi.getter
    def steps(self) -> pulumi.Input[Sequence[pulumi.Input['StrategyRollingStepArgs']]]:
        """
        A set of separate conditions of rollout processing.
        """
        return pulumi.get(self, "steps")

    @steps.setter
    def steps(self, value: pulumi.Input[Sequence[pulumi.Input['StrategyRollingStepArgs']]]):
        pulumi.set(self, "steps", value)


if not MYPY:
    class StrategyRollingStepArgsDict(TypedDict):
        pause: NotRequired[pulumi.Input['StrategyRollingStepPauseArgsDict']]
        """
        Defines the duration of time to freeze the rollout.
        """
        steps_name: NotRequired[pulumi.Input[builtins.str]]
        verification: NotRequired[pulumi.Input['StrategyRollingStepVerificationArgsDict']]
        """
        Represents the list of verifications to run in a step.
        """
elif False:
    StrategyRollingStepArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class StrategyRollingStepArgs:
    def __init__(__self__, *,
                 pause: Optional[pulumi.Input['StrategyRollingStepPauseArgs']] = None,
                 steps_name: Optional[pulumi.Input[builtins.str]] = None,
                 verification: Optional[pulumi.Input['StrategyRollingStepVerificationArgs']] = None):
        """
        :param pulumi.Input['StrategyRollingStepPauseArgs'] pause: Defines the duration of time to freeze the rollout.
        :param pulumi.Input['StrategyRollingStepVerificationArgs'] verification: Represents the list of verifications to run in a step.
        """
        if pause is not None:
            pulumi.set(__self__, "pause", pause)
        if steps_name is not None:
            pulumi.set(__self__, "steps_name", steps_name)
        if verification is not None:
            pulumi.set(__self__, "verification", verification)

    @property
    @pulumi.getter
    def pause(self) -> Optional[pulumi.Input['StrategyRollingStepPauseArgs']]:
        """
        Defines the duration of time to freeze the rollout.
        """
        return pulumi.get(self, "pause")

    @pause.setter
    def pause(self, value: Optional[pulumi.Input['StrategyRollingStepPauseArgs']]):
        pulumi.set(self, "pause", value)

    @property
    @pulumi.getter(name="stepsName")
    def steps_name(self) -> Optional[pulumi.Input[builtins.str]]:
        return pulumi.get(self, "steps_name")

    @steps_name.setter
    def steps_name(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "steps_name", value)

    @property
    @pulumi.getter
    def verification(self) -> Optional[pulumi.Input['StrategyRollingStepVerificationArgs']]:
        """
        Represents the list of verifications to run in a step.
        """
        return pulumi.get(self, "verification")

    @verification.setter
    def verification(self, value: Optional[pulumi.Input['StrategyRollingStepVerificationArgs']]):
        pulumi.set(self, "verification", value)


if not MYPY:
    class StrategyRollingStepPauseArgsDict(TypedDict):
        duration: NotRequired[pulumi.Input[builtins.str]]
        """
        The amount of time to wait before moving to the next step.
        """
elif False:
    StrategyRollingStepPauseArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class StrategyRollingStepPauseArgs:
    def __init__(__self__, *,
                 duration: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] duration: The amount of time to wait before moving to the next step.
        """
        if duration is not None:
            pulumi.set(__self__, "duration", duration)

    @property
    @pulumi.getter
    def duration(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The amount of time to wait before moving to the next step.
        """
        return pulumi.get(self, "duration")

    @duration.setter
    def duration(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "duration", value)


if not MYPY:
    class StrategyRollingStepVerificationArgsDict(TypedDict):
        template_names: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
        """
        List of Verification Template names.
        """
elif False:
    StrategyRollingStepVerificationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class StrategyRollingStepVerificationArgs:
    def __init__(__self__, *,
                 template_names: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] template_names: List of Verification Template names.
        """
        pulumi.set(__self__, "template_names", template_names)

    @property
    @pulumi.getter(name="templateNames")
    def template_names(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
        """
        List of Verification Template names.
        """
        return pulumi.get(self, "template_names")

    @template_names.setter
    def template_names(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
        pulumi.set(self, "template_names", value)


if not MYPY:
    class VerificationProviderCloudWatchArgsDict(TypedDict):
        iam_arn: pulumi.Input[builtins.str]
        """
        Set label key.
        """
elif False:
    VerificationProviderCloudWatchArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationProviderCloudWatchArgs:
    def __init__(__self__, *,
                 iam_arn: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] iam_arn: Set label key.
        """
        pulumi.set(__self__, "iam_arn", iam_arn)

    @property
    @pulumi.getter(name="iamArn")
    def iam_arn(self) -> pulumi.Input[builtins.str]:
        """
        Set label key.
        """
        return pulumi.get(self, "iam_arn")

    @iam_arn.setter
    def iam_arn(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "iam_arn", value)


if not MYPY:
    class VerificationProviderDatadogArgsDict(TypedDict):
        address: pulumi.Input[builtins.str]
        """
        DataDog API URL.
        """
        api_key: pulumi.Input[builtins.str]
        """
        API key required by the Datadog Agent to submit metrics and events to Datadog.
        """
        app_key: pulumi.Input[builtins.str]
        """
        API key that gives users access to Datadog’s programmatic API.
        """
elif False:
    VerificationProviderDatadogArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationProviderDatadogArgs:
    def __init__(__self__, *,
                 address: pulumi.Input[builtins.str],
                 api_key: pulumi.Input[builtins.str],
                 app_key: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] address: DataDog API URL.
        :param pulumi.Input[builtins.str] api_key: API key required by the Datadog Agent to submit metrics and events to Datadog.
        :param pulumi.Input[builtins.str] app_key: API key that gives users access to Datadog’s programmatic API.
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "api_key", api_key)
        pulumi.set(__self__, "app_key", app_key)

    @property
    @pulumi.getter
    def address(self) -> pulumi.Input[builtins.str]:
        """
        DataDog API URL.
        """
        return pulumi.get(self, "address")

    @address.setter
    def address(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "address", value)

    @property
    @pulumi.getter(name="apiKey")
    def api_key(self) -> pulumi.Input[builtins.str]:
        """
        API key required by the Datadog Agent to submit metrics and events to Datadog.
        """
        return pulumi.get(self, "api_key")

    @api_key.setter
    def api_key(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "api_key", value)

    @property
    @pulumi.getter(name="appKey")
    def app_key(self) -> pulumi.Input[builtins.str]:
        """
        API key that gives users access to Datadog’s programmatic API.
        """
        return pulumi.get(self, "app_key")

    @app_key.setter
    def app_key(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "app_key", value)


if not MYPY:
    class VerificationProviderJenkinsArgsDict(TypedDict):
        api_token: pulumi.Input[builtins.str]
        """
        The Jenkins server’s access apiToken.
        """
        base_url: pulumi.Input[builtins.str]
        """
        The address of the Jenkins server within the cluster.
        """
        username: pulumi.Input[builtins.str]
        """
        The Jenkins server’s access username.
        """
elif False:
    VerificationProviderJenkinsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationProviderJenkinsArgs:
    def __init__(__self__, *,
                 api_token: pulumi.Input[builtins.str],
                 base_url: pulumi.Input[builtins.str],
                 username: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] api_token: The Jenkins server’s access apiToken.
        :param pulumi.Input[builtins.str] base_url: The address of the Jenkins server within the cluster.
        :param pulumi.Input[builtins.str] username: The Jenkins server’s access username.
        """
        pulumi.set(__self__, "api_token", api_token)
        pulumi.set(__self__, "base_url", base_url)
        pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter(name="apiToken")
    def api_token(self) -> pulumi.Input[builtins.str]:
        """
        The Jenkins server’s access apiToken.
        """
        return pulumi.get(self, "api_token")

    @api_token.setter
    def api_token(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "api_token", value)

    @property
    @pulumi.getter(name="baseUrl")
    def base_url(self) -> pulumi.Input[builtins.str]:
        """
        The address of the Jenkins server within the cluster.
        """
        return pulumi.get(self, "base_url")

    @base_url.setter
    def base_url(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "base_url", value)

    @property
    @pulumi.getter
    def username(self) -> pulumi.Input[builtins.str]:
        """
        The Jenkins server’s access username.
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "username", value)


if not MYPY:
    class VerificationProviderNewRelicArgsDict(TypedDict):
        account_id: pulumi.Input[builtins.str]
        personal_api_key: pulumi.Input[builtins.str]
        """
        The NewRelic user key
        """
        base_url_nerd_graph: NotRequired[pulumi.Input[builtins.str]]
        """
        The base URL for NerdGraph for a proxy.
        """
        base_url_rest: NotRequired[pulumi.Input[builtins.str]]
        """
        The base URL of the New Relic REST API for a proxy.
        """
        region: NotRequired[pulumi.Input[builtins.str]]
        """
        A region which the account is attached to. Default is "us".
        """
elif False:
    VerificationProviderNewRelicArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationProviderNewRelicArgs:
    def __init__(__self__, *,
                 account_id: pulumi.Input[builtins.str],
                 personal_api_key: pulumi.Input[builtins.str],
                 base_url_nerd_graph: Optional[pulumi.Input[builtins.str]] = None,
                 base_url_rest: Optional[pulumi.Input[builtins.str]] = None,
                 region: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] personal_api_key: The NewRelic user key
        :param pulumi.Input[builtins.str] base_url_nerd_graph: The base URL for NerdGraph for a proxy.
        :param pulumi.Input[builtins.str] base_url_rest: The base URL of the New Relic REST API for a proxy.
        :param pulumi.Input[builtins.str] region: A region which the account is attached to. Default is "us".
        """
        pulumi.set(__self__, "account_id", account_id)
        pulumi.set(__self__, "personal_api_key", personal_api_key)
        if base_url_nerd_graph is not None:
            pulumi.set(__self__, "base_url_nerd_graph", base_url_nerd_graph)
        if base_url_rest is not None:
            pulumi.set(__self__, "base_url_rest", base_url_rest)
        if region is not None:
            pulumi.set(__self__, "region", region)

    @property
    @pulumi.getter(name="accountId")
    def account_id(self) -> pulumi.Input[builtins.str]:
        return pulumi.get(self, "account_id")

    @account_id.setter
    def account_id(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "account_id", value)

    @property
    @pulumi.getter(name="personalApiKey")
    def personal_api_key(self) -> pulumi.Input[builtins.str]:
        """
        The NewRelic user key
        """
        return pulumi.get(self, "personal_api_key")

    @personal_api_key.setter
    def personal_api_key(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "personal_api_key", value)

    @property
    @pulumi.getter(name="baseUrlNerdGraph")
    def base_url_nerd_graph(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The base URL for NerdGraph for a proxy.
        """
        return pulumi.get(self, "base_url_nerd_graph")

    @base_url_nerd_graph.setter
    def base_url_nerd_graph(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "base_url_nerd_graph", value)

    @property
    @pulumi.getter(name="baseUrlRest")
    def base_url_rest(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The base URL of the New Relic REST API for a proxy.
        """
        return pulumi.get(self, "base_url_rest")

    @base_url_rest.setter
    def base_url_rest(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "base_url_rest", value)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        A region which the account is attached to. Default is "us".
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "region", value)


if not MYPY:
    class VerificationProviderPrometheusArgsDict(TypedDict):
        address: pulumi.Input[builtins.str]
        """
        The address which the Prometheus server available on.
        """
elif False:
    VerificationProviderPrometheusArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationProviderPrometheusArgs:
    def __init__(__self__, *,
                 address: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] address: The address which the Prometheus server available on.
        """
        pulumi.set(__self__, "address", address)

    @property
    @pulumi.getter
    def address(self) -> pulumi.Input[builtins.str]:
        """
        The address which the Prometheus server available on.
        """
        return pulumi.get(self, "address")

    @address.setter
    def address(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "address", value)


if not MYPY:
    class VerificationTemplateArgArgsDict(TypedDict):
        arg_name: pulumi.Input[builtins.str]
        """
        Name of an argument.
        """
        value: NotRequired[pulumi.Input[builtins.str]]
        """
        String representation of data.
        """
        value_from: NotRequired[pulumi.Input['VerificationTemplateArgValueFromArgsDict']]
        """
        ValueFrom object.
        """
elif False:
    VerificationTemplateArgArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateArgArgs:
    def __init__(__self__, *,
                 arg_name: pulumi.Input[builtins.str],
                 value: Optional[pulumi.Input[builtins.str]] = None,
                 value_from: Optional[pulumi.Input['VerificationTemplateArgValueFromArgs']] = None):
        """
        :param pulumi.Input[builtins.str] arg_name: Name of an argument.
        :param pulumi.Input[builtins.str] value: String representation of data.
        :param pulumi.Input['VerificationTemplateArgValueFromArgs'] value_from: ValueFrom object.
        """
        pulumi.set(__self__, "arg_name", arg_name)
        if value is not None:
            pulumi.set(__self__, "value", value)
        if value_from is not None:
            pulumi.set(__self__, "value_from", value_from)

    @property
    @pulumi.getter(name="argName")
    def arg_name(self) -> pulumi.Input[builtins.str]:
        """
        Name of an argument.
        """
        return pulumi.get(self, "arg_name")

    @arg_name.setter
    def arg_name(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "arg_name", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        String representation of data.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "value", value)

    @property
    @pulumi.getter(name="valueFrom")
    def value_from(self) -> Optional[pulumi.Input['VerificationTemplateArgValueFromArgs']]:
        """
        ValueFrom object.
        """
        return pulumi.get(self, "value_from")

    @value_from.setter
    def value_from(self, value: Optional[pulumi.Input['VerificationTemplateArgValueFromArgs']]):
        pulumi.set(self, "value_from", value)


if not MYPY:
    class VerificationTemplateArgValueFromArgsDict(TypedDict):
        secret_key_ref: NotRequired[pulumi.Input['VerificationTemplateArgValueFromSecretKeyRefArgsDict']]
        """
        Secret key to use.
        """
elif False:
    VerificationTemplateArgValueFromArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateArgValueFromArgs:
    def __init__(__self__, *,
                 secret_key_ref: Optional[pulumi.Input['VerificationTemplateArgValueFromSecretKeyRefArgs']] = None):
        """
        :param pulumi.Input['VerificationTemplateArgValueFromSecretKeyRefArgs'] secret_key_ref: Secret key to use.
        """
        if secret_key_ref is not None:
            pulumi.set(__self__, "secret_key_ref", secret_key_ref)

    @property
    @pulumi.getter(name="secretKeyRef")
    def secret_key_ref(self) -> Optional[pulumi.Input['VerificationTemplateArgValueFromSecretKeyRefArgs']]:
        """
        Secret key to use.
        """
        return pulumi.get(self, "secret_key_ref")

    @secret_key_ref.setter
    def secret_key_ref(self, value: Optional[pulumi.Input['VerificationTemplateArgValueFromSecretKeyRefArgs']]):
        pulumi.set(self, "secret_key_ref", value)


if not MYPY:
    class VerificationTemplateArgValueFromSecretKeyRefArgsDict(TypedDict):
        key: pulumi.Input[builtins.str]
        """
        The name of the field inside the secret.
        """
        name: pulumi.Input[builtins.str]
        """
        The name of the secret.
        """
elif False:
    VerificationTemplateArgValueFromSecretKeyRefArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateArgValueFromSecretKeyRefArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[builtins.str],
                 name: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] key: The name of the field inside the secret.
        :param pulumi.Input[builtins.str] name: The name of the secret.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "name", name)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[builtins.str]:
        """
        The name of the field inside the secret.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[builtins.str]:
        """
        The name of the secret.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "name", value)


if not MYPY:
    class VerificationTemplateMetricArgsDict(TypedDict):
        metrics_name: pulumi.Input[builtins.str]
        """
        The name of the verification metric.
        """
        providers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderArgsDict']]]
        """
        The name of the monitoring tool chosen for the metric.
        """
        baseline: NotRequired[pulumi.Input['VerificationTemplateMetricBaselineArgsDict']]
        """
        Baseline Object.
        """
        consecutive_error_limit: NotRequired[pulumi.Input[builtins.int]]
        """
        The maximum number of times the measurement is allowed to error in succession, before the metric is considered error.Default is 4.When choosing `Jenkins` as the provider, there is no need to send this variable.
        """
        count: NotRequired[pulumi.Input[builtins.int]]
        """
        The number of times to run the measurement. If both interval and count are omitted, the effective count is 1. If only interval is specified, metric runs indefinitely. If count > 1, interval must be specified. When choosing `Jenkins` as the provider, there is no need to send this variable.
        """
        dry_run: NotRequired[pulumi.Input[builtins.bool]]
        """
        Defines whether the metric should have an impact on the result of the rollout.
        """
        failure_condition: NotRequired[pulumi.Input[builtins.str]]
        """
        An expression which determines if a measurement is considered failed.If failureCondition is set, then successCondition is not allowed. When choosing Jenkins as the provider, there is no need to send this variable.
        """
        failure_limit: NotRequired[pulumi.Input[builtins.int]]
        """
        The maximum number of times the measurement is allowed to fail, before the entire metric is considered failed.Default is 0. When choosing `Jenkins` as the provider, there is no need to send this variable.
        """
        initial_delay: NotRequired[pulumi.Input[builtins.str]]
        """
        How long to wait before starting this metric measurements. When choosing Jenkins as the provider, there is no need to send this variable.
        """
        interval: NotRequired[pulumi.Input[builtins.str]]
        """
        Defines an interval string (30s, 5m, 1h) between each verification measurements. If omitted, will perform a single measurement.When choosing Jenkins as the provider, there is no need to send this variable.
        """
        success_condition: NotRequired[pulumi.Input[builtins.str]]
        """
        An expression which determines if a measurement is considered successful. The keyword `result` is a variable reference to the value of measurement. Results can be both structured data or primitive. If successCondition is set, then failureCondition is not allowed. When choosing `Jenkins` as the provider, there is no need to send this variable.
        """
elif False:
    VerificationTemplateMetricArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricArgs:
    def __init__(__self__, *,
                 metrics_name: pulumi.Input[builtins.str],
                 providers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderArgs']]],
                 baseline: Optional[pulumi.Input['VerificationTemplateMetricBaselineArgs']] = None,
                 consecutive_error_limit: Optional[pulumi.Input[builtins.int]] = None,
                 count: Optional[pulumi.Input[builtins.int]] = None,
                 dry_run: Optional[pulumi.Input[builtins.bool]] = None,
                 failure_condition: Optional[pulumi.Input[builtins.str]] = None,
                 failure_limit: Optional[pulumi.Input[builtins.int]] = None,
                 initial_delay: Optional[pulumi.Input[builtins.str]] = None,
                 interval: Optional[pulumi.Input[builtins.str]] = None,
                 success_condition: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] metrics_name: The name of the verification metric.
        :param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderArgs']]] providers: The name of the monitoring tool chosen for the metric.
        :param pulumi.Input['VerificationTemplateMetricBaselineArgs'] baseline: Baseline Object.
        :param pulumi.Input[builtins.int] consecutive_error_limit: The maximum number of times the measurement is allowed to error in succession, before the metric is considered error.Default is 4.When choosing `Jenkins` as the provider, there is no need to send this variable.
        :param pulumi.Input[builtins.int] count: The number of times to run the measurement. If both interval and count are omitted, the effective count is 1. If only interval is specified, metric runs indefinitely. If count > 1, interval must be specified. When choosing `Jenkins` as the provider, there is no need to send this variable.
        :param pulumi.Input[builtins.bool] dry_run: Defines whether the metric should have an impact on the result of the rollout.
        :param pulumi.Input[builtins.str] failure_condition: An expression which determines if a measurement is considered failed.If failureCondition is set, then successCondition is not allowed. When choosing Jenkins as the provider, there is no need to send this variable.
        :param pulumi.Input[builtins.int] failure_limit: The maximum number of times the measurement is allowed to fail, before the entire metric is considered failed.Default is 0. When choosing `Jenkins` as the provider, there is no need to send this variable.
        :param pulumi.Input[builtins.str] initial_delay: How long to wait before starting this metric measurements. When choosing Jenkins as the provider, there is no need to send this variable.
        :param pulumi.Input[builtins.str] interval: Defines an interval string (30s, 5m, 1h) between each verification measurements. If omitted, will perform a single measurement.When choosing Jenkins as the provider, there is no need to send this variable.
        :param pulumi.Input[builtins.str] success_condition: An expression which determines if a measurement is considered successful. The keyword `result` is a variable reference to the value of measurement. Results can be both structured data or primitive. If successCondition is set, then failureCondition is not allowed. When choosing `Jenkins` as the provider, there is no need to send this variable.
        """
        pulumi.set(__self__, "metrics_name", metrics_name)
        pulumi.set(__self__, "providers", providers)
        if baseline is not None:
            pulumi.set(__self__, "baseline", baseline)
        if consecutive_error_limit is not None:
            pulumi.set(__self__, "consecutive_error_limit", consecutive_error_limit)
        if count is not None:
            pulumi.set(__self__, "count", count)
        if dry_run is not None:
            pulumi.set(__self__, "dry_run", dry_run)
        if failure_condition is not None:
            pulumi.set(__self__, "failure_condition", failure_condition)
        if failure_limit is not None:
            pulumi.set(__self__, "failure_limit", failure_limit)
        if initial_delay is not None:
            pulumi.set(__self__, "initial_delay", initial_delay)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)
        if success_condition is not None:
            pulumi.set(__self__, "success_condition", success_condition)

    @property
    @pulumi.getter(name="metricsName")
    def metrics_name(self) -> pulumi.Input[builtins.str]:
        """
        The name of the verification metric.
        """
        return pulumi.get(self, "metrics_name")

    @metrics_name.setter
    def metrics_name(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "metrics_name", value)

    @property
    @pulumi.getter
    def providers(self) -> pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderArgs']]]:
        """
        The name of the monitoring tool chosen for the metric.
        """
        return pulumi.get(self, "providers")

    @providers.setter
    def providers(self, value: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderArgs']]]):
        pulumi.set(self, "providers", value)

    @property
    @pulumi.getter
    def baseline(self) -> Optional[pulumi.Input['VerificationTemplateMetricBaselineArgs']]:
        """
        Baseline Object.
        """
        return pulumi.get(self, "baseline")

    @baseline.setter
    def baseline(self, value: Optional[pulumi.Input['VerificationTemplateMetricBaselineArgs']]):
        pulumi.set(self, "baseline", value)

    @property
    @pulumi.getter(name="consecutiveErrorLimit")
    def consecutive_error_limit(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The maximum number of times the measurement is allowed to error in succession, before the metric is considered error.Default is 4.When choosing `Jenkins` as the provider, there is no need to send this variable.
        """
        return pulumi.get(self, "consecutive_error_limit")

    @consecutive_error_limit.setter
    def consecutive_error_limit(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "consecutive_error_limit", value)

    @property
    @pulumi.getter
    def count(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The number of times to run the measurement. If both interval and count are omitted, the effective count is 1. If only interval is specified, metric runs indefinitely. If count > 1, interval must be specified. When choosing `Jenkins` as the provider, there is no need to send this variable.
        """
        return pulumi.get(self, "count")

    @count.setter
    def count(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "count", value)

    @property
    @pulumi.getter(name="dryRun")
    def dry_run(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Defines whether the metric should have an impact on the result of the rollout.
        """
        return pulumi.get(self, "dry_run")

    @dry_run.setter
    def dry_run(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "dry_run", value)

    @property
    @pulumi.getter(name="failureCondition")
    def failure_condition(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        An expression which determines if a measurement is considered failed.If failureCondition is set, then successCondition is not allowed. When choosing Jenkins as the provider, there is no need to send this variable.
        """
        return pulumi.get(self, "failure_condition")

    @failure_condition.setter
    def failure_condition(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "failure_condition", value)

    @property
    @pulumi.getter(name="failureLimit")
    def failure_limit(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The maximum number of times the measurement is allowed to fail, before the entire metric is considered failed.Default is 0. When choosing `Jenkins` as the provider, there is no need to send this variable.
        """
        return pulumi.get(self, "failure_limit")

    @failure_limit.setter
    def failure_limit(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "failure_limit", value)

    @property
    @pulumi.getter(name="initialDelay")
    def initial_delay(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        How long to wait before starting this metric measurements. When choosing Jenkins as the provider, there is no need to send this variable.
        """
        return pulumi.get(self, "initial_delay")

    @initial_delay.setter
    def initial_delay(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "initial_delay", value)

    @property
    @pulumi.getter
    def interval(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        Defines an interval string (30s, 5m, 1h) between each verification measurements. If omitted, will perform a single measurement.When choosing Jenkins as the provider, there is no need to send this variable.
        """
        return pulumi.get(self, "interval")

    @interval.setter
    def interval(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "interval", value)

    @property
    @pulumi.getter(name="successCondition")
    def success_condition(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        An expression which determines if a measurement is considered successful. The keyword `result` is a variable reference to the value of measurement. Results can be both structured data or primitive. If successCondition is set, then failureCondition is not allowed. When choosing `Jenkins` as the provider, there is no need to send this variable.
        """
        return pulumi.get(self, "success_condition")

    @success_condition.setter
    def success_condition(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "success_condition", value)


if not MYPY:
    class VerificationTemplateMetricBaselineArgsDict(TypedDict):
        baseline_providers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderArgsDict']]]
        """
        The name of the monitoring tool chosen for the metric.
        """
        threshold: pulumi.Input[builtins.str]
        """
        A mathematical expression needed for the comparison. Enum: "<" ">" "<=" ">=" "=" "range"
        """
        max_range: NotRequired[pulumi.Input[builtins.int]]
        """
        Number in percent we allow the new version’s data result to be under baseline data result.
        """
        min_range: NotRequired[pulumi.Input[builtins.int]]
        """
        Number in percent we allow the new version’s data result to be under baseline data result.*
        """
elif False:
    VerificationTemplateMetricBaselineArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricBaselineArgs:
    def __init__(__self__, *,
                 baseline_providers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderArgs']]],
                 threshold: pulumi.Input[builtins.str],
                 max_range: Optional[pulumi.Input[builtins.int]] = None,
                 min_range: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderArgs']]] baseline_providers: The name of the monitoring tool chosen for the metric.
        :param pulumi.Input[builtins.str] threshold: A mathematical expression needed for the comparison. Enum: "<" ">" "<=" ">=" "=" "range"
        :param pulumi.Input[builtins.int] max_range: Number in percent we allow the new version’s data result to be under baseline data result.
        :param pulumi.Input[builtins.int] min_range: Number in percent we allow the new version’s data result to be under baseline data result.*
        """
        pulumi.set(__self__, "baseline_providers", baseline_providers)
        pulumi.set(__self__, "threshold", threshold)
        if max_range is not None:
            pulumi.set(__self__, "max_range", max_range)
        if min_range is not None:
            pulumi.set(__self__, "min_range", min_range)

    @property
    @pulumi.getter(name="baselineProviders")
    def baseline_providers(self) -> pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderArgs']]]:
        """
        The name of the monitoring tool chosen for the metric.
        """
        return pulumi.get(self, "baseline_providers")

    @baseline_providers.setter
    def baseline_providers(self, value: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderArgs']]]):
        pulumi.set(self, "baseline_providers", value)

    @property
    @pulumi.getter
    def threshold(self) -> pulumi.Input[builtins.str]:
        """
        A mathematical expression needed for the comparison. Enum: "<" ">" "<=" ">=" "=" "range"
        """
        return pulumi.get(self, "threshold")

    @threshold.setter
    def threshold(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "threshold", value)

    @property
    @pulumi.getter(name="maxRange")
    def max_range(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Number in percent we allow the new version’s data result to be under baseline data result.
        """
        return pulumi.get(self, "max_range")

    @max_range.setter
    def max_range(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "max_range", value)

    @property
    @pulumi.getter(name="minRange")
    def min_range(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Number in percent we allow the new version’s data result to be under baseline data result.*
        """
        return pulumi.get(self, "min_range")

    @min_range.setter
    def min_range(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "min_range", value)


if not MYPY:
    class VerificationTemplateMetricBaselineBaselineProviderArgsDict(TypedDict):
        datadog: NotRequired[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderDatadogArgsDict']]
        """
        The datadog provider.
        """
        new_relic: NotRequired[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderNewRelicArgsDict']]
        """
        The New Relic provider.
        """
        prometheus: NotRequired[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderPrometheusArgsDict']]
        """
        The Prometheus provider.
        """
elif False:
    VerificationTemplateMetricBaselineBaselineProviderArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricBaselineBaselineProviderArgs:
    def __init__(__self__, *,
                 datadog: Optional[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderDatadogArgs']] = None,
                 new_relic: Optional[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderNewRelicArgs']] = None,
                 prometheus: Optional[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderPrometheusArgs']] = None):
        """
        :param pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderDatadogArgs'] datadog: The datadog provider.
        :param pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderNewRelicArgs'] new_relic: The New Relic provider.
        :param pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderPrometheusArgs'] prometheus: The Prometheus provider.
        """
        if datadog is not None:
            pulumi.set(__self__, "datadog", datadog)
        if new_relic is not None:
            pulumi.set(__self__, "new_relic", new_relic)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @property
    @pulumi.getter
    def datadog(self) -> Optional[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderDatadogArgs']]:
        """
        The datadog provider.
        """
        return pulumi.get(self, "datadog")

    @datadog.setter
    def datadog(self, value: Optional[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderDatadogArgs']]):
        pulumi.set(self, "datadog", value)

    @property
    @pulumi.getter(name="newRelic")
    def new_relic(self) -> Optional[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderNewRelicArgs']]:
        """
        The New Relic provider.
        """
        return pulumi.get(self, "new_relic")

    @new_relic.setter
    def new_relic(self, value: Optional[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderNewRelicArgs']]):
        pulumi.set(self, "new_relic", value)

    @property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderPrometheusArgs']]:
        """
        The Prometheus provider.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderPrometheusArgs']]):
        pulumi.set(self, "prometheus", value)


if not MYPY:
    class VerificationTemplateMetricBaselineBaselineProviderDatadogArgsDict(TypedDict):
        datadog_query: pulumi.Input[builtins.str]
        """
        A request for information retrieved from Datadog.
        """
        duration: NotRequired[pulumi.Input[builtins.str]]
        """
        The window of time we are looking at in DataDog.
        """
elif False:
    VerificationTemplateMetricBaselineBaselineProviderDatadogArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricBaselineBaselineProviderDatadogArgs:
    def __init__(__self__, *,
                 datadog_query: pulumi.Input[builtins.str],
                 duration: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] datadog_query: A request for information retrieved from Datadog.
        :param pulumi.Input[builtins.str] duration: The window of time we are looking at in DataDog.
        """
        pulumi.set(__self__, "datadog_query", datadog_query)
        if duration is not None:
            pulumi.set(__self__, "duration", duration)

    @property
    @pulumi.getter(name="datadogQuery")
    def datadog_query(self) -> pulumi.Input[builtins.str]:
        """
        A request for information retrieved from Datadog.
        """
        return pulumi.get(self, "datadog_query")

    @datadog_query.setter
    def datadog_query(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "datadog_query", value)

    @property
    @pulumi.getter
    def duration(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The window of time we are looking at in DataDog.
        """
        return pulumi.get(self, "duration")

    @duration.setter
    def duration(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "duration", value)


if not MYPY:
    class VerificationTemplateMetricBaselineBaselineProviderNewRelicArgsDict(TypedDict):
        new_relic_query: pulumi.Input[builtins.str]
        """
        A raw newrelic NRQL query to perform.
        """
        profile: NotRequired[pulumi.Input[builtins.str]]
        """
        The name of the secret holding NR account configuration.
        """
elif False:
    VerificationTemplateMetricBaselineBaselineProviderNewRelicArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricBaselineBaselineProviderNewRelicArgs:
    def __init__(__self__, *,
                 new_relic_query: pulumi.Input[builtins.str],
                 profile: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] new_relic_query: A raw newrelic NRQL query to perform.
        :param pulumi.Input[builtins.str] profile: The name of the secret holding NR account configuration.
        """
        pulumi.set(__self__, "new_relic_query", new_relic_query)
        if profile is not None:
            pulumi.set(__self__, "profile", profile)

    @property
    @pulumi.getter(name="newRelicQuery")
    def new_relic_query(self) -> pulumi.Input[builtins.str]:
        """
        A raw newrelic NRQL query to perform.
        """
        return pulumi.get(self, "new_relic_query")

    @new_relic_query.setter
    def new_relic_query(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "new_relic_query", value)

    @property
    @pulumi.getter
    def profile(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The name of the secret holding NR account configuration.
        """
        return pulumi.get(self, "profile")

    @profile.setter
    def profile(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "profile", value)


if not MYPY:
    class VerificationTemplateMetricBaselineBaselineProviderPrometheusArgsDict(TypedDict):
        prometheus_query: pulumi.Input[builtins.str]
        """
        A request for information retrieved from Prometheus.
        """
elif False:
    VerificationTemplateMetricBaselineBaselineProviderPrometheusArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricBaselineBaselineProviderPrometheusArgs:
    def __init__(__self__, *,
                 prometheus_query: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] prometheus_query: A request for information retrieved from Prometheus.
        """
        pulumi.set(__self__, "prometheus_query", prometheus_query)

    @property
    @pulumi.getter(name="prometheusQuery")
    def prometheus_query(self) -> pulumi.Input[builtins.str]:
        """
        A request for information retrieved from Prometheus.
        """
        return pulumi.get(self, "prometheus_query")

    @prometheus_query.setter
    def prometheus_query(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "prometheus_query", value)


if not MYPY:
    class VerificationTemplateMetricProviderArgsDict(TypedDict):
        cloud_watch: NotRequired[pulumi.Input['VerificationTemplateMetricProviderCloudWatchArgsDict']]
        """
        The CloudWatch provider.
        """
        datadog: NotRequired[pulumi.Input['VerificationTemplateMetricProviderDatadogArgsDict']]
        """
        The datadog provider.
        """
        jenkins: NotRequired[pulumi.Input['VerificationTemplateMetricProviderJenkinsArgsDict']]
        """
        The Jenkins provider. Default is "{$}"
        """
        job: NotRequired[pulumi.Input['VerificationTemplateMetricProviderJobArgsDict']]
        """
        The Job provider.
        """
        new_relic: NotRequired[pulumi.Input['VerificationTemplateMetricProviderNewRelicArgsDict']]
        """
        The New Relic provider.
        """
        prometheus: NotRequired[pulumi.Input['VerificationTemplateMetricProviderPrometheusArgsDict']]
        """
        The Prometheus provider.
        """
        web: NotRequired[pulumi.Input['VerificationTemplateMetricProviderWebArgsDict']]
        """
        The Web provider.
        """
elif False:
    VerificationTemplateMetricProviderArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderArgs:
    def __init__(__self__, *,
                 cloud_watch: Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchArgs']] = None,
                 datadog: Optional[pulumi.Input['VerificationTemplateMetricProviderDatadogArgs']] = None,
                 jenkins: Optional[pulumi.Input['VerificationTemplateMetricProviderJenkinsArgs']] = None,
                 job: Optional[pulumi.Input['VerificationTemplateMetricProviderJobArgs']] = None,
                 new_relic: Optional[pulumi.Input['VerificationTemplateMetricProviderNewRelicArgs']] = None,
                 prometheus: Optional[pulumi.Input['VerificationTemplateMetricProviderPrometheusArgs']] = None,
                 web: Optional[pulumi.Input['VerificationTemplateMetricProviderWebArgs']] = None):
        """
        :param pulumi.Input['VerificationTemplateMetricProviderCloudWatchArgs'] cloud_watch: The CloudWatch provider.
        :param pulumi.Input['VerificationTemplateMetricProviderDatadogArgs'] datadog: The datadog provider.
        :param pulumi.Input['VerificationTemplateMetricProviderJenkinsArgs'] jenkins: The Jenkins provider. Default is "{$}"
        :param pulumi.Input['VerificationTemplateMetricProviderJobArgs'] job: The Job provider.
        :param pulumi.Input['VerificationTemplateMetricProviderNewRelicArgs'] new_relic: The New Relic provider.
        :param pulumi.Input['VerificationTemplateMetricProviderPrometheusArgs'] prometheus: The Prometheus provider.
        :param pulumi.Input['VerificationTemplateMetricProviderWebArgs'] web: The Web provider.
        """
        if cloud_watch is not None:
            pulumi.set(__self__, "cloud_watch", cloud_watch)
        if datadog is not None:
            pulumi.set(__self__, "datadog", datadog)
        if jenkins is not None:
            pulumi.set(__self__, "jenkins", jenkins)
        if job is not None:
            pulumi.set(__self__, "job", job)
        if new_relic is not None:
            pulumi.set(__self__, "new_relic", new_relic)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)
        if web is not None:
            pulumi.set(__self__, "web", web)

    @property
    @pulumi.getter(name="cloudWatch")
    def cloud_watch(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchArgs']]:
        """
        The CloudWatch provider.
        """
        return pulumi.get(self, "cloud_watch")

    @cloud_watch.setter
    def cloud_watch(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchArgs']]):
        pulumi.set(self, "cloud_watch", value)

    @property
    @pulumi.getter
    def datadog(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderDatadogArgs']]:
        """
        The datadog provider.
        """
        return pulumi.get(self, "datadog")

    @datadog.setter
    def datadog(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderDatadogArgs']]):
        pulumi.set(self, "datadog", value)

    @property
    @pulumi.getter
    def jenkins(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderJenkinsArgs']]:
        """
        The Jenkins provider. Default is "{$}"
        """
        return pulumi.get(self, "jenkins")

    @jenkins.setter
    def jenkins(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderJenkinsArgs']]):
        pulumi.set(self, "jenkins", value)

    @property
    @pulumi.getter
    def job(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderJobArgs']]:
        """
        The Job provider.
        """
        return pulumi.get(self, "job")

    @job.setter
    def job(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderJobArgs']]):
        pulumi.set(self, "job", value)

    @property
    @pulumi.getter(name="newRelic")
    def new_relic(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderNewRelicArgs']]:
        """
        The New Relic provider.
        """
        return pulumi.get(self, "new_relic")

    @new_relic.setter
    def new_relic(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderNewRelicArgs']]):
        pulumi.set(self, "new_relic", value)

    @property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderPrometheusArgs']]:
        """
        The Prometheus provider.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderPrometheusArgs']]):
        pulumi.set(self, "prometheus", value)

    @property
    @pulumi.getter
    def web(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderWebArgs']]:
        """
        The Web provider.
        """
        return pulumi.get(self, "web")

    @web.setter
    def web(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderWebArgs']]):
        pulumi.set(self, "web", value)


if not MYPY:
    class VerificationTemplateMetricProviderCloudWatchArgsDict(TypedDict):
        metric_data_queries: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgsDict']]]
        """
        The metric queries to be returned. A single MetricData call can include as many as 500 MetricDataQuery structures. Each of these structures can specify either a metric to retrieve, a Metrics Insights query, or a math expression to perform on retrieved data.
        """
        duration: NotRequired[pulumi.Input[builtins.str]]
        """
        The window of time we are looking at in CloudWatch.
        """
elif False:
    VerificationTemplateMetricProviderCloudWatchArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderCloudWatchArgs:
    def __init__(__self__, *,
                 metric_data_queries: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs']]],
                 duration: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs']]] metric_data_queries: The metric queries to be returned. A single MetricData call can include as many as 500 MetricDataQuery structures. Each of these structures can specify either a metric to retrieve, a Metrics Insights query, or a math expression to perform on retrieved data.
        :param pulumi.Input[builtins.str] duration: The window of time we are looking at in CloudWatch.
        """
        pulumi.set(__self__, "metric_data_queries", metric_data_queries)
        if duration is not None:
            pulumi.set(__self__, "duration", duration)

    @property
    @pulumi.getter(name="metricDataQueries")
    def metric_data_queries(self) -> pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs']]]:
        """
        The metric queries to be returned. A single MetricData call can include as many as 500 MetricDataQuery structures. Each of these structures can specify either a metric to retrieve, a Metrics Insights query, or a math expression to perform on retrieved data.
        """
        return pulumi.get(self, "metric_data_queries")

    @metric_data_queries.setter
    def metric_data_queries(self, value: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs']]]):
        pulumi.set(self, "metric_data_queries", value)

    @property
    @pulumi.getter
    def duration(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The window of time we are looking at in CloudWatch.
        """
        return pulumi.get(self, "duration")

    @duration.setter
    def duration(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "duration", value)


if not MYPY:
    class VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgsDict(TypedDict):
        id: pulumi.Input[builtins.str]
        """
        The response ID. Must be unique and not null. This object can contain characters, letters, numbers and underscore. The first letter must be a lowercase letter.
        """
        expression: NotRequired[pulumi.Input[builtins.str]]
        """
        This field can contain either a Metrics Insights query, or a metric math expression to be performed on the returned data. Within one metricdataquery object, you must specify either expression or metricstat but not both.
        """
        label: NotRequired[pulumi.Input[builtins.str]]
        """
        A human-readable label for this metric or expression. If the metric or expression is shown in a CloudWatch dashboard widget, the label is shown
        """
        metric_stat: NotRequired[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgsDict']]
        """
        The metric to be returned, along with statistics, period, and units. Use this parameter only if this object is retrieving a metric and not performing a math expression on returned data.Within one metricdataquery object, you must specify either expression or metricstat but not both.
        """
        period: NotRequired[pulumi.Input[builtins.int]]
        """
        The granularity, in seconds, of the returned data points.
        """
        return_data: NotRequired[pulumi.Input[builtins.bool]]
        """
        This option indicates whether to return the timestamps and raw data values of this metric. If you are performing this call just to do math expressions and do not also need the raw data returned, you can specify `false`. If you omit this, the default of `true` is used.
        """
elif False:
    VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[builtins.str],
                 expression: Optional[pulumi.Input[builtins.str]] = None,
                 label: Optional[pulumi.Input[builtins.str]] = None,
                 metric_stat: Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs']] = None,
                 period: Optional[pulumi.Input[builtins.int]] = None,
                 return_data: Optional[pulumi.Input[builtins.bool]] = None):
        """
        :param pulumi.Input[builtins.str] id: The response ID. Must be unique and not null. This object can contain characters, letters, numbers and underscore. The first letter must be a lowercase letter.
        :param pulumi.Input[builtins.str] expression: This field can contain either a Metrics Insights query, or a metric math expression to be performed on the returned data. Within one metricdataquery object, you must specify either expression or metricstat but not both.
        :param pulumi.Input[builtins.str] label: A human-readable label for this metric or expression. If the metric or expression is shown in a CloudWatch dashboard widget, the label is shown
        :param pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs'] metric_stat: The metric to be returned, along with statistics, period, and units. Use this parameter only if this object is retrieving a metric and not performing a math expression on returned data.Within one metricdataquery object, you must specify either expression or metricstat but not both.
        :param pulumi.Input[builtins.int] period: The granularity, in seconds, of the returned data points.
        :param pulumi.Input[builtins.bool] return_data: This option indicates whether to return the timestamps and raw data values of this metric. If you are performing this call just to do math expressions and do not also need the raw data returned, you can specify `false`. If you omit this, the default of `true` is used.
        """
        pulumi.set(__self__, "id", id)
        if expression is not None:
            pulumi.set(__self__, "expression", expression)
        if label is not None:
            pulumi.set(__self__, "label", label)
        if metric_stat is not None:
            pulumi.set(__self__, "metric_stat", metric_stat)
        if period is not None:
            pulumi.set(__self__, "period", period)
        if return_data is not None:
            pulumi.set(__self__, "return_data", return_data)

    @property
    @pulumi.getter
    def id(self) -> pulumi.Input[builtins.str]:
        """
        The response ID. Must be unique and not null. This object can contain characters, letters, numbers and underscore. The first letter must be a lowercase letter.
        """
        return pulumi.get(self, "id")

    @id.setter
    def id(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "id", value)

    @property
    @pulumi.getter
    def expression(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        This field can contain either a Metrics Insights query, or a metric math expression to be performed on the returned data. Within one metricdataquery object, you must specify either expression or metricstat but not both.
        """
        return pulumi.get(self, "expression")

    @expression.setter
    def expression(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "expression", value)

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        A human-readable label for this metric or expression. If the metric or expression is shown in a CloudWatch dashboard widget, the label is shown
        """
        return pulumi.get(self, "label")

    @label.setter
    def label(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "label", value)

    @property
    @pulumi.getter(name="metricStat")
    def metric_stat(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs']]:
        """
        The metric to be returned, along with statistics, period, and units. Use this parameter only if this object is retrieving a metric and not performing a math expression on returned data.Within one metricdataquery object, you must specify either expression or metricstat but not both.
        """
        return pulumi.get(self, "metric_stat")

    @metric_stat.setter
    def metric_stat(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs']]):
        pulumi.set(self, "metric_stat", value)

    @property
    @pulumi.getter
    def period(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The granularity, in seconds, of the returned data points.
        """
        return pulumi.get(self, "period")

    @period.setter
    def period(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "period", value)

    @property
    @pulumi.getter(name="returnData")
    def return_data(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        This option indicates whether to return the timestamps and raw data values of this metric. If you are performing this call just to do math expressions and do not also need the raw data returned, you can specify `false`. If you omit this, the default of `true` is used.
        """
        return pulumi.get(self, "return_data")

    @return_data.setter
    def return_data(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "return_data", value)


if not MYPY:
    class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgsDict(TypedDict):
        metric: NotRequired[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgsDict']]
        """
        The metric to return, including the metric name, namespace, and dimensions.
        """
        metric_period: NotRequired[pulumi.Input[builtins.int]]
        """
        The granularity, in seconds, of the returned data points.
        """
        stat: NotRequired[pulumi.Input[builtins.str]]
        """
        The statistic to return. It can include any CloudWatch statistic or extended statistic.
        """
        unit: NotRequired[pulumi.Input[builtins.str]]
        """
        This defines what unit you want to use when storing the metric.  Enum: `"Seconds" "Microseconds" "Milliseconds" "Bytes" "Kilobytes" "Megabytes" "Gigabytes" "Terabytes" "Bits" "Kilobits" "Megabits" "Gigabits" "Terabits" "Percent" "Count" "Bytes/Second" "Kilobytes/Second" "Megabytes/Second" "Gigabytes/Second" "Terabytes/Second" "Bits/Second" "Kilobits/Second" "Megabits/Second" "Gigabits/Second" "Terabits/Second" "Count/Second" "None"`
        """
elif False:
    VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs:
    def __init__(__self__, *,
                 metric: Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs']] = None,
                 metric_period: Optional[pulumi.Input[builtins.int]] = None,
                 stat: Optional[pulumi.Input[builtins.str]] = None,
                 unit: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs'] metric: The metric to return, including the metric name, namespace, and dimensions.
        :param pulumi.Input[builtins.int] metric_period: The granularity, in seconds, of the returned data points.
        :param pulumi.Input[builtins.str] stat: The statistic to return. It can include any CloudWatch statistic or extended statistic.
        :param pulumi.Input[builtins.str] unit: This defines what unit you want to use when storing the metric.  Enum: `"Seconds" "Microseconds" "Milliseconds" "Bytes" "Kilobytes" "Megabytes" "Gigabytes" "Terabytes" "Bits" "Kilobits" "Megabits" "Gigabits" "Terabits" "Percent" "Count" "Bytes/Second" "Kilobytes/Second" "Megabytes/Second" "Gigabytes/Second" "Terabytes/Second" "Bits/Second" "Kilobits/Second" "Megabits/Second" "Gigabits/Second" "Terabits/Second" "Count/Second" "None"`
        """
        if metric is not None:
            pulumi.set(__self__, "metric", metric)
        if metric_period is not None:
            pulumi.set(__self__, "metric_period", metric_period)
        if stat is not None:
            pulumi.set(__self__, "stat", stat)
        if unit is not None:
            pulumi.set(__self__, "unit", unit)

    @property
    @pulumi.getter
    def metric(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs']]:
        """
        The metric to return, including the metric name, namespace, and dimensions.
        """
        return pulumi.get(self, "metric")

    @metric.setter
    def metric(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs']]):
        pulumi.set(self, "metric", value)

    @property
    @pulumi.getter(name="metricPeriod")
    def metric_period(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The granularity, in seconds, of the returned data points.
        """
        return pulumi.get(self, "metric_period")

    @metric_period.setter
    def metric_period(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "metric_period", value)

    @property
    @pulumi.getter
    def stat(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The statistic to return. It can include any CloudWatch statistic or extended statistic.
        """
        return pulumi.get(self, "stat")

    @stat.setter
    def stat(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "stat", value)

    @property
    @pulumi.getter
    def unit(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        This defines what unit you want to use when storing the metric.  Enum: `"Seconds" "Microseconds" "Milliseconds" "Bytes" "Kilobytes" "Megabytes" "Gigabytes" "Terabytes" "Bits" "Kilobits" "Megabits" "Gigabits" "Terabits" "Percent" "Count" "Bytes/Second" "Kilobytes/Second" "Megabytes/Second" "Gigabytes/Second" "Terabytes/Second" "Bits/Second" "Kilobits/Second" "Megabits/Second" "Gigabits/Second" "Terabits/Second" "Count/Second" "None"`
        """
        return pulumi.get(self, "unit")

    @unit.setter
    def unit(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "unit", value)


if not MYPY:
    class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgsDict(TypedDict):
        metric_name: pulumi.Input[builtins.str]
        """
        The name of the metric.
        """
        dimensions: NotRequired[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgsDict']]]]
        """
        A dimension is a name/value pair that is part of the identity of a metric.You can assign upto 30 dimensions to a metric
        """
        namespace: NotRequired[pulumi.Input[builtins.str]]
        """
        The namespace of the metric.
        """
elif False:
    VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs:
    def __init__(__self__, *,
                 metric_name: pulumi.Input[builtins.str],
                 dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs']]]] = None,
                 namespace: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] metric_name: The name of the metric.
        :param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs']]] dimensions: A dimension is a name/value pair that is part of the identity of a metric.You can assign upto 30 dimensions to a metric
        :param pulumi.Input[builtins.str] namespace: The namespace of the metric.
        """
        pulumi.set(__self__, "metric_name", metric_name)
        if dimensions is not None:
            pulumi.set(__self__, "dimensions", dimensions)
        if namespace is not None:
            pulumi.set(__self__, "namespace", namespace)

    @property
    @pulumi.getter(name="metricName")
    def metric_name(self) -> pulumi.Input[builtins.str]:
        """
        The name of the metric.
        """
        return pulumi.get(self, "metric_name")

    @metric_name.setter
    def metric_name(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "metric_name", value)

    @property
    @pulumi.getter
    def dimensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs']]]]:
        """
        A dimension is a name/value pair that is part of the identity of a metric.You can assign upto 30 dimensions to a metric
        """
        return pulumi.get(self, "dimensions")

    @dimensions.setter
    def dimensions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs']]]]):
        pulumi.set(self, "dimensions", value)

    @property
    @pulumi.getter
    def namespace(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The namespace of the metric.
        """
        return pulumi.get(self, "namespace")

    @namespace.setter
    def namespace(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "namespace", value)


if not MYPY:
    class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgsDict(TypedDict):
        dimension_name: pulumi.Input[builtins.str]
        """
        The name of the dimensions. These values must contain only ASCII characters and must include at least one non-whitespace characte
        """
        dimension_value: pulumi.Input[builtins.str]
        """
        The value of the dimensions.These values must contain only ASCII characters and must include at least one non-whitespace characte
        """
elif False:
    VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs:
    def __init__(__self__, *,
                 dimension_name: pulumi.Input[builtins.str],
                 dimension_value: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] dimension_name: The name of the dimensions. These values must contain only ASCII characters and must include at least one non-whitespace characte
        :param pulumi.Input[builtins.str] dimension_value: The value of the dimensions.These values must contain only ASCII characters and must include at least one non-whitespace characte
        """
        pulumi.set(__self__, "dimension_name", dimension_name)
        pulumi.set(__self__, "dimension_value", dimension_value)

    @property
    @pulumi.getter(name="dimensionName")
    def dimension_name(self) -> pulumi.Input[builtins.str]:
        """
        The name of the dimensions. These values must contain only ASCII characters and must include at least one non-whitespace characte
        """
        return pulumi.get(self, "dimension_name")

    @dimension_name.setter
    def dimension_name(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "dimension_name", value)

    @property
    @pulumi.getter(name="dimensionValue")
    def dimension_value(self) -> pulumi.Input[builtins.str]:
        """
        The value of the dimensions.These values must contain only ASCII characters and must include at least one non-whitespace characte
        """
        return pulumi.get(self, "dimension_value")

    @dimension_value.setter
    def dimension_value(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "dimension_value", value)


if not MYPY:
    class VerificationTemplateMetricProviderDatadogArgsDict(TypedDict):
        datadog_query: NotRequired[pulumi.Input[builtins.str]]
        """
        A request for information retrieved from Datadog.
        """
        duration: NotRequired[pulumi.Input[builtins.str]]
        """
        The window of time we are looking at in DataDog.
        """
elif False:
    VerificationTemplateMetricProviderDatadogArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderDatadogArgs:
    def __init__(__self__, *,
                 datadog_query: Optional[pulumi.Input[builtins.str]] = None,
                 duration: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] datadog_query: A request for information retrieved from Datadog.
        :param pulumi.Input[builtins.str] duration: The window of time we are looking at in DataDog.
        """
        if datadog_query is not None:
            pulumi.set(__self__, "datadog_query", datadog_query)
        if duration is not None:
            pulumi.set(__self__, "duration", duration)

    @property
    @pulumi.getter(name="datadogQuery")
    def datadog_query(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        A request for information retrieved from Datadog.
        """
        return pulumi.get(self, "datadog_query")

    @datadog_query.setter
    def datadog_query(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "datadog_query", value)

    @property
    @pulumi.getter
    def duration(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The window of time we are looking at in DataDog.
        """
        return pulumi.get(self, "duration")

    @duration.setter
    def duration(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "duration", value)


if not MYPY:
    class VerificationTemplateMetricProviderJenkinsArgsDict(TypedDict):
        jenkins_interval: pulumi.Input[builtins.str]
        """
        The interval time to poll status.
        """
        pipeline_name: pulumi.Input[builtins.str]
        """
        The Jenkins pipeline name.
        """
        timeout: pulumi.Input[builtins.str]
        """
        The total jenkins timeout.
        """
        jenkins_parameters: NotRequired[pulumi.Input['VerificationTemplateMetricProviderJenkinsJenkinsParametersArgsDict']]
        """
        List of parameters.
        """
        tls_verification: NotRequired[pulumi.Input[builtins.bool]]
        """
        Host TLS verification.
        """
elif False:
    VerificationTemplateMetricProviderJenkinsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderJenkinsArgs:
    def __init__(__self__, *,
                 jenkins_interval: pulumi.Input[builtins.str],
                 pipeline_name: pulumi.Input[builtins.str],
                 timeout: pulumi.Input[builtins.str],
                 jenkins_parameters: Optional[pulumi.Input['VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs']] = None,
                 tls_verification: Optional[pulumi.Input[builtins.bool]] = None):
        """
        :param pulumi.Input[builtins.str] jenkins_interval: The interval time to poll status.
        :param pulumi.Input[builtins.str] pipeline_name: The Jenkins pipeline name.
        :param pulumi.Input[builtins.str] timeout: The total jenkins timeout.
        :param pulumi.Input['VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs'] jenkins_parameters: List of parameters.
        :param pulumi.Input[builtins.bool] tls_verification: Host TLS verification.
        """
        pulumi.set(__self__, "jenkins_interval", jenkins_interval)
        pulumi.set(__self__, "pipeline_name", pipeline_name)
        pulumi.set(__self__, "timeout", timeout)
        if jenkins_parameters is not None:
            pulumi.set(__self__, "jenkins_parameters", jenkins_parameters)
        if tls_verification is not None:
            pulumi.set(__self__, "tls_verification", tls_verification)

    @property
    @pulumi.getter(name="jenkinsInterval")
    def jenkins_interval(self) -> pulumi.Input[builtins.str]:
        """
        The interval time to poll status.
        """
        return pulumi.get(self, "jenkins_interval")

    @jenkins_interval.setter
    def jenkins_interval(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "jenkins_interval", value)

    @property
    @pulumi.getter(name="pipelineName")
    def pipeline_name(self) -> pulumi.Input[builtins.str]:
        """
        The Jenkins pipeline name.
        """
        return pulumi.get(self, "pipeline_name")

    @pipeline_name.setter
    def pipeline_name(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "pipeline_name", value)

    @property
    @pulumi.getter
    def timeout(self) -> pulumi.Input[builtins.str]:
        """
        The total jenkins timeout.
        """
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "timeout", value)

    @property
    @pulumi.getter(name="jenkinsParameters")
    def jenkins_parameters(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs']]:
        """
        List of parameters.
        """
        return pulumi.get(self, "jenkins_parameters")

    @jenkins_parameters.setter
    def jenkins_parameters(self, value: Optional[pulumi.Input['VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs']]):
        pulumi.set(self, "jenkins_parameters", value)

    @property
    @pulumi.getter(name="tlsVerification")
    def tls_verification(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Host TLS verification.
        """
        return pulumi.get(self, "tls_verification")

    @tls_verification.setter
    def tls_verification(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "tls_verification", value)


if not MYPY:
    class VerificationTemplateMetricProviderJenkinsJenkinsParametersArgsDict(TypedDict):
        parameter_key: pulumi.Input[builtins.str]
        """
        Key of an argument.
        """
        parameter_value: pulumi.Input[builtins.str]
        """
        Value of an argument.
        """
elif False:
    VerificationTemplateMetricProviderJenkinsJenkinsParametersArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs:
    def __init__(__self__, *,
                 parameter_key: pulumi.Input[builtins.str],
                 parameter_value: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] parameter_key: Key of an argument.
        :param pulumi.Input[builtins.str] parameter_value: Value of an argument.
        """
        pulumi.set(__self__, "parameter_key", parameter_key)
        pulumi.set(__self__, "parameter_value", parameter_value)

    @property
    @pulumi.getter(name="parameterKey")
    def parameter_key(self) -> pulumi.Input[builtins.str]:
        """
        Key of an argument.
        """
        return pulumi.get(self, "parameter_key")

    @parameter_key.setter
    def parameter_key(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "parameter_key", value)

    @property
    @pulumi.getter(name="parameterValue")
    def parameter_value(self) -> pulumi.Input[builtins.str]:
        """
        Value of an argument.
        """
        return pulumi.get(self, "parameter_value")

    @parameter_value.setter
    def parameter_value(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "parameter_value", value)


if not MYPY:
    class VerificationTemplateMetricProviderJobArgsDict(TypedDict):
        specs: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecArgsDict']]]
        """
        The job spec require to run the metric.
        """
elif False:
    VerificationTemplateMetricProviderJobArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderJobArgs:
    def __init__(__self__, *,
                 specs: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecArgs']]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecArgs']]] specs: The job spec require to run the metric.
        """
        pulumi.set(__self__, "specs", specs)

    @property
    @pulumi.getter
    def specs(self) -> pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecArgs']]]:
        """
        The job spec require to run the metric.
        """
        return pulumi.get(self, "specs")

    @specs.setter
    def specs(self, value: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecArgs']]]):
        pulumi.set(self, "specs", value)


if not MYPY:
    class VerificationTemplateMetricProviderJobSpecArgsDict(TypedDict):
        job_templates: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateArgsDict']]]
        """
        Describes the pod that will be created when executing a job.
        """
        backoff_limit: NotRequired[pulumi.Input[builtins.int]]
        """
        Specifies the number of retries before marking this job failed.
        """
elif False:
    VerificationTemplateMetricProviderJobSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderJobSpecArgs:
    def __init__(__self__, *,
                 job_templates: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateArgs']]],
                 backoff_limit: Optional[pulumi.Input[builtins.int]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateArgs']]] job_templates: Describes the pod that will be created when executing a job.
        :param pulumi.Input[builtins.int] backoff_limit: Specifies the number of retries before marking this job failed.
        """
        pulumi.set(__self__, "job_templates", job_templates)
        if backoff_limit is not None:
            pulumi.set(__self__, "backoff_limit", backoff_limit)

    @property
    @pulumi.getter(name="jobTemplates")
    def job_templates(self) -> pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateArgs']]]:
        """
        Describes the pod that will be created when executing a job.
        """
        return pulumi.get(self, "job_templates")

    @job_templates.setter
    def job_templates(self, value: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateArgs']]]):
        pulumi.set(self, "job_templates", value)

    @property
    @pulumi.getter(name="backoffLimit")
    def backoff_limit(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        Specifies the number of retries before marking this job failed.
        """
        return pulumi.get(self, "backoff_limit")

    @backoff_limit.setter
    def backoff_limit(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "backoff_limit", value)


if not MYPY:
    class VerificationTemplateMetricProviderJobSpecJobTemplateArgsDict(TypedDict):
        template_specs: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgsDict']]]
        """
        Specification of the desired behavior of the pod.
        """
elif False:
    VerificationTemplateMetricProviderJobSpecJobTemplateArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderJobSpecJobTemplateArgs:
    def __init__(__self__, *,
                 template_specs: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgs']]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgs']]] template_specs: Specification of the desired behavior of the pod.
        """
        pulumi.set(__self__, "template_specs", template_specs)

    @property
    @pulumi.getter(name="templateSpecs")
    def template_specs(self) -> pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgs']]]:
        """
        Specification of the desired behavior of the pod.
        """
        return pulumi.get(self, "template_specs")

    @template_specs.setter
    def template_specs(self, value: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgs']]]):
        pulumi.set(self, "template_specs", value)


if not MYPY:
    class VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgsDict(TypedDict):
        containers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgsDict']]]
        """
        A list of containers belonging to the pod.
        """
        restart_policy: pulumi.Input[builtins.str]
        """
        Restart policy for all containers within the pod. Enum: `"Never" "OnFailure"`
        """
elif False:
    VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgs:
    def __init__(__self__, *,
                 containers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs']]],
                 restart_policy: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs']]] containers: A list of containers belonging to the pod.
        :param pulumi.Input[builtins.str] restart_policy: Restart policy for all containers within the pod. Enum: `"Never" "OnFailure"`
        """
        pulumi.set(__self__, "containers", containers)
        pulumi.set(__self__, "restart_policy", restart_policy)

    @property
    @pulumi.getter
    def containers(self) -> pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs']]]:
        """
        A list of containers belonging to the pod.
        """
        return pulumi.get(self, "containers")

    @containers.setter
    def containers(self, value: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs']]]):
        pulumi.set(self, "containers", value)

    @property
    @pulumi.getter(name="restartPolicy")
    def restart_policy(self) -> pulumi.Input[builtins.str]:
        """
        Restart policy for all containers within the pod. Enum: `"Never" "OnFailure"`
        """
        return pulumi.get(self, "restart_policy")

    @restart_policy.setter
    def restart_policy(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "restart_policy", value)


if not MYPY:
    class VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgsDict(TypedDict):
        commands: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
        """
        The entry point of a container.
        """
        container_name: pulumi.Input[builtins.str]
        """
        The name of a container.
        """
        image: pulumi.Input[builtins.str]
        """
        The image name of a container.
        """
elif False:
    VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs:
    def __init__(__self__, *,
                 commands: pulumi.Input[Sequence[pulumi.Input[builtins.str]]],
                 container_name: pulumi.Input[builtins.str],
                 image: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] commands: The entry point of a container.
        :param pulumi.Input[builtins.str] container_name: The name of a container.
        :param pulumi.Input[builtins.str] image: The image name of a container.
        """
        pulumi.set(__self__, "commands", commands)
        pulumi.set(__self__, "container_name", container_name)
        pulumi.set(__self__, "image", image)

    @property
    @pulumi.getter
    def commands(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
        """
        The entry point of a container.
        """
        return pulumi.get(self, "commands")

    @commands.setter
    def commands(self, value: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
        pulumi.set(self, "commands", value)

    @property
    @pulumi.getter(name="containerName")
    def container_name(self) -> pulumi.Input[builtins.str]:
        """
        The name of a container.
        """
        return pulumi.get(self, "container_name")

    @container_name.setter
    def container_name(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "container_name", value)

    @property
    @pulumi.getter
    def image(self) -> pulumi.Input[builtins.str]:
        """
        The image name of a container.
        """
        return pulumi.get(self, "image")

    @image.setter
    def image(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "image", value)


if not MYPY:
    class VerificationTemplateMetricProviderNewRelicArgsDict(TypedDict):
        new_relic_query: pulumi.Input[builtins.str]
        """
        A raw newrelic NRQL query to perform.
        """
        profile: NotRequired[pulumi.Input[builtins.str]]
        """
        The name of the secret holding NR account configuration.
        """
elif False:
    VerificationTemplateMetricProviderNewRelicArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderNewRelicArgs:
    def __init__(__self__, *,
                 new_relic_query: pulumi.Input[builtins.str],
                 profile: Optional[pulumi.Input[builtins.str]] = None):
        """
        :param pulumi.Input[builtins.str] new_relic_query: A raw newrelic NRQL query to perform.
        :param pulumi.Input[builtins.str] profile: The name of the secret holding NR account configuration.
        """
        pulumi.set(__self__, "new_relic_query", new_relic_query)
        if profile is not None:
            pulumi.set(__self__, "profile", profile)

    @property
    @pulumi.getter(name="newRelicQuery")
    def new_relic_query(self) -> pulumi.Input[builtins.str]:
        """
        A raw newrelic NRQL query to perform.
        """
        return pulumi.get(self, "new_relic_query")

    @new_relic_query.setter
    def new_relic_query(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "new_relic_query", value)

    @property
    @pulumi.getter
    def profile(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The name of the secret holding NR account configuration.
        """
        return pulumi.get(self, "profile")

    @profile.setter
    def profile(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "profile", value)


if not MYPY:
    class VerificationTemplateMetricProviderPrometheusArgsDict(TypedDict):
        prometheus_query: pulumi.Input[builtins.str]
        """
        A request for information retrieved from Prometheus.
        """
elif False:
    VerificationTemplateMetricProviderPrometheusArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderPrometheusArgs:
    def __init__(__self__, *,
                 prometheus_query: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] prometheus_query: A request for information retrieved from Prometheus.
        """
        pulumi.set(__self__, "prometheus_query", prometheus_query)

    @property
    @pulumi.getter(name="prometheusQuery")
    def prometheus_query(self) -> pulumi.Input[builtins.str]:
        """
        A request for information retrieved from Prometheus.
        """
        return pulumi.get(self, "prometheus_query")

    @prometheus_query.setter
    def prometheus_query(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "prometheus_query", value)


if not MYPY:
    class VerificationTemplateMetricProviderWebArgsDict(TypedDict):
        url: pulumi.Input[builtins.str]
        """
        The address of the web metric.
        """
        body: NotRequired[pulumi.Input[builtins.str]]
        """
        The body of the web metric.
        """
        insecure: NotRequired[pulumi.Input[builtins.bool]]
        """
        Skips host TLS verification.
        """
        json_path: NotRequired[pulumi.Input[builtins.str]]
        """
        A JSON Path to use as the result variable. Default is "{$}"
        """
        method: NotRequired[pulumi.Input[builtins.str]]
        """
        The method of the web metric.  Enum: "GET" "POST" "PUT"
        """
        timeout_seconds: NotRequired[pulumi.Input[builtins.int]]
        """
        The timeout for the request in seconds. Default is 10.
        """
        web_headers: NotRequired[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderWebWebHeaderArgsDict']]]]
        """
        Optional HTTP headers to use in the request.
        """
elif False:
    VerificationTemplateMetricProviderWebArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderWebArgs:
    def __init__(__self__, *,
                 url: pulumi.Input[builtins.str],
                 body: Optional[pulumi.Input[builtins.str]] = None,
                 insecure: Optional[pulumi.Input[builtins.bool]] = None,
                 json_path: Optional[pulumi.Input[builtins.str]] = None,
                 method: Optional[pulumi.Input[builtins.str]] = None,
                 timeout_seconds: Optional[pulumi.Input[builtins.int]] = None,
                 web_headers: Optional[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderWebWebHeaderArgs']]]] = None):
        """
        :param pulumi.Input[builtins.str] url: The address of the web metric.
        :param pulumi.Input[builtins.str] body: The body of the web metric.
        :param pulumi.Input[builtins.bool] insecure: Skips host TLS verification.
        :param pulumi.Input[builtins.str] json_path: A JSON Path to use as the result variable. Default is "{$}"
        :param pulumi.Input[builtins.str] method: The method of the web metric.  Enum: "GET" "POST" "PUT"
        :param pulumi.Input[builtins.int] timeout_seconds: The timeout for the request in seconds. Default is 10.
        :param pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderWebWebHeaderArgs']]] web_headers: Optional HTTP headers to use in the request.
        """
        pulumi.set(__self__, "url", url)
        if body is not None:
            pulumi.set(__self__, "body", body)
        if insecure is not None:
            pulumi.set(__self__, "insecure", insecure)
        if json_path is not None:
            pulumi.set(__self__, "json_path", json_path)
        if method is not None:
            pulumi.set(__self__, "method", method)
        if timeout_seconds is not None:
            pulumi.set(__self__, "timeout_seconds", timeout_seconds)
        if web_headers is not None:
            pulumi.set(__self__, "web_headers", web_headers)

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[builtins.str]:
        """
        The address of the web metric.
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "url", value)

    @property
    @pulumi.getter
    def body(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The body of the web metric.
        """
        return pulumi.get(self, "body")

    @body.setter
    def body(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "body", value)

    @property
    @pulumi.getter
    def insecure(self) -> Optional[pulumi.Input[builtins.bool]]:
        """
        Skips host TLS verification.
        """
        return pulumi.get(self, "insecure")

    @insecure.setter
    def insecure(self, value: Optional[pulumi.Input[builtins.bool]]):
        pulumi.set(self, "insecure", value)

    @property
    @pulumi.getter(name="jsonPath")
    def json_path(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        A JSON Path to use as the result variable. Default is "{$}"
        """
        return pulumi.get(self, "json_path")

    @json_path.setter
    def json_path(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "json_path", value)

    @property
    @pulumi.getter
    def method(self) -> Optional[pulumi.Input[builtins.str]]:
        """
        The method of the web metric.  Enum: "GET" "POST" "PUT"
        """
        return pulumi.get(self, "method")

    @method.setter
    def method(self, value: Optional[pulumi.Input[builtins.str]]):
        pulumi.set(self, "method", value)

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> Optional[pulumi.Input[builtins.int]]:
        """
        The timeout for the request in seconds. Default is 10.
        """
        return pulumi.get(self, "timeout_seconds")

    @timeout_seconds.setter
    def timeout_seconds(self, value: Optional[pulumi.Input[builtins.int]]):
        pulumi.set(self, "timeout_seconds", value)

    @property
    @pulumi.getter(name="webHeaders")
    def web_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderWebWebHeaderArgs']]]]:
        """
        Optional HTTP headers to use in the request.
        """
        return pulumi.get(self, "web_headers")

    @web_headers.setter
    def web_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderWebWebHeaderArgs']]]]):
        pulumi.set(self, "web_headers", value)


if not MYPY:
    class VerificationTemplateMetricProviderWebWebHeaderArgsDict(TypedDict):
        web_header_key: pulumi.Input[builtins.str]
        """
        The name of a header
        """
        web_header_value: pulumi.Input[builtins.str]
        """
        The value of a header
        """
elif False:
    VerificationTemplateMetricProviderWebWebHeaderArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class VerificationTemplateMetricProviderWebWebHeaderArgs:
    def __init__(__self__, *,
                 web_header_key: pulumi.Input[builtins.str],
                 web_header_value: pulumi.Input[builtins.str]):
        """
        :param pulumi.Input[builtins.str] web_header_key: The name of a header
        :param pulumi.Input[builtins.str] web_header_value: The value of a header
        """
        pulumi.set(__self__, "web_header_key", web_header_key)
        pulumi.set(__self__, "web_header_value", web_header_value)

    @property
    @pulumi.getter(name="webHeaderKey")
    def web_header_key(self) -> pulumi.Input[builtins.str]:
        """
        The name of a header
        """
        return pulumi.get(self, "web_header_key")

    @web_header_key.setter
    def web_header_key(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "web_header_key", value)

    @property
    @pulumi.getter(name="webHeaderValue")
    def web_header_value(self) -> pulumi.Input[builtins.str]:
        """
        The value of a header
        """
        return pulumi.get(self, "web_header_value")

    @web_header_value.setter
    def web_header_value(self, value: pulumi.Input[builtins.str]):
        pulumi.set(self, "web_header_value", value)


