# 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__ = [
    'ClusterAzureActiveDirectory',
    'ClusterCertificate',
    'ClusterCertificateCommonNames',
    'ClusterCertificateCommonNamesCommonName',
    'ClusterClientCertificateCommonName',
    'ClusterClientCertificateThumbprint',
    'ClusterDiagnosticsConfig',
    'ClusterFabricSetting',
    'ClusterNodeType',
    'ClusterNodeTypeApplicationPorts',
    'ClusterNodeTypeEphemeralPorts',
    'ClusterReverseProxyCertificate',
    'ClusterReverseProxyCertificateCommonNames',
    'ClusterReverseProxyCertificateCommonNamesCommonName',
    'ClusterUpgradePolicy',
    'ClusterUpgradePolicyDeltaHealthPolicy',
    'ClusterUpgradePolicyHealthPolicy',
    'MeshApplicationService',
    'MeshApplicationServiceCodePackage',
    'MeshApplicationServiceCodePackageResources',
    'MeshApplicationServiceCodePackageResourcesLimits',
    'MeshApplicationServiceCodePackageResourcesRequests',
]

@pulumi.output_type
class ClusterAzureActiveDirectory(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientApplicationId":
            suggest = "client_application_id"
        elif key == "clusterApplicationId":
            suggest = "cluster_application_id"
        elif key == "tenantId":
            suggest = "tenant_id"

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

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

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

    def __init__(__self__, *,
                 client_application_id: str,
                 cluster_application_id: str,
                 tenant_id: str):
        """
        :param str client_application_id: The Azure Active Directory Client ID which should be used for the Client Application.
        :param str cluster_application_id: The Azure Active Directory Cluster Application ID.
        :param str tenant_id: The Azure Active Directory Tenant ID.
        """
        pulumi.set(__self__, "client_application_id", client_application_id)
        pulumi.set(__self__, "cluster_application_id", cluster_application_id)
        pulumi.set(__self__, "tenant_id", tenant_id)

    @property
    @pulumi.getter(name="clientApplicationId")
    def client_application_id(self) -> str:
        """
        The Azure Active Directory Client ID which should be used for the Client Application.
        """
        return pulumi.get(self, "client_application_id")

    @property
    @pulumi.getter(name="clusterApplicationId")
    def cluster_application_id(self) -> str:
        """
        The Azure Active Directory Cluster Application ID.
        """
        return pulumi.get(self, "cluster_application_id")

    @property
    @pulumi.getter(name="tenantId")
    def tenant_id(self) -> str:
        """
        The Azure Active Directory Tenant ID.
        """
        return pulumi.get(self, "tenant_id")


@pulumi.output_type
class ClusterCertificate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "x509StoreName":
            suggest = "x509_store_name"
        elif key == "thumbprintSecondary":
            suggest = "thumbprint_secondary"

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

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

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

    def __init__(__self__, *,
                 thumbprint: str,
                 x509_store_name: str,
                 thumbprint_secondary: Optional[str] = None):
        """
        :param str thumbprint: The Thumbprint of the Certificate.
        :param str x509_store_name: The X509 Store where the Certificate Exists, such as `My`.
        :param str thumbprint_secondary: The Secondary Thumbprint of the Certificate.
        """
        pulumi.set(__self__, "thumbprint", thumbprint)
        pulumi.set(__self__, "x509_store_name", x509_store_name)
        if thumbprint_secondary is not None:
            pulumi.set(__self__, "thumbprint_secondary", thumbprint_secondary)

    @property
    @pulumi.getter
    def thumbprint(self) -> str:
        """
        The Thumbprint of the Certificate.
        """
        return pulumi.get(self, "thumbprint")

    @property
    @pulumi.getter(name="x509StoreName")
    def x509_store_name(self) -> str:
        """
        The X509 Store where the Certificate Exists, such as `My`.
        """
        return pulumi.get(self, "x509_store_name")

    @property
    @pulumi.getter(name="thumbprintSecondary")
    def thumbprint_secondary(self) -> Optional[str]:
        """
        The Secondary Thumbprint of the Certificate.
        """
        return pulumi.get(self, "thumbprint_secondary")


@pulumi.output_type
class ClusterCertificateCommonNames(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "commonNames":
            suggest = "common_names"
        elif key == "x509StoreName":
            suggest = "x509_store_name"

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

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

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

    def __init__(__self__, *,
                 common_names: Sequence['outputs.ClusterCertificateCommonNamesCommonName'],
                 x509_store_name: str):
        """
        :param Sequence['ClusterCertificateCommonNamesCommonNameArgs'] common_names: A `common_names` block as defined below.
        :param str x509_store_name: The X509 Store where the Certificate Exists, such as `My`.
        """
        pulumi.set(__self__, "common_names", common_names)
        pulumi.set(__self__, "x509_store_name", x509_store_name)

    @property
    @pulumi.getter(name="commonNames")
    def common_names(self) -> Sequence['outputs.ClusterCertificateCommonNamesCommonName']:
        """
        A `common_names` block as defined below.
        """
        return pulumi.get(self, "common_names")

    @property
    @pulumi.getter(name="x509StoreName")
    def x509_store_name(self) -> str:
        """
        The X509 Store where the Certificate Exists, such as `My`.
        """
        return pulumi.get(self, "x509_store_name")


@pulumi.output_type
class ClusterCertificateCommonNamesCommonName(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateCommonName":
            suggest = "certificate_common_name"
        elif key == "certificateIssuerThumbprint":
            suggest = "certificate_issuer_thumbprint"

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

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

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

    def __init__(__self__, *,
                 certificate_common_name: str,
                 certificate_issuer_thumbprint: Optional[str] = None):
        """
        :param str certificate_common_name: The common or subject name of the certificate.
        :param str certificate_issuer_thumbprint: The Issuer Thumbprint of the Certificate.
        """
        pulumi.set(__self__, "certificate_common_name", certificate_common_name)
        if certificate_issuer_thumbprint is not None:
            pulumi.set(__self__, "certificate_issuer_thumbprint", certificate_issuer_thumbprint)

    @property
    @pulumi.getter(name="certificateCommonName")
    def certificate_common_name(self) -> str:
        """
        The common or subject name of the certificate.
        """
        return pulumi.get(self, "certificate_common_name")

    @property
    @pulumi.getter(name="certificateIssuerThumbprint")
    def certificate_issuer_thumbprint(self) -> Optional[str]:
        """
        The Issuer Thumbprint of the Certificate.
        """
        return pulumi.get(self, "certificate_issuer_thumbprint")


@pulumi.output_type
class ClusterClientCertificateCommonName(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "commonName":
            suggest = "common_name"
        elif key == "isAdmin":
            suggest = "is_admin"
        elif key == "issuerThumbprint":
            suggest = "issuer_thumbprint"

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

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

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

    def __init__(__self__, *,
                 common_name: str,
                 is_admin: bool,
                 issuer_thumbprint: Optional[str] = None):
        """
        :param str common_name: The common or subject name of the certificate.
        :param bool is_admin: Does the Client Certificate have Admin Access to the cluster? Non-admin clients can only perform read only operations on the cluster.
        """
        pulumi.set(__self__, "common_name", common_name)
        pulumi.set(__self__, "is_admin", is_admin)
        if issuer_thumbprint is not None:
            pulumi.set(__self__, "issuer_thumbprint", issuer_thumbprint)

    @property
    @pulumi.getter(name="commonName")
    def common_name(self) -> str:
        """
        The common or subject name of the certificate.
        """
        return pulumi.get(self, "common_name")

    @property
    @pulumi.getter(name="isAdmin")
    def is_admin(self) -> bool:
        """
        Does the Client Certificate have Admin Access to the cluster? Non-admin clients can only perform read only operations on the cluster.
        """
        return pulumi.get(self, "is_admin")

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


@pulumi.output_type
class ClusterClientCertificateThumbprint(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "isAdmin":
            suggest = "is_admin"

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

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

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

    def __init__(__self__, *,
                 is_admin: bool,
                 thumbprint: str):
        """
        :param bool is_admin: Does the Client Certificate have Admin Access to the cluster? Non-admin clients can only perform read only operations on the cluster.
        :param str thumbprint: The Thumbprint associated with the Client Certificate.
        """
        pulumi.set(__self__, "is_admin", is_admin)
        pulumi.set(__self__, "thumbprint", thumbprint)

    @property
    @pulumi.getter(name="isAdmin")
    def is_admin(self) -> bool:
        """
        Does the Client Certificate have Admin Access to the cluster? Non-admin clients can only perform read only operations on the cluster.
        """
        return pulumi.get(self, "is_admin")

    @property
    @pulumi.getter
    def thumbprint(self) -> str:
        """
        The Thumbprint associated with the Client Certificate.
        """
        return pulumi.get(self, "thumbprint")


@pulumi.output_type
class ClusterDiagnosticsConfig(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "blobEndpoint":
            suggest = "blob_endpoint"
        elif key == "protectedAccountKeyName":
            suggest = "protected_account_key_name"
        elif key == "queueEndpoint":
            suggest = "queue_endpoint"
        elif key == "storageAccountName":
            suggest = "storage_account_name"
        elif key == "tableEndpoint":
            suggest = "table_endpoint"

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

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

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

    def __init__(__self__, *,
                 blob_endpoint: str,
                 protected_account_key_name: str,
                 queue_endpoint: str,
                 storage_account_name: str,
                 table_endpoint: str):
        """
        :param str blob_endpoint: The Blob Endpoint of the Storage Account.
        :param str protected_account_key_name: The protected diagnostics storage key name, such as `StorageAccountKey1`.
        :param str queue_endpoint: The Queue Endpoint of the Storage Account.
        :param str storage_account_name: The name of the Storage Account where the Diagnostics should be sent to.
        :param str table_endpoint: The Table Endpoint of the Storage Account.
        """
        pulumi.set(__self__, "blob_endpoint", blob_endpoint)
        pulumi.set(__self__, "protected_account_key_name", protected_account_key_name)
        pulumi.set(__self__, "queue_endpoint", queue_endpoint)
        pulumi.set(__self__, "storage_account_name", storage_account_name)
        pulumi.set(__self__, "table_endpoint", table_endpoint)

    @property
    @pulumi.getter(name="blobEndpoint")
    def blob_endpoint(self) -> str:
        """
        The Blob Endpoint of the Storage Account.
        """
        return pulumi.get(self, "blob_endpoint")

    @property
    @pulumi.getter(name="protectedAccountKeyName")
    def protected_account_key_name(self) -> str:
        """
        The protected diagnostics storage key name, such as `StorageAccountKey1`.
        """
        return pulumi.get(self, "protected_account_key_name")

    @property
    @pulumi.getter(name="queueEndpoint")
    def queue_endpoint(self) -> str:
        """
        The Queue Endpoint of the Storage Account.
        """
        return pulumi.get(self, "queue_endpoint")

    @property
    @pulumi.getter(name="storageAccountName")
    def storage_account_name(self) -> str:
        """
        The name of the Storage Account where the Diagnostics should be sent to.
        """
        return pulumi.get(self, "storage_account_name")

    @property
    @pulumi.getter(name="tableEndpoint")
    def table_endpoint(self) -> str:
        """
        The Table Endpoint of the Storage Account.
        """
        return pulumi.get(self, "table_endpoint")


@pulumi.output_type
class ClusterFabricSetting(dict):
    def __init__(__self__, *,
                 name: str,
                 parameters: Optional[Mapping[str, str]] = None):
        """
        :param str name: The name of the Fabric Setting, such as `Security` or `Federation`.
        :param Mapping[str, str] parameters: A map containing settings for the specified Fabric Setting.
        """
        pulumi.set(__self__, "name", name)
        if parameters is not None:
            pulumi.set(__self__, "parameters", parameters)

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Fabric Setting, such as `Security` or `Federation`.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def parameters(self) -> Optional[Mapping[str, str]]:
        """
        A map containing settings for the specified Fabric Setting.
        """
        return pulumi.get(self, "parameters")


@pulumi.output_type
class ClusterNodeType(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "clientEndpointPort":
            suggest = "client_endpoint_port"
        elif key == "httpEndpointPort":
            suggest = "http_endpoint_port"
        elif key == "instanceCount":
            suggest = "instance_count"
        elif key == "isPrimary":
            suggest = "is_primary"
        elif key == "applicationPorts":
            suggest = "application_ports"
        elif key == "durabilityLevel":
            suggest = "durability_level"
        elif key == "ephemeralPorts":
            suggest = "ephemeral_ports"
        elif key == "placementProperties":
            suggest = "placement_properties"
        elif key == "reverseProxyEndpointPort":
            suggest = "reverse_proxy_endpoint_port"

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

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

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

    def __init__(__self__, *,
                 client_endpoint_port: int,
                 http_endpoint_port: int,
                 instance_count: int,
                 is_primary: bool,
                 name: str,
                 application_ports: Optional['outputs.ClusterNodeTypeApplicationPorts'] = None,
                 capacities: Optional[Mapping[str, str]] = None,
                 durability_level: Optional[str] = None,
                 ephemeral_ports: Optional['outputs.ClusterNodeTypeEphemeralPorts'] = None,
                 placement_properties: Optional[Mapping[str, str]] = None,
                 reverse_proxy_endpoint_port: Optional[int] = None):
        """
        :param int client_endpoint_port: The Port used for the Client Endpoint for this Node Type. Changing this forces a new resource to be created.
        :param int http_endpoint_port: The Port used for the HTTP Endpoint for this Node Type. Changing this forces a new resource to be created.
        :param int instance_count: The number of nodes for this Node Type.
        :param bool is_primary: Is this the Primary Node Type? Changing this forces a new resource to be created.
        :param str name: The name of the Node Type. Changing this forces a new resource to be created.
        :param 'ClusterNodeTypeApplicationPortsArgs' application_ports: A `application_ports` block as defined below.
        :param Mapping[str, str] capacities: The capacity tags applied to the nodes in the node type, the cluster resource manager uses these tags to understand how much resource a node has.
        :param str durability_level: The Durability Level for this Node Type. Possible values include `Bronze`, `Gold` and `Silver`. Defaults to `Bronze`. Changing this forces a new resource to be created.
        :param 'ClusterNodeTypeEphemeralPortsArgs' ephemeral_ports: A `ephemeral_ports` block as defined below.
        :param Mapping[str, str] placement_properties: The placement tags applied to nodes in the node type, which can be used to indicate where certain services (workload) should run.
        :param int reverse_proxy_endpoint_port: The Port used for the Reverse Proxy Endpoint  for this Node Type. Changing this will upgrade the cluster.
        """
        pulumi.set(__self__, "client_endpoint_port", client_endpoint_port)
        pulumi.set(__self__, "http_endpoint_port", http_endpoint_port)
        pulumi.set(__self__, "instance_count", instance_count)
        pulumi.set(__self__, "is_primary", is_primary)
        pulumi.set(__self__, "name", name)
        if application_ports is not None:
            pulumi.set(__self__, "application_ports", application_ports)
        if capacities is not None:
            pulumi.set(__self__, "capacities", capacities)
        if durability_level is not None:
            pulumi.set(__self__, "durability_level", durability_level)
        if ephemeral_ports is not None:
            pulumi.set(__self__, "ephemeral_ports", ephemeral_ports)
        if placement_properties is not None:
            pulumi.set(__self__, "placement_properties", placement_properties)
        if reverse_proxy_endpoint_port is not None:
            pulumi.set(__self__, "reverse_proxy_endpoint_port", reverse_proxy_endpoint_port)

    @property
    @pulumi.getter(name="clientEndpointPort")
    def client_endpoint_port(self) -> int:
        """
        The Port used for the Client Endpoint for this Node Type. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "client_endpoint_port")

    @property
    @pulumi.getter(name="httpEndpointPort")
    def http_endpoint_port(self) -> int:
        """
        The Port used for the HTTP Endpoint for this Node Type. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "http_endpoint_port")

    @property
    @pulumi.getter(name="instanceCount")
    def instance_count(self) -> int:
        """
        The number of nodes for this Node Type.
        """
        return pulumi.get(self, "instance_count")

    @property
    @pulumi.getter(name="isPrimary")
    def is_primary(self) -> bool:
        """
        Is this the Primary Node Type? Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "is_primary")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the Node Type. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="applicationPorts")
    def application_ports(self) -> Optional['outputs.ClusterNodeTypeApplicationPorts']:
        """
        A `application_ports` block as defined below.
        """
        return pulumi.get(self, "application_ports")

    @property
    @pulumi.getter
    def capacities(self) -> Optional[Mapping[str, str]]:
        """
        The capacity tags applied to the nodes in the node type, the cluster resource manager uses these tags to understand how much resource a node has.
        """
        return pulumi.get(self, "capacities")

    @property
    @pulumi.getter(name="durabilityLevel")
    def durability_level(self) -> Optional[str]:
        """
        The Durability Level for this Node Type. Possible values include `Bronze`, `Gold` and `Silver`. Defaults to `Bronze`. Changing this forces a new resource to be created.
        """
        return pulumi.get(self, "durability_level")

    @property
    @pulumi.getter(name="ephemeralPorts")
    def ephemeral_ports(self) -> Optional['outputs.ClusterNodeTypeEphemeralPorts']:
        """
        A `ephemeral_ports` block as defined below.
        """
        return pulumi.get(self, "ephemeral_ports")

    @property
    @pulumi.getter(name="placementProperties")
    def placement_properties(self) -> Optional[Mapping[str, str]]:
        """
        The placement tags applied to nodes in the node type, which can be used to indicate where certain services (workload) should run.
        """
        return pulumi.get(self, "placement_properties")

    @property
    @pulumi.getter(name="reverseProxyEndpointPort")
    def reverse_proxy_endpoint_port(self) -> Optional[int]:
        """
        The Port used for the Reverse Proxy Endpoint  for this Node Type. Changing this will upgrade the cluster.
        """
        return pulumi.get(self, "reverse_proxy_endpoint_port")


@pulumi.output_type
class ClusterNodeTypeApplicationPorts(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "endPort":
            suggest = "end_port"
        elif key == "startPort":
            suggest = "start_port"

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

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

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

    def __init__(__self__, *,
                 end_port: int,
                 start_port: int):
        """
        :param int end_port: The end of the Application Port Range on this Node Type.
        :param int start_port: The start of the Application Port Range on this Node Type.
        """
        pulumi.set(__self__, "end_port", end_port)
        pulumi.set(__self__, "start_port", start_port)

    @property
    @pulumi.getter(name="endPort")
    def end_port(self) -> int:
        """
        The end of the Application Port Range on this Node Type.
        """
        return pulumi.get(self, "end_port")

    @property
    @pulumi.getter(name="startPort")
    def start_port(self) -> int:
        """
        The start of the Application Port Range on this Node Type.
        """
        return pulumi.get(self, "start_port")


@pulumi.output_type
class ClusterNodeTypeEphemeralPorts(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "endPort":
            suggest = "end_port"
        elif key == "startPort":
            suggest = "start_port"

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

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

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

    def __init__(__self__, *,
                 end_port: int,
                 start_port: int):
        """
        :param int end_port: The end of the Ephemeral Port Range on this Node Type.
        :param int start_port: The start of the Ephemeral Port Range on this Node Type.
        """
        pulumi.set(__self__, "end_port", end_port)
        pulumi.set(__self__, "start_port", start_port)

    @property
    @pulumi.getter(name="endPort")
    def end_port(self) -> int:
        """
        The end of the Ephemeral Port Range on this Node Type.
        """
        return pulumi.get(self, "end_port")

    @property
    @pulumi.getter(name="startPort")
    def start_port(self) -> int:
        """
        The start of the Ephemeral Port Range on this Node Type.
        """
        return pulumi.get(self, "start_port")


@pulumi.output_type
class ClusterReverseProxyCertificate(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "x509StoreName":
            suggest = "x509_store_name"
        elif key == "thumbprintSecondary":
            suggest = "thumbprint_secondary"

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

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

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

    def __init__(__self__, *,
                 thumbprint: str,
                 x509_store_name: str,
                 thumbprint_secondary: Optional[str] = None):
        """
        :param str thumbprint: The Thumbprint of the Certificate.
        :param str x509_store_name: The X509 Store where the Certificate Exists, such as `My`.
        :param str thumbprint_secondary: The Secondary Thumbprint of the Certificate.
        """
        pulumi.set(__self__, "thumbprint", thumbprint)
        pulumi.set(__self__, "x509_store_name", x509_store_name)
        if thumbprint_secondary is not None:
            pulumi.set(__self__, "thumbprint_secondary", thumbprint_secondary)

    @property
    @pulumi.getter
    def thumbprint(self) -> str:
        """
        The Thumbprint of the Certificate.
        """
        return pulumi.get(self, "thumbprint")

    @property
    @pulumi.getter(name="x509StoreName")
    def x509_store_name(self) -> str:
        """
        The X509 Store where the Certificate Exists, such as `My`.
        """
        return pulumi.get(self, "x509_store_name")

    @property
    @pulumi.getter(name="thumbprintSecondary")
    def thumbprint_secondary(self) -> Optional[str]:
        """
        The Secondary Thumbprint of the Certificate.
        """
        return pulumi.get(self, "thumbprint_secondary")


@pulumi.output_type
class ClusterReverseProxyCertificateCommonNames(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "commonNames":
            suggest = "common_names"
        elif key == "x509StoreName":
            suggest = "x509_store_name"

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

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

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

    def __init__(__self__, *,
                 common_names: Sequence['outputs.ClusterReverseProxyCertificateCommonNamesCommonName'],
                 x509_store_name: str):
        """
        :param Sequence['ClusterReverseProxyCertificateCommonNamesCommonNameArgs'] common_names: A `common_names` block as defined below.
        :param str x509_store_name: The X509 Store where the Certificate Exists, such as `My`.
        """
        pulumi.set(__self__, "common_names", common_names)
        pulumi.set(__self__, "x509_store_name", x509_store_name)

    @property
    @pulumi.getter(name="commonNames")
    def common_names(self) -> Sequence['outputs.ClusterReverseProxyCertificateCommonNamesCommonName']:
        """
        A `common_names` block as defined below.
        """
        return pulumi.get(self, "common_names")

    @property
    @pulumi.getter(name="x509StoreName")
    def x509_store_name(self) -> str:
        """
        The X509 Store where the Certificate Exists, such as `My`.
        """
        return pulumi.get(self, "x509_store_name")


@pulumi.output_type
class ClusterReverseProxyCertificateCommonNamesCommonName(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "certificateCommonName":
            suggest = "certificate_common_name"
        elif key == "certificateIssuerThumbprint":
            suggest = "certificate_issuer_thumbprint"

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

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

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

    def __init__(__self__, *,
                 certificate_common_name: str,
                 certificate_issuer_thumbprint: Optional[str] = None):
        """
        :param str certificate_common_name: The common or subject name of the certificate.
        :param str certificate_issuer_thumbprint: The Issuer Thumbprint of the Certificate.
        """
        pulumi.set(__self__, "certificate_common_name", certificate_common_name)
        if certificate_issuer_thumbprint is not None:
            pulumi.set(__self__, "certificate_issuer_thumbprint", certificate_issuer_thumbprint)

    @property
    @pulumi.getter(name="certificateCommonName")
    def certificate_common_name(self) -> str:
        """
        The common or subject name of the certificate.
        """
        return pulumi.get(self, "certificate_common_name")

    @property
    @pulumi.getter(name="certificateIssuerThumbprint")
    def certificate_issuer_thumbprint(self) -> Optional[str]:
        """
        The Issuer Thumbprint of the Certificate.
        """
        return pulumi.get(self, "certificate_issuer_thumbprint")


@pulumi.output_type
class ClusterUpgradePolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "deltaHealthPolicy":
            suggest = "delta_health_policy"
        elif key == "forceRestartEnabled":
            suggest = "force_restart_enabled"
        elif key == "healthCheckRetryTimeout":
            suggest = "health_check_retry_timeout"
        elif key == "healthCheckStableDuration":
            suggest = "health_check_stable_duration"
        elif key == "healthCheckWaitDuration":
            suggest = "health_check_wait_duration"
        elif key == "healthPolicy":
            suggest = "health_policy"
        elif key == "upgradeDomainTimeout":
            suggest = "upgrade_domain_timeout"
        elif key == "upgradeReplicaSetCheckTimeout":
            suggest = "upgrade_replica_set_check_timeout"
        elif key == "upgradeTimeout":
            suggest = "upgrade_timeout"

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

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

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

    def __init__(__self__, *,
                 delta_health_policy: Optional['outputs.ClusterUpgradePolicyDeltaHealthPolicy'] = None,
                 force_restart_enabled: Optional[bool] = None,
                 health_check_retry_timeout: Optional[str] = None,
                 health_check_stable_duration: Optional[str] = None,
                 health_check_wait_duration: Optional[str] = None,
                 health_policy: Optional['outputs.ClusterUpgradePolicyHealthPolicy'] = None,
                 upgrade_domain_timeout: Optional[str] = None,
                 upgrade_replica_set_check_timeout: Optional[str] = None,
                 upgrade_timeout: Optional[str] = None):
        """
        :param 'ClusterUpgradePolicyDeltaHealthPolicyArgs' delta_health_policy: A `delta_health_policy` block as defined below
        :param str health_check_retry_timeout: Specifies the duration, in "hh:mm:ss" string format, after which Service Fabric retries the health check if the previous health check fails. Defaults to `00:45:00`.
        :param str health_check_stable_duration: Specifies the duration, in "hh:mm:ss" string format, that Service Fabric waits in order to verify that the cluster is stable before it continues to the next upgrade domain or completes the upgrade. This wait duration prevents undetected changes of health right after the health check is performed. Defaults to `00:01:00`.
        :param str health_check_wait_duration: Specifies the duration, in "hh:mm:ss" string format, that Service Fabric waits before it performs the initial health check after it finishes the upgrade on the upgrade domain. Defaults to `00:00:30`.
        :param 'ClusterUpgradePolicyHealthPolicyArgs' health_policy: A `health_policy` block as defined below
        :param str upgrade_domain_timeout: Specifies the duration, in "hh:mm:ss" string format, that Service Fabric takes to upgrade a single upgrade domain. After this period, the upgrade fails. Defaults to `02:00:00`.
        :param str upgrade_replica_set_check_timeout: Specifies the duration, in "hh:mm:ss" string format, that Service Fabric waits for a replica set to reconfigure into a safe state, if it is not already in a safe state, before Service Fabric proceeds with the upgrade. Defaults to `10675199.02:48:05.4775807`.
        :param str upgrade_timeout: Specifies the duration, in "hh:mm:ss" string format, that Service Fabric takes for the entire upgrade. After this period, the upgrade fails. Defaults to `12:00:00`.
        """
        if delta_health_policy is not None:
            pulumi.set(__self__, "delta_health_policy", delta_health_policy)
        if force_restart_enabled is not None:
            pulumi.set(__self__, "force_restart_enabled", force_restart_enabled)
        if health_check_retry_timeout is not None:
            pulumi.set(__self__, "health_check_retry_timeout", health_check_retry_timeout)
        if health_check_stable_duration is not None:
            pulumi.set(__self__, "health_check_stable_duration", health_check_stable_duration)
        if health_check_wait_duration is not None:
            pulumi.set(__self__, "health_check_wait_duration", health_check_wait_duration)
        if health_policy is not None:
            pulumi.set(__self__, "health_policy", health_policy)
        if upgrade_domain_timeout is not None:
            pulumi.set(__self__, "upgrade_domain_timeout", upgrade_domain_timeout)
        if upgrade_replica_set_check_timeout is not None:
            pulumi.set(__self__, "upgrade_replica_set_check_timeout", upgrade_replica_set_check_timeout)
        if upgrade_timeout is not None:
            pulumi.set(__self__, "upgrade_timeout", upgrade_timeout)

    @property
    @pulumi.getter(name="deltaHealthPolicy")
    def delta_health_policy(self) -> Optional['outputs.ClusterUpgradePolicyDeltaHealthPolicy']:
        """
        A `delta_health_policy` block as defined below
        """
        return pulumi.get(self, "delta_health_policy")

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

    @property
    @pulumi.getter(name="healthCheckRetryTimeout")
    def health_check_retry_timeout(self) -> Optional[str]:
        """
        Specifies the duration, in "hh:mm:ss" string format, after which Service Fabric retries the health check if the previous health check fails. Defaults to `00:45:00`.
        """
        return pulumi.get(self, "health_check_retry_timeout")

    @property
    @pulumi.getter(name="healthCheckStableDuration")
    def health_check_stable_duration(self) -> Optional[str]:
        """
        Specifies the duration, in "hh:mm:ss" string format, that Service Fabric waits in order to verify that the cluster is stable before it continues to the next upgrade domain or completes the upgrade. This wait duration prevents undetected changes of health right after the health check is performed. Defaults to `00:01:00`.
        """
        return pulumi.get(self, "health_check_stable_duration")

    @property
    @pulumi.getter(name="healthCheckWaitDuration")
    def health_check_wait_duration(self) -> Optional[str]:
        """
        Specifies the duration, in "hh:mm:ss" string format, that Service Fabric waits before it performs the initial health check after it finishes the upgrade on the upgrade domain. Defaults to `00:00:30`.
        """
        return pulumi.get(self, "health_check_wait_duration")

    @property
    @pulumi.getter(name="healthPolicy")
    def health_policy(self) -> Optional['outputs.ClusterUpgradePolicyHealthPolicy']:
        """
        A `health_policy` block as defined below
        """
        return pulumi.get(self, "health_policy")

    @property
    @pulumi.getter(name="upgradeDomainTimeout")
    def upgrade_domain_timeout(self) -> Optional[str]:
        """
        Specifies the duration, in "hh:mm:ss" string format, that Service Fabric takes to upgrade a single upgrade domain. After this period, the upgrade fails. Defaults to `02:00:00`.
        """
        return pulumi.get(self, "upgrade_domain_timeout")

    @property
    @pulumi.getter(name="upgradeReplicaSetCheckTimeout")
    def upgrade_replica_set_check_timeout(self) -> Optional[str]:
        """
        Specifies the duration, in "hh:mm:ss" string format, that Service Fabric waits for a replica set to reconfigure into a safe state, if it is not already in a safe state, before Service Fabric proceeds with the upgrade. Defaults to `10675199.02:48:05.4775807`.
        """
        return pulumi.get(self, "upgrade_replica_set_check_timeout")

    @property
    @pulumi.getter(name="upgradeTimeout")
    def upgrade_timeout(self) -> Optional[str]:
        """
        Specifies the duration, in "hh:mm:ss" string format, that Service Fabric takes for the entire upgrade. After this period, the upgrade fails. Defaults to `12:00:00`.
        """
        return pulumi.get(self, "upgrade_timeout")


@pulumi.output_type
class ClusterUpgradePolicyDeltaHealthPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxDeltaUnhealthyApplicationsPercent":
            suggest = "max_delta_unhealthy_applications_percent"
        elif key == "maxDeltaUnhealthyNodesPercent":
            suggest = "max_delta_unhealthy_nodes_percent"
        elif key == "maxUpgradeDomainDeltaUnhealthyNodesPercent":
            suggest = "max_upgrade_domain_delta_unhealthy_nodes_percent"

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

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

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

    def __init__(__self__, *,
                 max_delta_unhealthy_applications_percent: Optional[int] = None,
                 max_delta_unhealthy_nodes_percent: Optional[int] = None,
                 max_upgrade_domain_delta_unhealthy_nodes_percent: Optional[int] = None):
        if max_delta_unhealthy_applications_percent is not None:
            pulumi.set(__self__, "max_delta_unhealthy_applications_percent", max_delta_unhealthy_applications_percent)
        if max_delta_unhealthy_nodes_percent is not None:
            pulumi.set(__self__, "max_delta_unhealthy_nodes_percent", max_delta_unhealthy_nodes_percent)
        if max_upgrade_domain_delta_unhealthy_nodes_percent is not None:
            pulumi.set(__self__, "max_upgrade_domain_delta_unhealthy_nodes_percent", max_upgrade_domain_delta_unhealthy_nodes_percent)

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

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

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


@pulumi.output_type
class ClusterUpgradePolicyHealthPolicy(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "maxUnhealthyApplicationsPercent":
            suggest = "max_unhealthy_applications_percent"
        elif key == "maxUnhealthyNodesPercent":
            suggest = "max_unhealthy_nodes_percent"

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

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

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

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

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

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


@pulumi.output_type
class MeshApplicationService(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "codePackages":
            suggest = "code_packages"
        elif key == "osType":
            suggest = "os_type"

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

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

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

    def __init__(__self__, *,
                 code_packages: Sequence['outputs.MeshApplicationServiceCodePackage'],
                 name: str,
                 os_type: str):
        """
        :param Sequence['MeshApplicationServiceCodePackageArgs'] code_packages: Any number `code_package` block as described below.
        :param str name: The name of the service resource.
        :param str os_type: The operating system required by the code in service. Valid values are `Linux` or `Windows`.
        """
        pulumi.set(__self__, "code_packages", code_packages)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "os_type", os_type)

    @property
    @pulumi.getter(name="codePackages")
    def code_packages(self) -> Sequence['outputs.MeshApplicationServiceCodePackage']:
        """
        Any number `code_package` block as described below.
        """
        return pulumi.get(self, "code_packages")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the service resource.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter(name="osType")
    def os_type(self) -> str:
        """
        The operating system required by the code in service. Valid values are `Linux` or `Windows`.
        """
        return pulumi.get(self, "os_type")


@pulumi.output_type
class MeshApplicationServiceCodePackage(dict):
    @staticmethod
    def __key_warning(key: str):
        suggest = None
        if key == "imageName":
            suggest = "image_name"

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

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

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

    def __init__(__self__, *,
                 image_name: str,
                 name: str,
                 resources: 'outputs.MeshApplicationServiceCodePackageResources'):
        """
        :param str image_name: The Container image the code package will use.
        :param str name: The name of the code package.
        :param 'MeshApplicationServiceCodePackageResourcesArgs' resources: A `resources` block as defined below.
        """
        pulumi.set(__self__, "image_name", image_name)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "resources", resources)

    @property
    @pulumi.getter(name="imageName")
    def image_name(self) -> str:
        """
        The Container image the code package will use.
        """
        return pulumi.get(self, "image_name")

    @property
    @pulumi.getter
    def name(self) -> str:
        """
        The name of the code package.
        """
        return pulumi.get(self, "name")

    @property
    @pulumi.getter
    def resources(self) -> 'outputs.MeshApplicationServiceCodePackageResources':
        """
        A `resources` block as defined below.
        """
        return pulumi.get(self, "resources")


@pulumi.output_type
class MeshApplicationServiceCodePackageResources(dict):
    def __init__(__self__, *,
                 requests: 'outputs.MeshApplicationServiceCodePackageResourcesRequests',
                 limits: Optional['outputs.MeshApplicationServiceCodePackageResourcesLimits'] = None):
        """
        :param 'MeshApplicationServiceCodePackageResourcesRequestsArgs' requests: A `requests` block as defined below.
        :param 'MeshApplicationServiceCodePackageResourcesLimitsArgs' limits: A `limits` block as defined below.
        """
        pulumi.set(__self__, "requests", requests)
        if limits is not None:
            pulumi.set(__self__, "limits", limits)

    @property
    @pulumi.getter
    def requests(self) -> 'outputs.MeshApplicationServiceCodePackageResourcesRequests':
        """
        A `requests` block as defined below.
        """
        return pulumi.get(self, "requests")

    @property
    @pulumi.getter
    def limits(self) -> Optional['outputs.MeshApplicationServiceCodePackageResourcesLimits']:
        """
        A `limits` block as defined below.
        """
        return pulumi.get(self, "limits")


@pulumi.output_type
class MeshApplicationServiceCodePackageResourcesLimits(dict):
    def __init__(__self__, *,
                 cpu: float,
                 memory: float):
        """
        :param float cpu: The maximum number of CPU cores the container can use.
        :param float memory: The maximum memory request in GB the container can use.
        """
        pulumi.set(__self__, "cpu", cpu)
        pulumi.set(__self__, "memory", memory)

    @property
    @pulumi.getter
    def cpu(self) -> float:
        """
        The maximum number of CPU cores the container can use.
        """
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter
    def memory(self) -> float:
        """
        The maximum memory request in GB the container can use.
        """
        return pulumi.get(self, "memory")


@pulumi.output_type
class MeshApplicationServiceCodePackageResourcesRequests(dict):
    def __init__(__self__, *,
                 cpu: float,
                 memory: float):
        """
        :param float cpu: The minimum number of CPU cores the container requires.
        :param float memory: The minimum memory request in GB the container requires.
        """
        pulumi.set(__self__, "cpu", cpu)
        pulumi.set(__self__, "memory", memory)

    @property
    @pulumi.getter
    def cpu(self) -> float:
        """
        The minimum number of CPU cores the container requires.
        """
        return pulumi.get(self, "cpu")

    @property
    @pulumi.getter
    def memory(self) -> float:
        """
        The minimum memory request in GB the container requires.
        """
        return pulumi.get(self, "memory")


