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

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

__all__ = [
    'LoadBalancerAccessLoggingPolicy',
    'LoadBalancerAppCookieStickinessPolicy',
    'LoadBalancerConnectionDrainingPolicy',
    'LoadBalancerConnectionSettings',
    'LoadBalancerHealthCheck',
    'LoadBalancerLBCookieStickinessPolicy',
    'LoadBalancerListeners',
    'LoadBalancerPolicies',
    'LoadBalancerTag',
]

@pulumi.output_type
class LoadBalancerAccessLoggingPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "s3BucketName":
            suggest = "s3_bucket_name"
        elif key == "emitInterval":
            suggest = "emit_interval"
        elif key == "s3BucketPrefix":
            suggest = "s3_bucket_prefix"

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

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

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

    def __init__(__self__, *,
                 enabled: bool,
                 s3_bucket_name: str,
                 emit_interval: Optional[int] = None,
                 s3_bucket_prefix: Optional[str] = None):
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "s3_bucket_name", s3_bucket_name)
        if emit_interval is not None:
            pulumi.set(__self__, "emit_interval", emit_interval)
        if s3_bucket_prefix is not None:
            pulumi.set(__self__, "s3_bucket_prefix", s3_bucket_prefix)

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

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

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

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


@pulumi.output_type
class LoadBalancerAppCookieStickinessPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cookieName":
            suggest = "cookie_name"
        elif key == "policyName":
            suggest = "policy_name"

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

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

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

    def __init__(__self__, *,
                 cookie_name: str,
                 policy_name: str):
        pulumi.set(__self__, "cookie_name", cookie_name)
        pulumi.set(__self__, "policy_name", policy_name)

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

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


@pulumi.output_type
class LoadBalancerConnectionDrainingPolicy(dict):
    def __init__(__self__, *,
                 enabled: bool,
                 timeout: Optional[int] = None):
        pulumi.set(__self__, "enabled", enabled)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

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

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


@pulumi.output_type
class LoadBalancerConnectionSettings(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "idleTimeout":
            suggest = "idle_timeout"

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

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

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

    def __init__(__self__, *,
                 idle_timeout: int):
        pulumi.set(__self__, "idle_timeout", idle_timeout)

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


@pulumi.output_type
class LoadBalancerHealthCheck(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 LoadBalancerHealthCheck. Access the value via the '{suggest}' property getter instead.")

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

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

    def __init__(__self__, *,
                 healthy_threshold: str,
                 interval: str,
                 target: str,
                 timeout: str,
                 unhealthy_threshold: str):
        pulumi.set(__self__, "healthy_threshold", healthy_threshold)
        pulumi.set(__self__, "interval", interval)
        pulumi.set(__self__, "target", target)
        pulumi.set(__self__, "timeout", timeout)
        pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)

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

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

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

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

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


@pulumi.output_type
class LoadBalancerLBCookieStickinessPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cookieExpirationPeriod":
            suggest = "cookie_expiration_period"
        elif key == "policyName":
            suggest = "policy_name"

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

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

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

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

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

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


@pulumi.output_type
class LoadBalancerListeners(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "instancePort":
            suggest = "instance_port"
        elif key == "loadBalancerPort":
            suggest = "load_balancer_port"
        elif key == "instanceProtocol":
            suggest = "instance_protocol"
        elif key == "policyNames":
            suggest = "policy_names"
        elif key == "sSLCertificateId":
            suggest = "s_sl_certificate_id"

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

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

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

    def __init__(__self__, *,
                 instance_port: str,
                 load_balancer_port: str,
                 protocol: str,
                 instance_protocol: Optional[str] = None,
                 policy_names: Optional[Sequence[str]] = None,
                 s_sl_certificate_id: Optional[str] = None):
        pulumi.set(__self__, "instance_port", instance_port)
        pulumi.set(__self__, "load_balancer_port", load_balancer_port)
        pulumi.set(__self__, "protocol", protocol)
        if instance_protocol is not None:
            pulumi.set(__self__, "instance_protocol", instance_protocol)
        if policy_names is not None:
            pulumi.set(__self__, "policy_names", policy_names)
        if s_sl_certificate_id is not None:
            pulumi.set(__self__, "s_sl_certificate_id", s_sl_certificate_id)

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

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

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

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

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

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


@pulumi.output_type
class LoadBalancerPolicies(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "policyName":
            suggest = "policy_name"
        elif key == "policyType":
            suggest = "policy_type"
        elif key == "instancePorts":
            suggest = "instance_ports"
        elif key == "loadBalancerPorts":
            suggest = "load_balancer_ports"

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

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

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

    def __init__(__self__, *,
                 attributes: Sequence[Any],
                 policy_name: str,
                 policy_type: str,
                 instance_ports: Optional[Sequence[str]] = None,
                 load_balancer_ports: Optional[Sequence[str]] = None):
        pulumi.set(__self__, "attributes", attributes)
        pulumi.set(__self__, "policy_name", policy_name)
        pulumi.set(__self__, "policy_type", policy_type)
        if instance_ports is not None:
            pulumi.set(__self__, "instance_ports", instance_ports)
        if load_balancer_ports is not None:
            pulumi.set(__self__, "load_balancer_ports", load_balancer_ports)

    @property
    @pulumi.getter
    def attributes(self) -> Sequence[Any]:
        return pulumi.get(self, "attributes")

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

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

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

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


@pulumi.output_type
class LoadBalancerTag(dict):
    def __init__(__self__, *,
                 key: str,
                 value: str):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "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")


