# 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__ = [
    'CpsDvEnrollmentAdminContact',
    'CpsDvEnrollmentCsr',
    'CpsDvEnrollmentDnsChallenge',
    'CpsDvEnrollmentHttpChallenge',
    'CpsDvEnrollmentNetworkConfiguration',
    'CpsDvEnrollmentNetworkConfigurationClientMutualAuthentication',
    'CpsDvEnrollmentOrganization',
    'CpsDvEnrollmentTechContact',
    'DnsZoneTsigKey',
    'GtmAsmapAssignment',
    'GtmAsmapDefaultDatacenter',
    'GtmCidrmapAssignment',
    'GtmCidrmapDefaultDatacenter',
    'GtmDatacenterDefaultLoadObject',
    'GtmGeomapAssignment',
    'GtmGeomapDefaultDatacenter',
    'GtmPropertyLivenessTest',
    'GtmPropertyLivenessTestHttpHeader',
    'GtmPropertyStaticRrSet',
    'GtmPropertyTrafficTarget',
    'GtmResourceResourceInstance',
    'PropertyActivationRuleError',
    'PropertyActivationRuleWarning',
    'PropertyHostname',
    'PropertyHostnameCertStatus',
    'PropertyOrigin',
    'PropertyRuleError',
    'PropertyRuleWarning',
    'PropertyVariablesVariable',
    'PropertyVariablesVariableVariable',
    'ProviderAppsec',
    'ProviderConfig',
    'ProviderDns',
    'ProviderGtm',
    'ProviderNetwork',
    'ProviderProperty',
    'GetContractsContractResult',
    'GetGroupsGroupResult',
    'GetPropertiesPropertyResult',
    'GetPropertyHostnamesHostnameResult',
    'GetPropertyHostnamesHostnameCertStatusResult',
    'GetPropertyProductsProductResult',
    'GetPropertyRulesTemplateVariableResult',
]

@pulumi.output_type
class CpsDvEnrollmentAdminContact(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "addressLineOne":
            suggest = "address_line_one"
        elif key == "countryCode":
            suggest = "country_code"
        elif key == "firstName":
            suggest = "first_name"
        elif key == "lastName":
            suggest = "last_name"
        elif key == "postalCode":
            suggest = "postal_code"
        elif key == "addressLineTwo":
            suggest = "address_line_two"

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

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

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

    def __init__(__self__, *,
                 address_line_one: str,
                 city: str,
                 country_code: str,
                 email: str,
                 first_name: str,
                 last_name: str,
                 organization: str,
                 phone: str,
                 postal_code: str,
                 region: str,
                 address_line_two: Optional[str] = None,
                 title: Optional[str] = None):
        pulumi.set(__self__, "address_line_one", address_line_one)
        pulumi.set(__self__, "city", city)
        pulumi.set(__self__, "country_code", country_code)
        pulumi.set(__self__, "email", email)
        pulumi.set(__self__, "first_name", first_name)
        pulumi.set(__self__, "last_name", last_name)
        pulumi.set(__self__, "organization", organization)
        pulumi.set(__self__, "phone", phone)
        pulumi.set(__self__, "postal_code", postal_code)
        pulumi.set(__self__, "region", region)
        if address_line_two is not None:
            pulumi.set(__self__, "address_line_two", address_line_two)
        if title is not None:
            pulumi.set(__self__, "title", title)

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class CpsDvEnrollmentCsr(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "countryCode":
            suggest = "country_code"
        elif key == "organizationalUnit":
            suggest = "organizational_unit"

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

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

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

    def __init__(__self__, *,
                 city: str,
                 country_code: str,
                 organization: str,
                 organizational_unit: str,
                 state: str):
        pulumi.set(__self__, "city", city)
        pulumi.set(__self__, "country_code", country_code)
        pulumi.set(__self__, "organization", organization)
        pulumi.set(__self__, "organizational_unit", organizational_unit)
        pulumi.set(__self__, "state", state)

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

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

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

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

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


@pulumi.output_type
class CpsDvEnrollmentDnsChallenge(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fullPath":
            suggest = "full_path"
        elif key == "responseBody":
            suggest = "response_body"

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

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

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

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

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

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

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


@pulumi.output_type
class CpsDvEnrollmentHttpChallenge(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "fullPath":
            suggest = "full_path"
        elif key == "responseBody":
            suggest = "response_body"

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

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

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

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

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

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

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


@pulumi.output_type
class CpsDvEnrollmentNetworkConfiguration(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientMutualAuthentication":
            suggest = "client_mutual_authentication"
        elif key == "cloneDnsNames":
            suggest = "clone_dns_names"
        elif key == "disallowedTlsVersions":
            suggest = "disallowed_tls_versions"
        elif key == "mustHaveCiphers":
            suggest = "must_have_ciphers"
        elif key == "ocspStapling":
            suggest = "ocsp_stapling"
        elif key == "preferredCiphers":
            suggest = "preferred_ciphers"
        elif key == "quicEnabled":
            suggest = "quic_enabled"

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

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

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

    def __init__(__self__, *,
                 geography: str,
                 client_mutual_authentication: Optional['outputs.CpsDvEnrollmentNetworkConfigurationClientMutualAuthentication'] = None,
                 clone_dns_names: Optional[bool] = None,
                 disallowed_tls_versions: Optional[Sequence[str]] = None,
                 must_have_ciphers: Optional[str] = None,
                 ocsp_stapling: Optional[str] = None,
                 preferred_ciphers: Optional[str] = None,
                 quic_enabled: Optional[bool] = None):
        pulumi.set(__self__, "geography", geography)
        if client_mutual_authentication is not None:
            pulumi.set(__self__, "client_mutual_authentication", client_mutual_authentication)
        if clone_dns_names is not None:
            pulumi.set(__self__, "clone_dns_names", clone_dns_names)
        if disallowed_tls_versions is not None:
            pulumi.set(__self__, "disallowed_tls_versions", disallowed_tls_versions)
        if must_have_ciphers is not None:
            pulumi.set(__self__, "must_have_ciphers", must_have_ciphers)
        if ocsp_stapling is not None:
            pulumi.set(__self__, "ocsp_stapling", ocsp_stapling)
        if preferred_ciphers is not None:
            pulumi.set(__self__, "preferred_ciphers", preferred_ciphers)
        if quic_enabled is not None:
            pulumi.set(__self__, "quic_enabled", quic_enabled)

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

    @property
    @pulumi.getter(name="clientMutualAuthentication")
    def client_mutual_authentication(self) -> Optional['outputs.CpsDvEnrollmentNetworkConfigurationClientMutualAuthentication']:
        return pulumi.get(self, "client_mutual_authentication")

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

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

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

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

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

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


@pulumi.output_type
class CpsDvEnrollmentNetworkConfigurationClientMutualAuthentication(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "ocspEnabled":
            suggest = "ocsp_enabled"
        elif key == "sendCaListToClient":
            suggest = "send_ca_list_to_client"
        elif key == "setId":
            suggest = "set_id"

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

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

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

    def __init__(__self__, *,
                 ocsp_enabled: Optional[bool] = None,
                 send_ca_list_to_client: Optional[bool] = None,
                 set_id: Optional[str] = None):
        if ocsp_enabled is not None:
            pulumi.set(__self__, "ocsp_enabled", ocsp_enabled)
        if send_ca_list_to_client is not None:
            pulumi.set(__self__, "send_ca_list_to_client", send_ca_list_to_client)
        if set_id is not None:
            pulumi.set(__self__, "set_id", set_id)

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

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

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


@pulumi.output_type
class CpsDvEnrollmentOrganization(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "addressLineOne":
            suggest = "address_line_one"
        elif key == "countryCode":
            suggest = "country_code"
        elif key == "postalCode":
            suggest = "postal_code"
        elif key == "addressLineTwo":
            suggest = "address_line_two"

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

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

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

    def __init__(__self__, *,
                 address_line_one: str,
                 city: str,
                 country_code: str,
                 name: str,
                 phone: str,
                 postal_code: str,
                 region: str,
                 address_line_two: Optional[str] = None):
        pulumi.set(__self__, "address_line_one", address_line_one)
        pulumi.set(__self__, "city", city)
        pulumi.set(__self__, "country_code", country_code)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "phone", phone)
        pulumi.set(__self__, "postal_code", postal_code)
        pulumi.set(__self__, "region", region)
        if address_line_two is not None:
            pulumi.set(__self__, "address_line_two", address_line_two)

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

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

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

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

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

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

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

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


@pulumi.output_type
class CpsDvEnrollmentTechContact(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "addressLineOne":
            suggest = "address_line_one"
        elif key == "countryCode":
            suggest = "country_code"
        elif key == "firstName":
            suggest = "first_name"
        elif key == "lastName":
            suggest = "last_name"
        elif key == "postalCode":
            suggest = "postal_code"
        elif key == "addressLineTwo":
            suggest = "address_line_two"

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

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

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

    def __init__(__self__, *,
                 address_line_one: str,
                 city: str,
                 country_code: str,
                 email: str,
                 first_name: str,
                 last_name: str,
                 organization: str,
                 phone: str,
                 postal_code: str,
                 region: str,
                 address_line_two: Optional[str] = None,
                 title: Optional[str] = None):
        pulumi.set(__self__, "address_line_one", address_line_one)
        pulumi.set(__self__, "city", city)
        pulumi.set(__self__, "country_code", country_code)
        pulumi.set(__self__, "email", email)
        pulumi.set(__self__, "first_name", first_name)
        pulumi.set(__self__, "last_name", last_name)
        pulumi.set(__self__, "organization", organization)
        pulumi.set(__self__, "phone", phone)
        pulumi.set(__self__, "postal_code", postal_code)
        pulumi.set(__self__, "region", region)
        if address_line_two is not None:
            pulumi.set(__self__, "address_line_two", address_line_two)
        if title is not None:
            pulumi.set(__self__, "title", title)

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

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

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class DnsZoneTsigKey(dict):
    def __init__(__self__, *,
                 algorithm: str,
                 name: str,
                 secret: str):
        pulumi.set(__self__, "algorithm", algorithm)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "secret", secret)

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

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

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


@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")


@pulumi.output_type
class PropertyActivationRuleError(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "behaviorName":
            suggest = "behavior_name"
        elif key == "errorLocation":
            suggest = "error_location"
        elif key == "statusCode":
            suggest = "status_code"

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

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

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

    def __init__(__self__, *,
                 behavior_name: Optional[str] = None,
                 detail: Optional[str] = None,
                 error_location: Optional[str] = None,
                 instance: Optional[str] = None,
                 status_code: Optional[int] = None,
                 title: Optional[str] = None,
                 type: Optional[str] = None):
        if behavior_name is not None:
            pulumi.set(__self__, "behavior_name", behavior_name)
        if detail is not None:
            pulumi.set(__self__, "detail", detail)
        if error_location is not None:
            pulumi.set(__self__, "error_location", error_location)
        if instance is not None:
            pulumi.set(__self__, "instance", instance)
        if status_code is not None:
            pulumi.set(__self__, "status_code", status_code)
        if title is not None:
            pulumi.set(__self__, "title", title)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

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

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

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

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

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

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


@pulumi.output_type
class PropertyActivationRuleWarning(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "behaviorName":
            suggest = "behavior_name"
        elif key == "errorLocation":
            suggest = "error_location"
        elif key == "statusCode":
            suggest = "status_code"

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

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

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

    def __init__(__self__, *,
                 behavior_name: Optional[str] = None,
                 detail: Optional[str] = None,
                 error_location: Optional[str] = None,
                 instance: Optional[str] = None,
                 status_code: Optional[int] = None,
                 title: Optional[str] = None,
                 type: Optional[str] = None):
        if behavior_name is not None:
            pulumi.set(__self__, "behavior_name", behavior_name)
        if detail is not None:
            pulumi.set(__self__, "detail", detail)
        if error_location is not None:
            pulumi.set(__self__, "error_location", error_location)
        if instance is not None:
            pulumi.set(__self__, "instance", instance)
        if status_code is not None:
            pulumi.set(__self__, "status_code", status_code)
        if title is not None:
            pulumi.set(__self__, "title", title)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

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

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

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

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

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

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


@pulumi.output_type
class PropertyHostname(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certProvisioningType":
            suggest = "cert_provisioning_type"
        elif key == "cnameFrom":
            suggest = "cname_from"
        elif key == "cnameTo":
            suggest = "cname_to"
        elif key == "certStatuses":
            suggest = "cert_statuses"
        elif key == "cnameType":
            suggest = "cname_type"
        elif key == "edgeHostnameId":
            suggest = "edge_hostname_id"

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

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

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

    def __init__(__self__, *,
                 cert_provisioning_type: str,
                 cname_from: str,
                 cname_to: str,
                 cert_statuses: Optional[Sequence['outputs.PropertyHostnameCertStatus']] = None,
                 cname_type: Optional[str] = None,
                 edge_hostname_id: Optional[str] = None):
        pulumi.set(__self__, "cert_provisioning_type", cert_provisioning_type)
        pulumi.set(__self__, "cname_from", cname_from)
        pulumi.set(__self__, "cname_to", cname_to)
        if cert_statuses is not None:
            pulumi.set(__self__, "cert_statuses", cert_statuses)
        if cname_type is not None:
            pulumi.set(__self__, "cname_type", cname_type)
        if edge_hostname_id is not None:
            pulumi.set(__self__, "edge_hostname_id", edge_hostname_id)

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

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

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

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

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

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


@pulumi.output_type
class PropertyHostnameCertStatus(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "productionStatus":
            suggest = "production_status"
        elif key == "stagingStatus":
            suggest = "staging_status"

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

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

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

    def __init__(__self__, *,
                 hostname: Optional[str] = None,
                 production_status: Optional[str] = None,
                 staging_status: Optional[str] = None,
                 target: Optional[str] = None):
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if production_status is not None:
            pulumi.set(__self__, "production_status", production_status)
        if staging_status is not None:
            pulumi.set(__self__, "staging_status", staging_status)
        if target is not None:
            pulumi.set(__self__, "target", target)

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

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

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

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


@pulumi.output_type
class PropertyOrigin(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "cacheKeyHostname":
            suggest = "cache_key_hostname"
        elif key == "enableTrueClientIp":
            suggest = "enable_true_client_ip"
        elif key == "forwardHostname":
            suggest = "forward_hostname"

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

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

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

    def __init__(__self__, *,
                 cache_key_hostname: Optional[str] = None,
                 compress: Optional[bool] = None,
                 enable_true_client_ip: Optional[bool] = None,
                 forward_hostname: Optional[str] = None,
                 hostname: Optional[str] = None,
                 port: Optional[int] = None):
        if cache_key_hostname is not None:
            pulumi.set(__self__, "cache_key_hostname", cache_key_hostname)
        if compress is not None:
            pulumi.set(__self__, "compress", compress)
        if enable_true_client_ip is not None:
            pulumi.set(__self__, "enable_true_client_ip", enable_true_client_ip)
        if forward_hostname is not None:
            pulumi.set(__self__, "forward_hostname", forward_hostname)
        if hostname is not None:
            pulumi.set(__self__, "hostname", hostname)
        if port is not None:
            pulumi.set(__self__, "port", port)

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

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

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

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

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

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


@pulumi.output_type
class PropertyRuleError(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "behaviorName":
            suggest = "behavior_name"
        elif key == "errorLocation":
            suggest = "error_location"
        elif key == "statusCode":
            suggest = "status_code"

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

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

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

    def __init__(__self__, *,
                 behavior_name: Optional[str] = None,
                 detail: Optional[str] = None,
                 error_location: Optional[str] = None,
                 instance: Optional[str] = None,
                 status_code: Optional[int] = None,
                 title: Optional[str] = None,
                 type: Optional[str] = None):
        if behavior_name is not None:
            pulumi.set(__self__, "behavior_name", behavior_name)
        if detail is not None:
            pulumi.set(__self__, "detail", detail)
        if error_location is not None:
            pulumi.set(__self__, "error_location", error_location)
        if instance is not None:
            pulumi.set(__self__, "instance", instance)
        if status_code is not None:
            pulumi.set(__self__, "status_code", status_code)
        if title is not None:
            pulumi.set(__self__, "title", title)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

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

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

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

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

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

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


@pulumi.output_type
class PropertyRuleWarning(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "behaviorName":
            suggest = "behavior_name"
        elif key == "errorLocation":
            suggest = "error_location"
        elif key == "statusCode":
            suggest = "status_code"

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

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

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

    def __init__(__self__, *,
                 behavior_name: Optional[str] = None,
                 detail: Optional[str] = None,
                 error_location: Optional[str] = None,
                 instance: Optional[str] = None,
                 status_code: Optional[int] = None,
                 title: Optional[str] = None,
                 type: Optional[str] = None):
        if behavior_name is not None:
            pulumi.set(__self__, "behavior_name", behavior_name)
        if detail is not None:
            pulumi.set(__self__, "detail", detail)
        if error_location is not None:
            pulumi.set(__self__, "error_location", error_location)
        if instance is not None:
            pulumi.set(__self__, "instance", instance)
        if status_code is not None:
            pulumi.set(__self__, "status_code", status_code)
        if title is not None:
            pulumi.set(__self__, "title", title)
        if type is not None:
            pulumi.set(__self__, "type", type)

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

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

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

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

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

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

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


@pulumi.output_type
class PropertyVariablesVariable(dict):
    def __init__(__self__, *,
                 variables: Optional[Sequence['outputs.PropertyVariablesVariableVariable']] = None):
        if variables is not None:
            pulumi.set(__self__, "variables", variables)

    @property
    @pulumi.getter
    def variables(self) -> Optional[Sequence['outputs.PropertyVariablesVariableVariable']]:
        return pulumi.get(self, "variables")


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

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

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

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

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

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


@pulumi.output_type
class ProviderAppsec(dict):
    def __init__(__self__, *,
                 access_token: Optional[str] = None,
                 account_key: Optional[str] = None,
                 client_secret: Optional[str] = None,
                 client_token: Optional[str] = None,
                 host: Optional[str] = None,
                 max_body: Optional[int] = None):
        if access_token is not None:
            pulumi.set(__self__, "access_token", access_token)
        if account_key is not None:
            pulumi.set(__self__, "account_key", account_key)
        if client_secret is not None:
            pulumi.set(__self__, "client_secret", client_secret)
        if client_token is not None:
            pulumi.set(__self__, "client_token", client_token)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if max_body is not None:
            pulumi.set(__self__, "max_body", max_body)

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

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

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

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

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

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


@pulumi.output_type
class ProviderConfig(dict):
    def __init__(__self__, *,
                 access_token: Optional[str] = None,
                 account_key: Optional[str] = None,
                 client_secret: Optional[str] = None,
                 client_token: Optional[str] = None,
                 host: Optional[str] = None,
                 max_body: Optional[int] = None):
        if access_token is not None:
            pulumi.set(__self__, "access_token", access_token)
        if account_key is not None:
            pulumi.set(__self__, "account_key", account_key)
        if client_secret is not None:
            pulumi.set(__self__, "client_secret", client_secret)
        if client_token is not None:
            pulumi.set(__self__, "client_token", client_token)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if max_body is not None:
            pulumi.set(__self__, "max_body", max_body)

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

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

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

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

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

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


@pulumi.output_type
class ProviderDns(dict):
    def __init__(__self__, *,
                 access_token: Optional[str] = None,
                 account_key: Optional[str] = None,
                 client_secret: Optional[str] = None,
                 client_token: Optional[str] = None,
                 host: Optional[str] = None,
                 max_body: Optional[int] = None):
        if access_token is not None:
            pulumi.set(__self__, "access_token", access_token)
        if account_key is not None:
            pulumi.set(__self__, "account_key", account_key)
        if client_secret is not None:
            pulumi.set(__self__, "client_secret", client_secret)
        if client_token is not None:
            pulumi.set(__self__, "client_token", client_token)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if max_body is not None:
            pulumi.set(__self__, "max_body", max_body)

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

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

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

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

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

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


@pulumi.output_type
class ProviderGtm(dict):
    def __init__(__self__, *,
                 access_token: Optional[str] = None,
                 account_key: Optional[str] = None,
                 client_secret: Optional[str] = None,
                 client_token: Optional[str] = None,
                 host: Optional[str] = None,
                 max_body: Optional[int] = None):
        if access_token is not None:
            pulumi.set(__self__, "access_token", access_token)
        if account_key is not None:
            pulumi.set(__self__, "account_key", account_key)
        if client_secret is not None:
            pulumi.set(__self__, "client_secret", client_secret)
        if client_token is not None:
            pulumi.set(__self__, "client_token", client_token)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if max_body is not None:
            pulumi.set(__self__, "max_body", max_body)

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

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

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

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

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

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


@pulumi.output_type
class ProviderNetwork(dict):
    def __init__(__self__, *,
                 access_token: Optional[str] = None,
                 account_key: Optional[str] = None,
                 client_secret: Optional[str] = None,
                 client_token: Optional[str] = None,
                 host: Optional[str] = None,
                 max_body: Optional[int] = None):
        if access_token is not None:
            pulumi.set(__self__, "access_token", access_token)
        if account_key is not None:
            pulumi.set(__self__, "account_key", account_key)
        if client_secret is not None:
            pulumi.set(__self__, "client_secret", client_secret)
        if client_token is not None:
            pulumi.set(__self__, "client_token", client_token)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if max_body is not None:
            pulumi.set(__self__, "max_body", max_body)

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

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

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

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

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

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


@pulumi.output_type
class ProviderProperty(dict):
    def __init__(__self__, *,
                 access_token: Optional[str] = None,
                 account_key: Optional[str] = None,
                 client_secret: Optional[str] = None,
                 client_token: Optional[str] = None,
                 host: Optional[str] = None,
                 max_body: Optional[int] = None):
        if access_token is not None:
            pulumi.set(__self__, "access_token", access_token)
        if account_key is not None:
            pulumi.set(__self__, "account_key", account_key)
        if client_secret is not None:
            pulumi.set(__self__, "client_secret", client_secret)
        if client_token is not None:
            pulumi.set(__self__, "client_token", client_token)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if max_body is not None:
            pulumi.set(__self__, "max_body", max_body)

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

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

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

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

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

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


@pulumi.output_type
class GetContractsContractResult(dict):
    def __init__(__self__, *,
                 contract_id: str,
                 contract_type_name: str):
        pulumi.set(__self__, "contract_id", contract_id)
        pulumi.set(__self__, "contract_type_name", contract_type_name)

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

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


@pulumi.output_type
class GetGroupsGroupResult(dict):
    def __init__(__self__, *,
                 contract_ids: Sequence[str],
                 group_id: str,
                 group_name: str,
                 parent_group_id: str):
        pulumi.set(__self__, "contract_ids", contract_ids)
        pulumi.set(__self__, "group_id", group_id)
        pulumi.set(__self__, "group_name", group_name)
        pulumi.set(__self__, "parent_group_id", parent_group_id)

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

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

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

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


@pulumi.output_type
class GetPropertiesPropertyResult(dict):
    def __init__(__self__, *,
                 contract_id: str,
                 group_id: str,
                 latest_version: int,
                 note: str,
                 product_id: str,
                 production_version: int,
                 property_id: str,
                 property_name: str,
                 rule_format: str,
                 staging_version: int):
        pulumi.set(__self__, "contract_id", contract_id)
        pulumi.set(__self__, "group_id", group_id)
        pulumi.set(__self__, "latest_version", latest_version)
        pulumi.set(__self__, "note", note)
        pulumi.set(__self__, "product_id", product_id)
        pulumi.set(__self__, "production_version", production_version)
        pulumi.set(__self__, "property_id", property_id)
        pulumi.set(__self__, "property_name", property_name)
        pulumi.set(__self__, "rule_format", rule_format)
        pulumi.set(__self__, "staging_version", staging_version)

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

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

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

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

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

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

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

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

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

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


@pulumi.output_type
class GetPropertyHostnamesHostnameResult(dict):
    def __init__(__self__, *,
                 cert_provisioning_type: str,
                 cert_statuses: Sequence['outputs.GetPropertyHostnamesHostnameCertStatusResult'],
                 cname_from: str,
                 cname_to: str,
                 cname_type: str,
                 edge_hostname_id: str):
        pulumi.set(__self__, "cert_provisioning_type", cert_provisioning_type)
        pulumi.set(__self__, "cert_statuses", cert_statuses)
        pulumi.set(__self__, "cname_from", cname_from)
        pulumi.set(__self__, "cname_to", cname_to)
        pulumi.set(__self__, "cname_type", cname_type)
        pulumi.set(__self__, "edge_hostname_id", edge_hostname_id)

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

    @property
    @pulumi.getter(name="certStatuses")
    def cert_statuses(self) -> Sequence['outputs.GetPropertyHostnamesHostnameCertStatusResult']:
        return pulumi.get(self, "cert_statuses")

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

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

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

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


@pulumi.output_type
class GetPropertyHostnamesHostnameCertStatusResult(dict):
    def __init__(__self__, *,
                 hostname: str,
                 production_status: str,
                 staging_status: str,
                 target: str):
        pulumi.set(__self__, "hostname", hostname)
        pulumi.set(__self__, "production_status", production_status)
        pulumi.set(__self__, "staging_status", staging_status)
        pulumi.set(__self__, "target", target)

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

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

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

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


@pulumi.output_type
class GetPropertyProductsProductResult(dict):
    def __init__(__self__, *,
                 product_id: str,
                 product_name: str):
        pulumi.set(__self__, "product_id", product_id)
        pulumi.set(__self__, "product_name", product_name)

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

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


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

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

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

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


