# 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 warnings
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
from .. import _utilities
from . import outputs

__all__ = [
    'GtmASmapAssignment',
    'GtmASmapDefaultDatacenter',
    'GtmCidrmapAssignment',
    'GtmCidrmapDefaultDatacenter',
    'GtmDatacenterDefaultLoadObject',
    'GtmGeomapAssignment',
    'GtmGeomapDefaultDatacenter',
    'GtmPropertyLivenessTest',
    'GtmPropertyLivenessTestHttpHeader',
    'GtmPropertyStaticRrSet',
    'GtmPropertyTrafficTarget',
    'GtmResourceResourceInstance',
]

@pulumi.output_type
class GtmASmapAssignment(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "asNumbers":
            suggest = "as_numbers"
        elif key == "datacenterId":
            suggest = "datacenter_id"

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

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

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

    def __init__(__self__, *,
                 as_numbers: Sequence[int],
                 datacenter_id: int,
                 nickname: str):
        pulumi.set(__self__, "as_numbers", as_numbers)
        pulumi.set(__self__, "datacenter_id", datacenter_id)
        pulumi.set(__self__, "nickname", nickname)

    @property
    @pulumi.getter(name="asNumbers")
    def as_numbers(self) -> Sequence[int]:
        return pulumi.get(self, "as_numbers")

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

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


@pulumi.output_type
class GtmASmapDefaultDatacenter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "datacenterId":
            suggest = "datacenter_id"

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

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

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

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

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

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


@pulumi.output_type
class GtmCidrmapAssignment(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "datacenterId":
            suggest = "datacenter_id"

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

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

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

    def __init__(__self__, *,
                 datacenter_id: int,
                 nickname: str,
                 blocks: Optional[Sequence[str]] = None):
        pulumi.set(__self__, "datacenter_id", datacenter_id)
        pulumi.set(__self__, "nickname", nickname)
        if blocks is not None:
            pulumi.set(__self__, "blocks", blocks)

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

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

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


@pulumi.output_type
class GtmCidrmapDefaultDatacenter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "datacenterId":
            suggest = "datacenter_id"

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

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

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

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

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

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


@pulumi.output_type
class GtmDatacenterDefaultLoadObject(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "loadObject":
            suggest = "load_object"
        elif key == "loadObjectPort":
            suggest = "load_object_port"
        elif key == "loadServers":
            suggest = "load_servers"

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

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

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

    def __init__(__self__, *,
                 load_object: Optional[str] = None,
                 load_object_port: Optional[int] = None,
                 load_servers: Optional[Sequence[str]] = None):
        if load_object is not None:
            pulumi.set(__self__, "load_object", load_object)
        if load_object_port is not None:
            pulumi.set(__self__, "load_object_port", load_object_port)
        if load_servers is not None:
            pulumi.set(__self__, "load_servers", load_servers)

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

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

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


@pulumi.output_type
class GtmGeomapAssignment(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "datacenterId":
            suggest = "datacenter_id"

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

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

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

    def __init__(__self__, *,
                 datacenter_id: int,
                 nickname: str,
                 countries: Optional[Sequence[str]] = None):
        pulumi.set(__self__, "datacenter_id", datacenter_id)
        pulumi.set(__self__, "nickname", nickname)
        if countries is not None:
            pulumi.set(__self__, "countries", countries)

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

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

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


@pulumi.output_type
class GtmGeomapDefaultDatacenter(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "datacenterId":
            suggest = "datacenter_id"

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

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

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

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

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

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


@pulumi.output_type
class GtmPropertyLivenessTest(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "testInterval":
            suggest = "test_interval"
        elif key == "testObject":
            suggest = "test_object"
        elif key == "testObjectProtocol":
            suggest = "test_object_protocol"
        elif key == "testTimeout":
            suggest = "test_timeout"
        elif key == "answersRequired":
            suggest = "answers_required"
        elif key == "disableNonstandardPortWarning":
            suggest = "disable_nonstandard_port_warning"
        elif key == "errorPenalty":
            suggest = "error_penalty"
        elif key == "httpError3xx":
            suggest = "http_error3xx"
        elif key == "httpError4xx":
            suggest = "http_error4xx"
        elif key == "httpError5xx":
            suggest = "http_error5xx"
        elif key == "httpHeaders":
            suggest = "http_headers"
        elif key == "peerCertificateVerification":
            suggest = "peer_certificate_verification"
        elif key == "recursionRequested":
            suggest = "recursion_requested"
        elif key == "requestString":
            suggest = "request_string"
        elif key == "resourceType":
            suggest = "resource_type"
        elif key == "responseString":
            suggest = "response_string"
        elif key == "sslClientCertificate":
            suggest = "ssl_client_certificate"
        elif key == "sslClientPrivateKey":
            suggest = "ssl_client_private_key"
        elif key == "testObjectPassword":
            suggest = "test_object_password"
        elif key == "testObjectPort":
            suggest = "test_object_port"
        elif key == "testObjectUsername":
            suggest = "test_object_username"
        elif key == "timeoutPenalty":
            suggest = "timeout_penalty"

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

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

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

    def __init__(__self__, *,
                 name: str,
                 test_interval: int,
                 test_object: str,
                 test_object_protocol: str,
                 test_timeout: float,
                 answers_required: Optional[bool] = None,
                 disable_nonstandard_port_warning: Optional[bool] = None,
                 disabled: Optional[bool] = None,
                 error_penalty: Optional[float] = None,
                 http_error3xx: Optional[bool] = None,
                 http_error4xx: Optional[bool] = None,
                 http_error5xx: Optional[bool] = None,
                 http_headers: Optional[Sequence['outputs.GtmPropertyLivenessTestHttpHeader']] = None,
                 peer_certificate_verification: Optional[bool] = None,
                 recursion_requested: Optional[bool] = None,
                 request_string: Optional[str] = None,
                 resource_type: Optional[str] = None,
                 response_string: Optional[str] = None,
                 ssl_client_certificate: Optional[str] = None,
                 ssl_client_private_key: Optional[str] = None,
                 test_object_password: Optional[str] = None,
                 test_object_port: Optional[int] = None,
                 test_object_username: Optional[str] = None,
                 timeout_penalty: Optional[float] = None):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "test_interval", test_interval)
        pulumi.set(__self__, "test_object", test_object)
        pulumi.set(__self__, "test_object_protocol", test_object_protocol)
        pulumi.set(__self__, "test_timeout", test_timeout)
        if answers_required is not None:
            pulumi.set(__self__, "answers_required", answers_required)
        if disable_nonstandard_port_warning is not None:
            pulumi.set(__self__, "disable_nonstandard_port_warning", disable_nonstandard_port_warning)
        if disabled is not None:
            pulumi.set(__self__, "disabled", disabled)
        if error_penalty is not None:
            pulumi.set(__self__, "error_penalty", error_penalty)
        if http_error3xx is not None:
            pulumi.set(__self__, "http_error3xx", http_error3xx)
        if http_error4xx is not None:
            pulumi.set(__self__, "http_error4xx", http_error4xx)
        if http_error5xx is not None:
            pulumi.set(__self__, "http_error5xx", http_error5xx)
        if http_headers is not None:
            pulumi.set(__self__, "http_headers", http_headers)
        if peer_certificate_verification is not None:
            pulumi.set(__self__, "peer_certificate_verification", peer_certificate_verification)
        if recursion_requested is not None:
            pulumi.set(__self__, "recursion_requested", recursion_requested)
        if request_string is not None:
            pulumi.set(__self__, "request_string", request_string)
        if resource_type is not None:
            pulumi.set(__self__, "resource_type", resource_type)
        if response_string is not None:
            pulumi.set(__self__, "response_string", response_string)
        if ssl_client_certificate is not None:
            pulumi.set(__self__, "ssl_client_certificate", ssl_client_certificate)
        if ssl_client_private_key is not None:
            pulumi.set(__self__, "ssl_client_private_key", ssl_client_private_key)
        if test_object_password is not None:
            pulumi.set(__self__, "test_object_password", test_object_password)
        if test_object_port is not None:
            pulumi.set(__self__, "test_object_port", test_object_port)
        if test_object_username is not None:
            pulumi.set(__self__, "test_object_username", test_object_username)
        if timeout_penalty is not None:
            pulumi.set(__self__, "timeout_penalty", timeout_penalty)

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

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

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

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

    @property
    @pulumi.getter(name="testTimeout")
    def test_timeout(self) -> float:
        return pulumi.get(self, "test_timeout")

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

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

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

    @property
    @pulumi.getter(name="errorPenalty")
    def error_penalty(self) -> Optional[float]:
        return pulumi.get(self, "error_penalty")

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

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

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

    @property
    @pulumi.getter(name="httpHeaders")
    def http_headers(self) -> Optional[Sequence['outputs.GtmPropertyLivenessTestHttpHeader']]:
        return pulumi.get(self, "http_headers")

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

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

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

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

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

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

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

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

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

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

    @property
    @pulumi.getter(name="timeoutPenalty")
    def timeout_penalty(self) -> Optional[float]:
        return pulumi.get(self, "timeout_penalty")


@pulumi.output_type
class GtmPropertyLivenessTestHttpHeader(dict):
    def __init__(__self__, *,
                 name: Optional[str] = None,
                 value: Optional[str] = None):
        if name is not None:
            pulumi.set(__self__, "name", name)
        if value is not None:
            pulumi.set(__self__, "value", value)

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

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


@pulumi.output_type
class GtmPropertyStaticRrSet(dict):
    def __init__(__self__, *,
                 rdatas: Optional[Sequence[str]] = None,
                 ttl: Optional[int] = None,
                 type: Optional[str] = None):
        if rdatas is not None:
            pulumi.set(__self__, "rdatas", rdatas)
        if ttl is not None:
            pulumi.set(__self__, "ttl", ttl)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

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

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


@pulumi.output_type
class GtmPropertyTrafficTarget(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "datacenterId":
            suggest = "datacenter_id"
        elif key == "handoutCname":
            suggest = "handout_cname"

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

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

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

    def __init__(__self__, *,
                 datacenter_id: Optional[int] = None,
                 enabled: Optional[bool] = None,
                 handout_cname: Optional[str] = None,
                 name: Optional[str] = None,
                 servers: Optional[Sequence[str]] = None,
                 weight: Optional[float] = None):
        if datacenter_id is not None:
            pulumi.set(__self__, "datacenter_id", datacenter_id)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if handout_cname is not None:
            pulumi.set(__self__, "handout_cname", handout_cname)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if servers is not None:
            pulumi.set(__self__, "servers", servers)
        if weight is not None:
            pulumi.set(__self__, "weight", weight)

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

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

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

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

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

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


@pulumi.output_type
class GtmResourceResourceInstance(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "datacenterId":
            suggest = "datacenter_id"
        elif key == "loadObject":
            suggest = "load_object"
        elif key == "loadObjectPort":
            suggest = "load_object_port"
        elif key == "loadServers":
            suggest = "load_servers"
        elif key == "useDefaultLoadObject":
            suggest = "use_default_load_object"

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

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

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

    def __init__(__self__, *,
                 datacenter_id: int,
                 load_object: Optional[str] = None,
                 load_object_port: Optional[int] = None,
                 load_servers: Optional[Sequence[str]] = None,
                 use_default_load_object: Optional[bool] = None):
        pulumi.set(__self__, "datacenter_id", datacenter_id)
        if load_object is not None:
            pulumi.set(__self__, "load_object", load_object)
        if load_object_port is not None:
            pulumi.set(__self__, "load_object_port", load_object_port)
        if load_servers is not None:
            pulumi.set(__self__, "load_servers", load_servers)
        if use_default_load_object is not None:
            pulumi.set(__self__, "use_default_load_object", use_default_load_object)

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

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

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

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

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


