# 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__ = [
    'LoadBalancerLinkArgs',
    'LoadBalancerNicArgs',
    'LoadBalancerRouteArgs',
    'LoadBalancerRouteHealthCheckConfigurationArgs',
    'LoadBalancerTagArgs',
    'LoadBalancerTargetArgs',
]

@pulumi.input_type
class LoadBalancerLinkArgs:
    def __init__(__self__, *,
                 rel: pulumi.Input[str],
                 href: Optional[pulumi.Input[str]] = None,
                 hrefs: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "rel", rel)
        if href is not None:
            pulumi.set(__self__, "href", href)
        if hrefs is not None:
            pulumi.set(__self__, "hrefs", hrefs)

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

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

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

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

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

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


@pulumi.input_type
class LoadBalancerNicArgs:
    def __init__(__self__, *,
                 network_id: pulumi.Input[str],
                 addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 custom_properties: Optional[pulumi.Input[Mapping[str, Any]]] = None,
                 description: Optional[pulumi.Input[str]] = None,
                 device_index: Optional[pulumi.Input[int]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Mapping[str, Any]] custom_properties: Additional custom properties that may be used to extend the machine.
        :param pulumi.Input[str] description: Describes machine within the scope of your organization and is not propagated to the cloud.
        :param pulumi.Input[str] name: A human-friendly name used as an identifier in APIs that support this option.
        """
        pulumi.set(__self__, "network_id", network_id)
        if addresses is not None:
            pulumi.set(__self__, "addresses", addresses)
        if custom_properties is not None:
            pulumi.set(__self__, "custom_properties", custom_properties)
        if description is not None:
            pulumi.set(__self__, "description", description)
        if device_index is not None:
            pulumi.set(__self__, "device_index", device_index)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if security_group_ids is not None:
            pulumi.set(__self__, "security_group_ids", security_group_ids)

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

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

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

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

    @property
    @pulumi.getter(name="customProperties")
    def custom_properties(self) -> Optional[pulumi.Input[Mapping[str, Any]]]:
        """
        Additional custom properties that may be used to extend the machine.
        """
        return pulumi.get(self, "custom_properties")

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

    @property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[str]]:
        """
        Describes machine within the scope of your organization and is not propagated to the cloud.
        """
        return pulumi.get(self, "description")

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

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

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

    @property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[str]]:
        """
        A human-friendly name used as an identifier in APIs that support this option.
        """
        return pulumi.get(self, "name")

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

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

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


@pulumi.input_type
class LoadBalancerRouteArgs:
    def __init__(__self__, *,
                 member_port: pulumi.Input[str],
                 member_protocol: pulumi.Input[str],
                 port: pulumi.Input[str],
                 protocol: pulumi.Input[str],
                 health_check_configurations: Optional[pulumi.Input[Sequence[pulumi.Input['LoadBalancerRouteHealthCheckConfigurationArgs']]]] = None):
        """
        :param pulumi.Input[str] member_port: Member port where the traffic is routed to.
        :param pulumi.Input[str] member_protocol: The protocol of the member traffic.
        :param pulumi.Input[str] port: Port which the load balancer is listening to.
        :param pulumi.Input[str] protocol: The protocol of the incoming load balancer requests.
        :param pulumi.Input[Sequence[pulumi.Input['LoadBalancerRouteHealthCheckConfigurationArgs']]] health_check_configurations: Load balancer health check configuration.
        """
        pulumi.set(__self__, "member_port", member_port)
        pulumi.set(__self__, "member_protocol", member_protocol)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)
        if health_check_configurations is not None:
            pulumi.set(__self__, "health_check_configurations", health_check_configurations)

    @property
    @pulumi.getter(name="memberPort")
    def member_port(self) -> pulumi.Input[str]:
        """
        Member port where the traffic is routed to.
        """
        return pulumi.get(self, "member_port")

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

    @property
    @pulumi.getter(name="memberProtocol")
    def member_protocol(self) -> pulumi.Input[str]:
        """
        The protocol of the member traffic.
        """
        return pulumi.get(self, "member_protocol")

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

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[str]:
        """
        Port which the load balancer is listening to.
        """
        return pulumi.get(self, "port")

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

    @property
    @pulumi.getter
    def protocol(self) -> pulumi.Input[str]:
        """
        The protocol of the incoming load balancer requests.
        """
        return pulumi.get(self, "protocol")

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

    @property
    @pulumi.getter(name="healthCheckConfigurations")
    def health_check_configurations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['LoadBalancerRouteHealthCheckConfigurationArgs']]]]:
        """
        Load balancer health check configuration.
        """
        return pulumi.get(self, "health_check_configurations")

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


@pulumi.input_type
class LoadBalancerRouteHealthCheckConfigurationArgs:
    def __init__(__self__, *,
                 port: pulumi.Input[str],
                 protocol: pulumi.Input[str],
                 healthy_threshold: Optional[pulumi.Input[int]] = None,
                 interval_seconds: Optional[pulumi.Input[int]] = None,
                 timeout_seconds: Optional[pulumi.Input[int]] = None,
                 unhealthy_threshold: Optional[pulumi.Input[int]] = None,
                 url_path: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] port: Port which the load balancer is listening to.
        :param pulumi.Input[str] protocol: The protocol of the incoming load balancer requests.
        :param pulumi.Input[int] healthy_threshold: Number of consecutive successful checks before considering a particular back-end instance as healthy.
        :param pulumi.Input[int] interval_seconds: Interval (in seconds) at which the health checks will be performed.
        :param pulumi.Input[int] timeout_seconds: Timeout (in seconds) to wait for a response from the back-end instance.
        """
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "protocol", protocol)
        if healthy_threshold is not None:
            pulumi.set(__self__, "healthy_threshold", healthy_threshold)
        if interval_seconds is not None:
            pulumi.set(__self__, "interval_seconds", interval_seconds)
        if timeout_seconds is not None:
            pulumi.set(__self__, "timeout_seconds", timeout_seconds)
        if unhealthy_threshold is not None:
            pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
        if url_path is not None:
            pulumi.set(__self__, "url_path", url_path)

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[str]:
        """
        Port which the load balancer is listening to.
        """
        return pulumi.get(self, "port")

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

    @property
    @pulumi.getter
    def protocol(self) -> pulumi.Input[str]:
        """
        The protocol of the incoming load balancer requests.
        """
        return pulumi.get(self, "protocol")

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

    @property
    @pulumi.getter(name="healthyThreshold")
    def healthy_threshold(self) -> Optional[pulumi.Input[int]]:
        """
        Number of consecutive successful checks before considering a particular back-end instance as healthy.
        """
        return pulumi.get(self, "healthy_threshold")

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

    @property
    @pulumi.getter(name="intervalSeconds")
    def interval_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Interval (in seconds) at which the health checks will be performed.
        """
        return pulumi.get(self, "interval_seconds")

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

    @property
    @pulumi.getter(name="timeoutSeconds")
    def timeout_seconds(self) -> Optional[pulumi.Input[int]]:
        """
        Timeout (in seconds) to wait for a response from the back-end instance.
        """
        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="unhealthyThreshold")
    def unhealthy_threshold(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "unhealthy_threshold")

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

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

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


@pulumi.input_type
class LoadBalancerTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: Tag’s key.
        :param pulumi.Input[str] value: Tag’s value.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

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

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

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


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

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

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

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

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


