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

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

__all__ = [
    'RolloutSpecFailurePolicyArgs',
    'RolloutSpecSpotDeploymentArgs',
    'RolloutSpecStrategyArgs',
    'RolloutSpecStrategyArgArgs',
    'RolloutSpecStrategyArgValueFromArgs',
    'RolloutSpecStrategyArgValueFromFieldRefArgs',
    'RolloutSpecTrafficArgs',
    'RolloutSpecTrafficAlbArgs',
    'RolloutSpecTrafficAlbStickinessConfigArgs',
    'RolloutSpecTrafficAmbassadorArgs',
    'RolloutSpecTrafficIstioArgs',
    'RolloutSpecTrafficIstioDestinationRuleArgs',
    'RolloutSpecTrafficIstioVirtualServiceArgs',
    'RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs',
    'RolloutSpecTrafficNginxArgs',
    'RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs',
    'RolloutSpecTrafficPingPongArgs',
    'RolloutSpecTrafficSmiArgs',
    'StrategyCanaryArgs',
    'StrategyCanaryBackgroundVerificationArgs',
    'StrategyCanaryStepArgs',
    'StrategyCanaryStepPauseArgs',
    'StrategyCanaryStepSetCanaryScaleArgs',
    'StrategyCanaryStepSetHeaderRouteArgs',
    'StrategyCanaryStepSetHeaderRouteMatchArgs',
    'StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs',
    'StrategyCanaryStepVerificationArgs',
    'StrategyRollingArgs',
    'StrategyRollingStepArgs',
    'StrategyRollingStepPauseArgs',
    'StrategyRollingStepVerificationArgs',
    'VerificationProviderCloudWatchArgs',
    'VerificationProviderDatadogArgs',
    'VerificationProviderJenkinsArgs',
    'VerificationProviderNewRelicArgs',
    'VerificationProviderPrometheusArgs',
    'VerificationTemplateArgArgs',
    'VerificationTemplateArgValueFromArgs',
    'VerificationTemplateArgValueFromSecretKeyRefArgs',
    'VerificationTemplateMetricArgs',
    'VerificationTemplateMetricBaselineArgs',
    'VerificationTemplateMetricBaselineBaselineProviderArgs',
    'VerificationTemplateMetricBaselineBaselineProviderDatadogArgs',
    'VerificationTemplateMetricBaselineBaselineProviderNewRelicArgs',
    'VerificationTemplateMetricBaselineBaselineProviderPrometheusArgs',
    'VerificationTemplateMetricProviderArgs',
    'VerificationTemplateMetricProviderCloudWatchArgs',
    'VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs',
    'VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs',
    'VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs',
    'VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs',
    'VerificationTemplateMetricProviderDatadogArgs',
    'VerificationTemplateMetricProviderJenkinsArgs',
    'VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs',
    'VerificationTemplateMetricProviderJobArgs',
    'VerificationTemplateMetricProviderJobSpecArgs',
    'VerificationTemplateMetricProviderJobSpecJobTemplateArgs',
    'VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgs',
    'VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs',
    'VerificationTemplateMetricProviderNewRelicArgs',
    'VerificationTemplateMetricProviderPrometheusArgs',
    'VerificationTemplateMetricProviderWebArgs',
    'VerificationTemplateMetricProviderWebWebHeaderArgs',
]

@pulumi.input_type
class RolloutSpecFailurePolicyArgs:
    def __init__(__self__, *,
                 action: pulumi.Input[str]):
        """
        :param pulumi.Input[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[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[str]):
        pulumi.set(self, "action", value)


@pulumi.input_type
class RolloutSpecSpotDeploymentArgs:
    def __init__(__self__, *,
                 spot_deployments_cluster_id: Optional[pulumi.Input[str]] = None,
                 spot_deployments_name: Optional[pulumi.Input[str]] = None,
                 spot_deployments_namespace: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] spot_deployments_cluster_id: Ocean CD cluster identifier for the references `SpotDeployment`.
        :param pulumi.Input[str] spot_deployments_name: The name of the `SpotDeployment` resource
        :param pulumi.Input[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[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[str]]):
        pulumi.set(self, "spot_deployments_cluster_id", value)

    @property
    @pulumi.getter(name="spotDeploymentsName")
    def spot_deployments_name(self) -> Optional[pulumi.Input[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[str]]):
        pulumi.set(self, "spot_deployments_name", value)

    @property
    @pulumi.getter(name="spotDeploymentsNamespace")
    def spot_deployments_namespace(self) -> Optional[pulumi.Input[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[str]]):
        pulumi.set(self, "spot_deployments_namespace", value)


@pulumi.input_type
class RolloutSpecStrategyArgs:
    def __init__(__self__, *,
                 strategy_name: pulumi.Input[str],
                 args: Optional[pulumi.Input[Sequence[pulumi.Input['RolloutSpecStrategyArgArgs']]]] = None):
        """
        :param pulumi.Input[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[str]:
        """
        Ocean CD strategy name identifier.
        """
        return pulumi.get(self, "strategy_name")

    @strategy_name.setter
    def strategy_name(self, value: pulumi.Input[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)


@pulumi.input_type
class RolloutSpecStrategyArgArgs:
    def __init__(__self__, *,
                 arg_name: pulumi.Input[str],
                 arg_value: Optional[pulumi.Input[str]] = None,
                 value_from: Optional[pulumi.Input['RolloutSpecStrategyArgValueFromArgs']] = None):
        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[str]:
        return pulumi.get(self, "arg_name")

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

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

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

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

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


@pulumi.input_type
class RolloutSpecStrategyArgValueFromArgs:
    def __init__(__self__, *,
                 field_ref: pulumi.Input['RolloutSpecStrategyArgValueFromFieldRefArgs']):
        pulumi.set(__self__, "field_ref", field_ref)

    @property
    @pulumi.getter(name="fieldRef")
    def field_ref(self) -> pulumi.Input['RolloutSpecStrategyArgValueFromFieldRefArgs']:
        return pulumi.get(self, "field_ref")

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


@pulumi.input_type
class RolloutSpecStrategyArgValueFromFieldRefArgs:
    def __init__(__self__, *,
                 field_path: pulumi.Input[str]):
        pulumi.set(__self__, "field_path", field_path)

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

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


@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[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[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[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[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[str]]:
        """
        The canary service name.
        """
        return pulumi.get(self, "canary_service")

    @canary_service.setter
    def canary_service(self, value: Optional[pulumi.Input[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[str]]:
        """
        The stable service name.
        """
        return pulumi.get(self, "stable_service")

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


@pulumi.input_type
class RolloutSpecTrafficAlbArgs:
    def __init__(__self__, *,
                 alb_ingress: pulumi.Input[str],
                 alb_root_service: pulumi.Input[str],
                 service_port: pulumi.Input[int],
                 alb_annotation_prefix: Optional[pulumi.Input[str]] = None,
                 stickiness_config: Optional[pulumi.Input['RolloutSpecTrafficAlbStickinessConfigArgs']] = None):
        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[str]:
        return pulumi.get(self, "alb_ingress")

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

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

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

    @property
    @pulumi.getter(name="servicePort")
    def service_port(self) -> pulumi.Input[int]:
        return pulumi.get(self, "service_port")

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

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

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

    @property
    @pulumi.getter(name="stickinessConfig")
    def stickiness_config(self) -> Optional[pulumi.Input['RolloutSpecTrafficAlbStickinessConfigArgs']]:
        return pulumi.get(self, "stickiness_config")

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


@pulumi.input_type
class RolloutSpecTrafficAlbStickinessConfigArgs:
    def __init__(__self__, *,
                 duration_seconds: Optional[pulumi.Input[int]] = None,
                 enabled: Optional[pulumi.Input[bool]] = None):
        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[int]]:
        return pulumi.get(self, "duration_seconds")

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

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

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


@pulumi.input_type
class RolloutSpecTrafficAmbassadorArgs:
    def __init__(__self__, *,
                 mappings: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(__self__, "mappings", mappings)

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

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


@pulumi.input_type
class RolloutSpecTrafficIstioArgs:
    def __init__(__self__, *,
                 virtual_services: pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceArgs']]],
                 destination_rule: Optional[pulumi.Input['RolloutSpecTrafficIstioDestinationRuleArgs']] = None):
        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']]]:
        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']]:
        return pulumi.get(self, "destination_rule")

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


@pulumi.input_type
class RolloutSpecTrafficIstioDestinationRuleArgs:
    def __init__(__self__, *,
                 canary_subset_name: pulumi.Input[str],
                 destination_rule_name: pulumi.Input[str],
                 stable_subset_name: pulumi.Input[str]):
        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[str]:
        return pulumi.get(self, "canary_subset_name")

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

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

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

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

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


@pulumi.input_type
class RolloutSpecTrafficIstioVirtualServiceArgs:
    def __init__(__self__, *,
                 virtual_service_name: pulumi.Input[str],
                 tls_routes: Optional[pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs']]]] = None,
                 virtual_service_routes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        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[str]:
        return pulumi.get(self, "virtual_service_name")

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

    @property
    @pulumi.getter(name="tlsRoutes")
    def tls_routes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs']]]]:
        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[str]]]]:
        return pulumi.get(self, "virtual_service_routes")

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


@pulumi.input_type
class RolloutSpecTrafficIstioVirtualServiceTlsRouteArgs:
    def __init__(__self__, *,
                 port: Optional[pulumi.Input[int]] = None,
                 sni_hosts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        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[int]]:
        return pulumi.get(self, "port")

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

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

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


@pulumi.input_type
class RolloutSpecTrafficNginxArgs:
    def __init__(__self__, *,
                 stable_ingress: pulumi.Input[str],
                 additional_ingress_annotation: Optional[pulumi.Input['RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs']] = None,
                 nginx_annotation_prefix: Optional[pulumi.Input[str]] = None):
        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[str]:
        return pulumi.get(self, "stable_ingress")

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

    @property
    @pulumi.getter(name="additionalIngressAnnotation")
    def additional_ingress_annotation(self) -> Optional[pulumi.Input['RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs']]:
        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[str]]:
        return pulumi.get(self, "nginx_annotation_prefix")

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


@pulumi.input_type
class RolloutSpecTrafficNginxAdditionalIngressAnnotationArgs:
    def __init__(__self__, *,
                 canary_by_header: Optional[pulumi.Input[str]] = None,
                 key1: Optional[pulumi.Input[str]] = None):
        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[str]]:
        return pulumi.get(self, "canary_by_header")

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

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

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


@pulumi.input_type
class RolloutSpecTrafficPingPongArgs:
    def __init__(__self__, *,
                 ping_service: pulumi.Input[str],
                 pong_service: pulumi.Input[str]):
        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[str]:
        return pulumi.get(self, "ping_service")

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

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

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


@pulumi.input_type
class RolloutSpecTrafficSmiArgs:
    def __init__(__self__, *,
                 smi_root_service: Optional[pulumi.Input[str]] = None,
                 traffic_split_name: Optional[pulumi.Input[str]] = None):
        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[str]]:
        return pulumi.get(self, "smi_root_service")

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

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

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


@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)


@pulumi.input_type
class StrategyCanaryBackgroundVerificationArgs:
    def __init__(__self__, *,
                 template_names: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(__self__, "template_names", template_names)

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

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


@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[int]] = None,
                 step_name: Optional[pulumi.Input[str]] = None,
                 verification: Optional[pulumi.Input['StrategyCanaryStepVerificationArgs']] = None):
        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']]:
        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']]:
        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']]:
        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[int]]:
        return pulumi.get(self, "set_weight")

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

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

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

    @property
    @pulumi.getter
    def verification(self) -> Optional[pulumi.Input['StrategyCanaryStepVerificationArgs']]:
        return pulumi.get(self, "verification")

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


@pulumi.input_type
class StrategyCanaryStepPauseArgs:
    def __init__(__self__, *,
                 duration: Optional[pulumi.Input[str]] = None):
        if duration is not None:
            pulumi.set(__self__, "duration", duration)

    @property
    @pulumi.getter
    def duration(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "duration")

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


@pulumi.input_type
class StrategyCanaryStepSetCanaryScaleArgs:
    def __init__(__self__, *,
                 match_traffic_weight: Optional[pulumi.Input[bool]] = None,
                 replicas: Optional[pulumi.Input[int]] = None,
                 weight: Optional[pulumi.Input[int]] = None):
        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[bool]]:
        return pulumi.get(self, "match_traffic_weight")

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

    @property
    @pulumi.getter
    def replicas(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "replicas")

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

    @property
    @pulumi.getter
    def weight(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "weight")

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


@pulumi.input_type
class StrategyCanaryStepSetHeaderRouteArgs:
    def __init__(__self__, *,
                 header_route_name: pulumi.Input[str],
                 matches: pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchArgs']]]):
        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[str]:
        return pulumi.get(self, "header_route_name")

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

    @property
    @pulumi.getter
    def matches(self) -> pulumi.Input[Sequence[pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchArgs']]]:
        return pulumi.get(self, "matches")

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


@pulumi.input_type
class StrategyCanaryStepSetHeaderRouteMatchArgs:
    def __init__(__self__, *,
                 header_name: pulumi.Input[str],
                 header_value: pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs']):
        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[str]:
        return pulumi.get(self, "header_name")

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

    @property
    @pulumi.getter(name="headerValue")
    def header_value(self) -> pulumi.Input['StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs']:
        return pulumi.get(self, "header_value")

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


@pulumi.input_type
class StrategyCanaryStepSetHeaderRouteMatchHeaderValueArgs:
    def __init__(__self__, *,
                 exact: Optional[pulumi.Input[str]] = None,
                 prefix: Optional[pulumi.Input[str]] = None,
                 regex: Optional[pulumi.Input[str]] = None):
        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[str]]:
        return pulumi.get(self, "exact")

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

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

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

    @property
    @pulumi.getter
    def regex(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "regex")

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


@pulumi.input_type
class StrategyCanaryStepVerificationArgs:
    def __init__(__self__, *,
                 template_names: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(__self__, "template_names", template_names)

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

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


@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)


@pulumi.input_type
class StrategyRollingStepArgs:
    def __init__(__self__, *,
                 pause: Optional[pulumi.Input['StrategyRollingStepPauseArgs']] = None,
                 steps_name: Optional[pulumi.Input[str]] = None,
                 verification: Optional[pulumi.Input['StrategyRollingStepVerificationArgs']] = None):
        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']]:
        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[str]]:
        return pulumi.get(self, "steps_name")

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

    @property
    @pulumi.getter
    def verification(self) -> Optional[pulumi.Input['StrategyRollingStepVerificationArgs']]:
        return pulumi.get(self, "verification")

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


@pulumi.input_type
class StrategyRollingStepPauseArgs:
    def __init__(__self__, *,
                 duration: Optional[pulumi.Input[str]] = None):
        if duration is not None:
            pulumi.set(__self__, "duration", duration)

    @property
    @pulumi.getter
    def duration(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "duration")

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


@pulumi.input_type
class StrategyRollingStepVerificationArgs:
    def __init__(__self__, *,
                 template_names: pulumi.Input[Sequence[pulumi.Input[str]]]):
        pulumi.set(__self__, "template_names", template_names)

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

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


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

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

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


@pulumi.input_type
class VerificationProviderDatadogArgs:
    def __init__(__self__, *,
                 address: pulumi.Input[str],
                 api_key: pulumi.Input[str],
                 app_key: pulumi.Input[str]):
        """
        :param pulumi.Input[str] address: DataDog API URL.
        :param pulumi.Input[str] api_key: API key required by the Datadog Agent to submit metrics and events to Datadog.
        :param pulumi.Input[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[str]:
        """
        DataDog API URL.
        """
        return pulumi.get(self, "address")

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

    @property
    @pulumi.getter(name="apiKey")
    def api_key(self) -> pulumi.Input[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[str]):
        pulumi.set(self, "api_key", value)

    @property
    @pulumi.getter(name="appKey")
    def app_key(self) -> pulumi.Input[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[str]):
        pulumi.set(self, "app_key", value)


@pulumi.input_type
class VerificationProviderJenkinsArgs:
    def __init__(__self__, *,
                 api_token: pulumi.Input[str],
                 base_url: pulumi.Input[str],
                 username: pulumi.Input[str]):
        """
        :param pulumi.Input[str] api_token: The Jenkins server’s access apiToken.
        :param pulumi.Input[str] base_url: The address of the Jenkins server within the cluster.
        :param pulumi.Input[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[str]:
        """
        The Jenkins server’s access apiToken.
        """
        return pulumi.get(self, "api_token")

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

    @property
    @pulumi.getter(name="baseUrl")
    def base_url(self) -> pulumi.Input[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[str]):
        pulumi.set(self, "base_url", value)

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

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


@pulumi.input_type
class VerificationProviderNewRelicArgs:
    def __init__(__self__, *,
                 account_id: pulumi.Input[str],
                 personal_api_key: pulumi.Input[str],
                 base_url_nerd_graph: Optional[pulumi.Input[str]] = None,
                 base_url_rest: Optional[pulumi.Input[str]] = None,
                 region: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] personal_api_key: The NewRelic user key
        :param pulumi.Input[str] base_url_nerd_graph: The base URL for NerdGraph for a proxy.
        :param pulumi.Input[str] base_url_rest: The base URL of the New Relic REST API for a proxy.
        :param pulumi.Input[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[str]:
        return pulumi.get(self, "account_id")

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

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

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

    @property
    @pulumi.getter(name="baseUrlNerdGraph")
    def base_url_nerd_graph(self) -> Optional[pulumi.Input[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[str]]):
        pulumi.set(self, "base_url_nerd_graph", value)

    @property
    @pulumi.getter(name="baseUrlRest")
    def base_url_rest(self) -> Optional[pulumi.Input[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[str]]):
        pulumi.set(self, "base_url_rest", value)

    @property
    @pulumi.getter
    def region(self) -> Optional[pulumi.Input[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[str]]):
        pulumi.set(self, "region", value)


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

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

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


@pulumi.input_type
class VerificationTemplateArgArgs:
    def __init__(__self__, *,
                 arg_name: pulumi.Input[str],
                 value: Optional[pulumi.Input[str]] = None,
                 value_from: Optional[pulumi.Input['VerificationTemplateArgValueFromArgs']] = None):
        """
        :param pulumi.Input[str] arg_name: Name of an argument.
        :param pulumi.Input[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[str]:
        """
        Name of an argument.
        """
        return pulumi.get(self, "arg_name")

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

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

    @value.setter
    def value(self, value: Optional[pulumi.Input[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)


@pulumi.input_type
class VerificationTemplateArgValueFromArgs:
    def __init__(__self__, *,
                 secret_key_ref: Optional[pulumi.Input['VerificationTemplateArgValueFromSecretKeyRefArgs']] = None):
        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']]:
        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)


@pulumi.input_type
class VerificationTemplateArgValueFromSecretKeyRefArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] name: Identifier name for Ocean CD Verification Template. Must be unique.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "name", name)

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

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

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        """
        Identifier name for Ocean CD Verification Template. Must be unique.
        """
        return pulumi.get(self, "name")

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


@pulumi.input_type
class VerificationTemplateMetricArgs:
    def __init__(__self__, *,
                 metrics_name: pulumi.Input[str],
                 providers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderArgs']]],
                 baseline: Optional[pulumi.Input['VerificationTemplateMetricBaselineArgs']] = None,
                 consecutive_error_limit: Optional[pulumi.Input[int]] = None,
                 count: Optional[pulumi.Input[int]] = None,
                 dry_run: Optional[pulumi.Input[bool]] = None,
                 failure_condition: Optional[pulumi.Input[str]] = None,
                 failure_limit: Optional[pulumi.Input[int]] = None,
                 initial_delay: Optional[pulumi.Input[str]] = None,
                 interval: Optional[pulumi.Input[str]] = None,
                 success_condition: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[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[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[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[bool] dry_run: Defines whether the metric should have an impact on the result of the rollout.
        :param pulumi.Input[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[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[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[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[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[str]:
        """
        The name of the verification metric.
        """
        return pulumi.get(self, "metrics_name")

    @metrics_name.setter
    def metrics_name(self, value: pulumi.Input[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[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[int]]):
        pulumi.set(self, "consecutive_error_limit", value)

    @property
    @pulumi.getter
    def count(self) -> Optional[pulumi.Input[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[int]]):
        pulumi.set(self, "count", value)

    @property
    @pulumi.getter(name="dryRun")
    def dry_run(self) -> Optional[pulumi.Input[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[bool]]):
        pulumi.set(self, "dry_run", value)

    @property
    @pulumi.getter(name="failureCondition")
    def failure_condition(self) -> Optional[pulumi.Input[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[str]]):
        pulumi.set(self, "failure_condition", value)

    @property
    @pulumi.getter(name="failureLimit")
    def failure_limit(self) -> Optional[pulumi.Input[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[int]]):
        pulumi.set(self, "failure_limit", value)

    @property
    @pulumi.getter(name="initialDelay")
    def initial_delay(self) -> Optional[pulumi.Input[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[str]]):
        pulumi.set(self, "initial_delay", value)

    @property
    @pulumi.getter
    def interval(self) -> Optional[pulumi.Input[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[str]]):
        pulumi.set(self, "interval", value)

    @property
    @pulumi.getter(name="successCondition")
    def success_condition(self) -> Optional[pulumi.Input[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[str]]):
        pulumi.set(self, "success_condition", value)


@pulumi.input_type
class VerificationTemplateMetricBaselineArgs:
    def __init__(__self__, *,
                 baseline_providers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricBaselineBaselineProviderArgs']]],
                 threshold: pulumi.Input[str],
                 max_range: Optional[pulumi.Input[int]] = None,
                 min_range: Optional[pulumi.Input[int]] = None):
        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']]]:
        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[str]:
        return pulumi.get(self, "threshold")

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

    @property
    @pulumi.getter(name="maxRange")
    def max_range(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "max_range")

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

    @property
    @pulumi.getter(name="minRange")
    def min_range(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "min_range")

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


@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):
        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']]:
        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']]:
        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']]:
        return pulumi.get(self, "prometheus")

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


@pulumi.input_type
class VerificationTemplateMetricBaselineBaselineProviderDatadogArgs:
    def __init__(__self__, *,
                 datadog_query: pulumi.Input[str],
                 duration: Optional[pulumi.Input[str]] = 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) -> pulumi.Input[str]:
        return pulumi.get(self, "datadog_query")

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

    @property
    @pulumi.getter
    def duration(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "duration")

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


@pulumi.input_type
class VerificationTemplateMetricBaselineBaselineProviderNewRelicArgs:
    def __init__(__self__, *,
                 new_relic_query: pulumi.Input[str],
                 profile: Optional[pulumi.Input[str]] = None):
        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[str]:
        return pulumi.get(self, "new_relic_query")

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

    @property
    @pulumi.getter
    def profile(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "profile")

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


@pulumi.input_type
class VerificationTemplateMetricBaselineBaselineProviderPrometheusArgs:
    def __init__(__self__, *,
                 prometheus_query: pulumi.Input[str]):
        pulumi.set(__self__, "prometheus_query", prometheus_query)

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

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


@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):
        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']]:
        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']]:
        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']]:
        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']]:
        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']]:
        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']]:
        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']]:
        return pulumi.get(self, "web")

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


@pulumi.input_type
class VerificationTemplateMetricProviderCloudWatchArgs:
    def __init__(__self__, *,
                 metric_data_queries: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs']]],
                 duration: Optional[pulumi.Input[str]] = None):
        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']]]:
        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[str]]:
        return pulumi.get(self, "duration")

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


@pulumi.input_type
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryArgs:
    def __init__(__self__, *,
                 id: pulumi.Input[str],
                 expression: Optional[pulumi.Input[str]] = None,
                 label: Optional[pulumi.Input[str]] = None,
                 metric_stat: Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs']] = None,
                 period: Optional[pulumi.Input[int]] = None,
                 return_data: Optional[pulumi.Input[bool]] = None):
        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[str]:
        return pulumi.get(self, "id")

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

    @property
    @pulumi.getter
    def expression(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "expression")

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

    @property
    @pulumi.getter
    def label(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "label")

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

    @property
    @pulumi.getter(name="metricStat")
    def metric_stat(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs']]:
        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[int]]:
        return pulumi.get(self, "period")

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

    @property
    @pulumi.getter(name="returnData")
    def return_data(self) -> Optional[pulumi.Input[bool]]:
        return pulumi.get(self, "return_data")

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


@pulumi.input_type
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatArgs:
    def __init__(__self__, *,
                 metric: Optional[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs']] = None,
                 metric_period: Optional[pulumi.Input[int]] = None,
                 stat: Optional[pulumi.Input[str]] = None,
                 unit: Optional[pulumi.Input[str]] = 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']]:
        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[int]]:
        return pulumi.get(self, "metric_period")

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

    @property
    @pulumi.getter
    def stat(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "stat")

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

    @property
    @pulumi.getter
    def unit(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "unit")

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


@pulumi.input_type
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricArgs:
    def __init__(__self__, *,
                 metric_name: pulumi.Input[str],
                 dimensions: Optional[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs']]]] = None,
                 namespace: Optional[pulumi.Input[str]] = None):
        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[str]:
        return pulumi.get(self, "metric_name")

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

    @property
    @pulumi.getter
    def dimensions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs']]]]:
        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[str]]:
        return pulumi.get(self, "namespace")

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


@pulumi.input_type
class VerificationTemplateMetricProviderCloudWatchMetricDataQueryMetricStatMetricDimensionArgs:
    def __init__(__self__, *,
                 dimension_name: pulumi.Input[str],
                 dimension_value: pulumi.Input[str]):
        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[str]:
        return pulumi.get(self, "dimension_name")

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

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

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


@pulumi.input_type
class VerificationTemplateMetricProviderDatadogArgs:
    def __init__(__self__, *,
                 datadog_query: Optional[pulumi.Input[str]] = None,
                 duration: Optional[pulumi.Input[str]] = None):
        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[str]]:
        return pulumi.get(self, "datadog_query")

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

    @property
    @pulumi.getter
    def duration(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "duration")

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


@pulumi.input_type
class VerificationTemplateMetricProviderJenkinsArgs:
    def __init__(__self__, *,
                 jenkins_interval: pulumi.Input[str],
                 pipeline_name: pulumi.Input[str],
                 timeout: pulumi.Input[str],
                 jenkins_parameters: Optional[pulumi.Input['VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs']] = None,
                 tls_verification: Optional[pulumi.Input[bool]] = None):
        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[str]:
        return pulumi.get(self, "jenkins_interval")

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

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

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

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

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

    @property
    @pulumi.getter(name="jenkinsParameters")
    def jenkins_parameters(self) -> Optional[pulumi.Input['VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs']]:
        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[bool]]:
        return pulumi.get(self, "tls_verification")

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


@pulumi.input_type
class VerificationTemplateMetricProviderJenkinsJenkinsParametersArgs:
    def __init__(__self__, *,
                 parameter_key: pulumi.Input[str],
                 parameter_value: pulumi.Input[str]):
        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[str]:
        return pulumi.get(self, "parameter_key")

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

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

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


@pulumi.input_type
class VerificationTemplateMetricProviderJobArgs:
    def __init__(__self__, *,
                 specs: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecArgs']]]):
        pulumi.set(__self__, "specs", specs)

    @property
    @pulumi.getter
    def specs(self) -> pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecArgs']]]:
        return pulumi.get(self, "specs")

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


@pulumi.input_type
class VerificationTemplateMetricProviderJobSpecArgs:
    def __init__(__self__, *,
                 job_templates: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateArgs']]],
                 backoff_limit: Optional[pulumi.Input[int]] = None):
        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']]]:
        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[int]]:
        return pulumi.get(self, "backoff_limit")

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


@pulumi.input_type
class VerificationTemplateMetricProviderJobSpecJobTemplateArgs:
    def __init__(__self__, *,
                 template_specs: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgs']]]):
        pulumi.set(__self__, "template_specs", template_specs)

    @property
    @pulumi.getter(name="templateSpecs")
    def template_specs(self) -> pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgs']]]:
        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)


@pulumi.input_type
class VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecArgs:
    def __init__(__self__, *,
                 containers: pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs']]],
                 restart_policy: pulumi.Input[str]):
        pulumi.set(__self__, "containers", containers)
        pulumi.set(__self__, "restart_policy", restart_policy)

    @property
    @pulumi.getter
    def containers(self) -> pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs']]]:
        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[str]:
        return pulumi.get(self, "restart_policy")

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


@pulumi.input_type
class VerificationTemplateMetricProviderJobSpecJobTemplateTemplateSpecContainerArgs:
    def __init__(__self__, *,
                 commands: pulumi.Input[Sequence[pulumi.Input[str]]],
                 container_name: pulumi.Input[str],
                 image: pulumi.Input[str]):
        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[str]]]:
        return pulumi.get(self, "commands")

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

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

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

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

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


@pulumi.input_type
class VerificationTemplateMetricProviderNewRelicArgs:
    def __init__(__self__, *,
                 new_relic_query: pulumi.Input[str],
                 profile: Optional[pulumi.Input[str]] = None):
        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[str]:
        return pulumi.get(self, "new_relic_query")

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

    @property
    @pulumi.getter
    def profile(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "profile")

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


@pulumi.input_type
class VerificationTemplateMetricProviderPrometheusArgs:
    def __init__(__self__, *,
                 prometheus_query: pulumi.Input[str]):
        pulumi.set(__self__, "prometheus_query", prometheus_query)

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

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


@pulumi.input_type
class VerificationTemplateMetricProviderWebArgs:
    def __init__(__self__, *,
                 url: pulumi.Input[str],
                 body: Optional[pulumi.Input[str]] = None,
                 insecure: Optional[pulumi.Input[bool]] = None,
                 json_path: Optional[pulumi.Input[str]] = None,
                 method: Optional[pulumi.Input[str]] = None,
                 timeout_seconds: Optional[pulumi.Input[int]] = None,
                 web_headers: Optional[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderWebWebHeaderArgs']]]] = None):
        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[str]:
        return pulumi.get(self, "url")

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

    @property
    @pulumi.getter
    def body(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "body")

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

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

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

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

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

    @property
    @pulumi.getter
    def method(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "method")

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

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "timeout_seconds")

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

    @property
    @pulumi.getter(name="webHeaders")
    def web_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VerificationTemplateMetricProviderWebWebHeaderArgs']]]]:
        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)


@pulumi.input_type
class VerificationTemplateMetricProviderWebWebHeaderArgs:
    def __init__(__self__, *,
                 web_header_key: pulumi.Input[str],
                 web_header_value: pulumi.Input[str]):
        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[str]:
        return pulumi.get(self, "web_header_key")

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

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

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


