# coding=utf-8
# *** WARNING: this file was generated by pulumi-language-python. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

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

__all__ = [
    'RouteDestinationArgs',
    'RouteDestinationArgsDict',
    'RouteHeaderArgs',
    'RouteHeaderArgsDict',
    'RouteSourceArgs',
    'RouteSourceArgsDict',
    'UpstreamHealthchecksArgs',
    'UpstreamHealthchecksArgsDict',
    'UpstreamHealthchecksActiveArgs',
    'UpstreamHealthchecksActiveArgsDict',
    'UpstreamHealthchecksActiveHealthyArgs',
    'UpstreamHealthchecksActiveHealthyArgsDict',
    'UpstreamHealthchecksActiveUnhealthyArgs',
    'UpstreamHealthchecksActiveUnhealthyArgsDict',
    'UpstreamHealthchecksPassiveArgs',
    'UpstreamHealthchecksPassiveArgsDict',
    'UpstreamHealthchecksPassiveHealthyArgs',
    'UpstreamHealthchecksPassiveHealthyArgsDict',
    'UpstreamHealthchecksPassiveUnhealthyArgs',
    'UpstreamHealthchecksPassiveUnhealthyArgsDict',
]

MYPY = False

if not MYPY:
    class RouteDestinationArgsDict(TypedDict):
        ip: NotRequired[pulumi.Input[builtins.str]]
        port: NotRequired[pulumi.Input[builtins.int]]
elif False:
    RouteDestinationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RouteDestinationArgs:
    def __init__(__self__, *,
                 ip: Optional[pulumi.Input[builtins.str]] = None,
                 port: Optional[pulumi.Input[builtins.int]] = None):
        if ip is not None:
            pulumi.set(__self__, "ip", ip)
        if port is not None:
            pulumi.set(__self__, "port", port)

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

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

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

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


if not MYPY:
    class RouteHeaderArgsDict(TypedDict):
        name: pulumi.Input[builtins.str]
        """
        The name of the route
        """
        values: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
elif False:
    RouteHeaderArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RouteHeaderArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[builtins.str],
                 values: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]):
        """
        :param pulumi.Input[builtins.str] name: The name of the route
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "values", values)

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

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

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

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


if not MYPY:
    class RouteSourceArgsDict(TypedDict):
        ip: NotRequired[pulumi.Input[builtins.str]]
        port: NotRequired[pulumi.Input[builtins.int]]
elif False:
    RouteSourceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RouteSourceArgs:
    def __init__(__self__, *,
                 ip: Optional[pulumi.Input[builtins.str]] = None,
                 port: Optional[pulumi.Input[builtins.int]] = None):
        if ip is not None:
            pulumi.set(__self__, "ip", ip)
        if port is not None:
            pulumi.set(__self__, "port", port)

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

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

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

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


if not MYPY:
    class UpstreamHealthchecksArgsDict(TypedDict):
        active: NotRequired[pulumi.Input['UpstreamHealthchecksActiveArgsDict']]
        passive: NotRequired[pulumi.Input['UpstreamHealthchecksPassiveArgsDict']]
elif False:
    UpstreamHealthchecksArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamHealthchecksArgs:
    def __init__(__self__, *,
                 active: Optional[pulumi.Input['UpstreamHealthchecksActiveArgs']] = None,
                 passive: Optional[pulumi.Input['UpstreamHealthchecksPassiveArgs']] = None):
        if active is not None:
            pulumi.set(__self__, "active", active)
        if passive is not None:
            pulumi.set(__self__, "passive", passive)

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

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

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

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


if not MYPY:
    class UpstreamHealthchecksActiveArgsDict(TypedDict):
        concurrency: NotRequired[pulumi.Input[builtins.int]]
        healthy: NotRequired[pulumi.Input['UpstreamHealthchecksActiveHealthyArgsDict']]
        http_path: NotRequired[pulumi.Input[builtins.str]]
        https_sni: NotRequired[pulumi.Input[builtins.str]]
        https_verify_certificate: NotRequired[pulumi.Input[builtins.bool]]
        timeout: NotRequired[pulumi.Input[builtins.int]]
        type: NotRequired[pulumi.Input[builtins.str]]
        unhealthy: NotRequired[pulumi.Input['UpstreamHealthchecksActiveUnhealthyArgsDict']]
elif False:
    UpstreamHealthchecksActiveArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamHealthchecksActiveArgs:
    def __init__(__self__, *,
                 concurrency: Optional[pulumi.Input[builtins.int]] = None,
                 healthy: Optional[pulumi.Input['UpstreamHealthchecksActiveHealthyArgs']] = None,
                 http_path: Optional[pulumi.Input[builtins.str]] = None,
                 https_sni: Optional[pulumi.Input[builtins.str]] = None,
                 https_verify_certificate: Optional[pulumi.Input[builtins.bool]] = None,
                 timeout: Optional[pulumi.Input[builtins.int]] = None,
                 type: Optional[pulumi.Input[builtins.str]] = None,
                 unhealthy: Optional[pulumi.Input['UpstreamHealthchecksActiveUnhealthyArgs']] = None):
        if concurrency is not None:
            pulumi.set(__self__, "concurrency", concurrency)
        if healthy is not None:
            pulumi.set(__self__, "healthy", healthy)
        if http_path is not None:
            pulumi.set(__self__, "http_path", http_path)
        if https_sni is not None:
            pulumi.set(__self__, "https_sni", https_sni)
        if https_verify_certificate is not None:
            pulumi.set(__self__, "https_verify_certificate", https_verify_certificate)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if unhealthy is not None:
            pulumi.set(__self__, "unhealthy", unhealthy)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


if not MYPY:
    class UpstreamHealthchecksActiveHealthyArgsDict(TypedDict):
        http_statuses: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]]
        interval: NotRequired[pulumi.Input[builtins.int]]
        successes: NotRequired[pulumi.Input[builtins.int]]
elif False:
    UpstreamHealthchecksActiveHealthyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamHealthchecksActiveHealthyArgs:
    def __init__(__self__, *,
                 http_statuses: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]] = None,
                 interval: Optional[pulumi.Input[builtins.int]] = None,
                 successes: Optional[pulumi.Input[builtins.int]] = None):
        if http_statuses is not None:
            pulumi.set(__self__, "http_statuses", http_statuses)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)
        if successes is not None:
            pulumi.set(__self__, "successes", successes)

    @property
    @pulumi.getter(name="httpStatuses")
    def http_statuses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]]:
        return pulumi.get(self, "http_statuses")

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

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

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

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

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


if not MYPY:
    class UpstreamHealthchecksActiveUnhealthyArgsDict(TypedDict):
        http_failures: NotRequired[pulumi.Input[builtins.int]]
        http_statuses: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]]
        interval: NotRequired[pulumi.Input[builtins.int]]
        tcp_failures: NotRequired[pulumi.Input[builtins.int]]
        timeouts: NotRequired[pulumi.Input[builtins.int]]
elif False:
    UpstreamHealthchecksActiveUnhealthyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamHealthchecksActiveUnhealthyArgs:
    def __init__(__self__, *,
                 http_failures: Optional[pulumi.Input[builtins.int]] = None,
                 http_statuses: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]] = None,
                 interval: Optional[pulumi.Input[builtins.int]] = None,
                 tcp_failures: Optional[pulumi.Input[builtins.int]] = None,
                 timeouts: Optional[pulumi.Input[builtins.int]] = None):
        if http_failures is not None:
            pulumi.set(__self__, "http_failures", http_failures)
        if http_statuses is not None:
            pulumi.set(__self__, "http_statuses", http_statuses)
        if interval is not None:
            pulumi.set(__self__, "interval", interval)
        if tcp_failures is not None:
            pulumi.set(__self__, "tcp_failures", tcp_failures)
        if timeouts is not None:
            pulumi.set(__self__, "timeouts", timeouts)

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

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

    @property
    @pulumi.getter(name="httpStatuses")
    def http_statuses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]]:
        return pulumi.get(self, "http_statuses")

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

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

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

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

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

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

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


if not MYPY:
    class UpstreamHealthchecksPassiveArgsDict(TypedDict):
        healthy: NotRequired[pulumi.Input['UpstreamHealthchecksPassiveHealthyArgsDict']]
        type: NotRequired[pulumi.Input[builtins.str]]
        unhealthy: NotRequired[pulumi.Input['UpstreamHealthchecksPassiveUnhealthyArgsDict']]
elif False:
    UpstreamHealthchecksPassiveArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamHealthchecksPassiveArgs:
    def __init__(__self__, *,
                 healthy: Optional[pulumi.Input['UpstreamHealthchecksPassiveHealthyArgs']] = None,
                 type: Optional[pulumi.Input[builtins.str]] = None,
                 unhealthy: Optional[pulumi.Input['UpstreamHealthchecksPassiveUnhealthyArgs']] = None):
        if healthy is not None:
            pulumi.set(__self__, "healthy", healthy)
        if type is not None:
            pulumi.set(__self__, "type", type)
        if unhealthy is not None:
            pulumi.set(__self__, "unhealthy", unhealthy)

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

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

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

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

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

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


if not MYPY:
    class UpstreamHealthchecksPassiveHealthyArgsDict(TypedDict):
        http_statuses: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]]
        successes: NotRequired[pulumi.Input[builtins.int]]
elif False:
    UpstreamHealthchecksPassiveHealthyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamHealthchecksPassiveHealthyArgs:
    def __init__(__self__, *,
                 http_statuses: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]] = None,
                 successes: Optional[pulumi.Input[builtins.int]] = None):
        if http_statuses is not None:
            pulumi.set(__self__, "http_statuses", http_statuses)
        if successes is not None:
            pulumi.set(__self__, "successes", successes)

    @property
    @pulumi.getter(name="httpStatuses")
    def http_statuses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]]:
        return pulumi.get(self, "http_statuses")

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

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

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


if not MYPY:
    class UpstreamHealthchecksPassiveUnhealthyArgsDict(TypedDict):
        http_failures: NotRequired[pulumi.Input[builtins.int]]
        http_statuses: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]]
        tcp_failures: NotRequired[pulumi.Input[builtins.int]]
        timeouts: NotRequired[pulumi.Input[builtins.int]]
elif False:
    UpstreamHealthchecksPassiveUnhealthyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class UpstreamHealthchecksPassiveUnhealthyArgs:
    def __init__(__self__, *,
                 http_failures: Optional[pulumi.Input[builtins.int]] = None,
                 http_statuses: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]] = None,
                 tcp_failures: Optional[pulumi.Input[builtins.int]] = None,
                 timeouts: Optional[pulumi.Input[builtins.int]] = None):
        if http_failures is not None:
            pulumi.set(__self__, "http_failures", http_failures)
        if http_statuses is not None:
            pulumi.set(__self__, "http_statuses", http_statuses)
        if tcp_failures is not None:
            pulumi.set(__self__, "tcp_failures", tcp_failures)
        if timeouts is not None:
            pulumi.set(__self__, "timeouts", timeouts)

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

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

    @property
    @pulumi.getter(name="httpStatuses")
    def http_statuses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]]:
        return pulumi.get(self, "http_statuses")

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

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

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

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

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


