# 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, Callable, Mapping, Optional, Sequence, Union, overload
from .. import _utilities

__all__ = [
    'BalancerConnectionTimeouts',
    'BalancerTag',
    'ListenerTag',
    'ListenerTlsConfig',
    'RoutingRuleTag',
    'TargetSetHealthCheck',
    'TargetSetTag',
    'TargetTag',
]

@pulumi.output_type
class BalancerConnectionTimeouts(dict):
    def __init__(__self__, *,
                 draining: Optional[int] = None,
                 idle: Optional[int] = None):
        BalancerConnectionTimeouts._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            draining=draining,
            idle=idle,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             draining: Optional[int] = None,
             idle: Optional[int] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):

        if draining is not None:
            _setter("draining", draining)
        if idle is not None:
            _setter("idle", idle)

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

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


@pulumi.output_type
class BalancerTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        BalancerTag._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            key=key,
            value=value,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             key: Optional[str] = None,
             value: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if key is None:
            raise TypeError("Missing 'key' argument")
        if value is None:
            raise TypeError("Missing 'value' argument")

        _setter("key", key)
        _setter("value", value)

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

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


@pulumi.output_type
class ListenerTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        ListenerTag._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            key=key,
            value=value,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             key: Optional[str] = None,
             value: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if key is None:
            raise TypeError("Missing 'key' argument")
        if value is None:
            raise TypeError("Missing 'value' argument")

        _setter("key", key)
        _setter("value", value)

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

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


@pulumi.output_type
class ListenerTlsConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateIds":
            suggest = "certificate_ids"
        elif key == "cipherSuites":
            suggest = "cipher_suites"
        elif key == "maxVersion":
            suggest = "max_version"
        elif key == "minVersion":
            suggest = "min_version"
        elif key == "preferServerCipherSuites":
            suggest = "prefer_server_cipher_suites"
        elif key == "sessionTicketsDisabled":
            suggest = "session_tickets_disabled"

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

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

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

    def __init__(__self__, *,
                 certificate_ids: Sequence[str],
                 cipher_suites: Sequence[str],
                 max_version: str,
                 min_version: str,
                 prefer_server_cipher_suites: bool,
                 session_tickets_disabled: bool):
        ListenerTlsConfig._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            certificate_ids=certificate_ids,
            cipher_suites=cipher_suites,
            max_version=max_version,
            min_version=min_version,
            prefer_server_cipher_suites=prefer_server_cipher_suites,
            session_tickets_disabled=session_tickets_disabled,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             certificate_ids: Optional[Sequence[str]] = None,
             cipher_suites: Optional[Sequence[str]] = None,
             max_version: Optional[str] = None,
             min_version: Optional[str] = None,
             prefer_server_cipher_suites: Optional[bool] = None,
             session_tickets_disabled: Optional[bool] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if certificate_ids is None and 'certificateIds' in kwargs:
            certificate_ids = kwargs['certificateIds']
        if certificate_ids is None:
            raise TypeError("Missing 'certificate_ids' argument")
        if cipher_suites is None and 'cipherSuites' in kwargs:
            cipher_suites = kwargs['cipherSuites']
        if cipher_suites is None:
            raise TypeError("Missing 'cipher_suites' argument")
        if max_version is None and 'maxVersion' in kwargs:
            max_version = kwargs['maxVersion']
        if max_version is None:
            raise TypeError("Missing 'max_version' argument")
        if min_version is None and 'minVersion' in kwargs:
            min_version = kwargs['minVersion']
        if min_version is None:
            raise TypeError("Missing 'min_version' argument")
        if prefer_server_cipher_suites is None and 'preferServerCipherSuites' in kwargs:
            prefer_server_cipher_suites = kwargs['preferServerCipherSuites']
        if prefer_server_cipher_suites is None:
            raise TypeError("Missing 'prefer_server_cipher_suites' argument")
        if session_tickets_disabled is None and 'sessionTicketsDisabled' in kwargs:
            session_tickets_disabled = kwargs['sessionTicketsDisabled']
        if session_tickets_disabled is None:
            raise TypeError("Missing 'session_tickets_disabled' argument")

        _setter("certificate_ids", certificate_ids)
        _setter("cipher_suites", cipher_suites)
        _setter("max_version", max_version)
        _setter("min_version", min_version)
        _setter("prefer_server_cipher_suites", prefer_server_cipher_suites)
        _setter("session_tickets_disabled", session_tickets_disabled)

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

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

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

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

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

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


@pulumi.output_type
class RoutingRuleTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        RoutingRuleTag._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            key=key,
            value=value,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             key: Optional[str] = None,
             value: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if key is None:
            raise TypeError("Missing 'key' argument")
        if value is None:
            raise TypeError("Missing 'value' argument")

        _setter("key", key)
        _setter("value", value)

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

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


@pulumi.output_type
class TargetSetHealthCheck(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "healthyThreshold":
            suggest = "healthy_threshold"
        elif key == "unhealthyThreshold":
            suggest = "unhealthy_threshold"

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

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

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

    def __init__(__self__, *,
                 healthy_threshold: int,
                 interval: int,
                 path: str,
                 protocol: str,
                 timeout: int,
                 unhealthy_threshold: int,
                 port: Optional[int] = None):
        TargetSetHealthCheck._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            healthy_threshold=healthy_threshold,
            interval=interval,
            path=path,
            protocol=protocol,
            timeout=timeout,
            unhealthy_threshold=unhealthy_threshold,
            port=port,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             healthy_threshold: Optional[int] = None,
             interval: Optional[int] = None,
             path: Optional[str] = None,
             protocol: Optional[str] = None,
             timeout: Optional[int] = None,
             unhealthy_threshold: Optional[int] = None,
             port: Optional[int] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if healthy_threshold is None and 'healthyThreshold' in kwargs:
            healthy_threshold = kwargs['healthyThreshold']
        if healthy_threshold is None:
            raise TypeError("Missing 'healthy_threshold' argument")
        if interval is None:
            raise TypeError("Missing 'interval' argument")
        if path is None:
            raise TypeError("Missing 'path' argument")
        if protocol is None:
            raise TypeError("Missing 'protocol' argument")
        if timeout is None:
            raise TypeError("Missing 'timeout' argument")
        if unhealthy_threshold is None and 'unhealthyThreshold' in kwargs:
            unhealthy_threshold = kwargs['unhealthyThreshold']
        if unhealthy_threshold is None:
            raise TypeError("Missing 'unhealthy_threshold' argument")

        _setter("healthy_threshold", healthy_threshold)
        _setter("interval", interval)
        _setter("path", path)
        _setter("protocol", protocol)
        _setter("timeout", timeout)
        _setter("unhealthy_threshold", unhealthy_threshold)
        if port is not None:
            _setter("port", port)

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

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

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

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

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

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

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


@pulumi.output_type
class TargetSetTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        TargetSetTag._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            key=key,
            value=value,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             key: Optional[str] = None,
             value: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if key is None:
            raise TypeError("Missing 'key' argument")
        if value is None:
            raise TypeError("Missing 'value' argument")

        _setter("key", key)
        _setter("value", value)

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

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


@pulumi.output_type
class TargetTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        TargetTag._configure(
            lambda key, value: pulumi.set(__self__, key, value),
            key=key,
            value=value,
        )
    @staticmethod
    def _configure(
             _setter: Callable[[Any, Any], None],
             key: Optional[str] = None,
             value: Optional[str] = None,
             opts: Optional[pulumi.ResourceOptions] = None,
             **kwargs):
        if key is None:
            raise TypeError("Missing 'key' argument")
        if value is None:
            raise TypeError("Missing 'value' argument")

        _setter("key", key)
        _setter("value", value)

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

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


