text: # coding=utf-8
  # *** WARNING: this file was generated by the Pulumi SDK Generator. ***
  # *** Do not edit by hand unless you're certain you know what you are doing! ***
  
  import warnings
  import pulumi
  import pulumi.runtime
  from typing import Any, Mapping, Optional, Sequence, Union
  from ... import _utilities, _tables
  from . import outputs
  
  __all__ = [
      'ApplicationDeltaHealthPolicyResponse',
      'ApplicationHealthPolicyResponse',
      'ApplicationMetricDescriptionResponse',
      'ApplicationUpgradePolicyResponse',
      'ApplicationUserAssignedIdentityResponse',
      'ArmApplicationHealthPolicyResponse',
      'ArmRollingUpgradeMonitoringPolicyResponse',
      'ArmServiceTypeHealthPolicyResponse',
      'AzureActiveDirectoryResponse',
      'CertificateDescriptionResponse',
      'ClientCertificateCommonNameResponse',
      'ClientCertificateThumbprintResponse',
      'ClusterHealthPolicyResponse',
      'ClusterUpgradeDeltaHealthPolicyResponse',
      'ClusterUpgradePolicyResponse',
      'ClusterVersionDetailsResponse',
      'DiagnosticsStorageAccountConfigResponse',
      'EndpointRangeDescriptionResponse',
      'ManagedIdentityResponse',
      'NamedPartitionSchemeDescriptionResponse',
      'NodeTypeDescriptionResponse',
      'ServerCertificateCommonNameResponse',
      'ServerCertificateCommonNamesResponse',
      'ServiceCorrelationDescriptionResponse',
      'ServiceLoadMetricDescriptionResponse',
      'ServicePlacementPolicyDescriptionResponse',
      'ServiceTypeDeltaHealthPolicyResponse',
      'ServiceTypeHealthPolicyResponse',
      'SettingsParameterDescriptionResponse',
      'SettingsSectionDescriptionResponse',
      'SingletonPartitionSchemeDescriptionResponse',
      'UniformInt64RangePartitionSchemeDescriptionResponse',
      'UserAssignedIdentityResponse',
  ]
  
  @pulumi.output_type
  class ApplicationDeltaHealthPolicyResponse(dict):
      """
      Defines a delta health policy used to evaluate the health of an application or one of its child entities when upgrading the cluster.
      """
      def __init__(__self__, *,
                   default_service_type_delta_health_policy: Optional['outputs.ServiceTypeDeltaHealthPolicyResponse'] = None,
                   service_type_delta_health_policies: Optional[Mapping[str, 'outputs.ServiceTypeDeltaHealthPolicyResponse']] = None):
          """
          Defines a delta health policy used to evaluate the health of an application or one of its child entities when upgrading the cluster.
  
          :param 'ServiceTypeDeltaHealthPolicyResponseArgs' default_service_type_delta_health_policy: The delta health policy used by default to evaluate the health of a service type when upgrading the cluster.
          :param Mapping[str, 'ServiceTypeDeltaHealthPolicyResponseArgs'] service_type_delta_health_policies: The map with service type delta health policy per service type name. The map is empty by default.
          """
          if default_service_type_delta_health_policy is not None:
              pulumi.set(__self__, "default_service_type_delta_health_policy", default_service_type_delta_health_policy)
          if service_type_delta_health_policies is not None:
              pulumi.set(__self__, "service_type_delta_health_policies", service_type_delta_health_policies)
  
      @property
      @pulumi.getter(name="defaultServiceTypeDeltaHealthPolicy")
      def default_service_type_delta_health_policy(self) -> Optional['outputs.ServiceTypeDeltaHealthPolicyResponse']:
          """
          The delta health policy used by default to evaluate the health of a service type when upgrading the cluster.
          """
          return pulumi.get(self, "default_service_type_delta_health_policy")
  
      @property
      @pulumi.getter(name="serviceTypeDeltaHealthPolicies")
      def service_type_delta_health_policies(self) -> Optional[Mapping[str, 'outputs.ServiceTypeDeltaHealthPolicyResponse']]:
          """
          The map with service type delta health policy per service type name. The map is empty by default.
          """
          return pulumi.get(self, "service_type_delta_health_policies")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ApplicationHealthPolicyResponse(dict):
      """
      Defines a health policy used to evaluate the health of an application or one of its children entities.
      """
      def __init__(__self__, *,
                   default_service_type_health_policy: Optional['outputs.ServiceTypeHealthPolicyResponse'] = None,
                   service_type_health_policies: Optional[Mapping[str, 'outputs.ServiceTypeHealthPolicyResponse']] = None):
          """
          Defines a health policy used to evaluate the health of an application or one of its children entities.
  
          :param 'ServiceTypeHealthPolicyResponseArgs' default_service_type_health_policy: The health policy used by default to evaluate the health of a service type.
          :param Mapping[str, 'ServiceTypeHealthPolicyResponseArgs'] service_type_health_policies: The map with service type health policy per service type name. The map is empty by default.
          """
          if default_service_type_health_policy is not None:
              pulumi.set(__self__, "default_service_type_health_policy", default_service_type_health_policy)
          if service_type_health_policies is not None:
              pulumi.set(__self__, "service_type_health_policies", service_type_health_policies)
  
      @property
      @pulumi.getter(name="defaultServiceTypeHealthPolicy")
      def default_service_type_health_policy(self) -> Optional['outputs.ServiceTypeHealthPolicyResponse']:
          """
          The health policy used by default to evaluate the health of a service type.
          """
          return pulumi.get(self, "default_service_type_health_policy")
  
      @property
      @pulumi.getter(name="serviceTypeHealthPolicies")
      def service_type_health_policies(self) -> Optional[Mapping[str, 'outputs.ServiceTypeHealthPolicyResponse']]:
          """
          The map with service type health policy per service type name. The map is empty by default.
          """
          return pulumi.get(self, "service_type_health_policies")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ApplicationMetricDescriptionResponse(dict):
      """
      Describes capacity information for a custom resource balancing metric. This can be used to limit the total consumption of this metric by the services of this application.
      """
      def __init__(__self__, *,
                   maximum_capacity: Optional[int] = None,
                   name: Optional[str] = None,
                   reservation_capacity: Optional[int] = None,
                   total_application_capacity: Optional[int] = None):
          """
          Describes capacity information for a custom resource balancing metric. This can be used to limit the total consumption of this metric by the services of this application.
  
          :param int maximum_capacity: The maximum node capacity for Service Fabric application.
                 This is the maximum Load for an instance of this application on a single node. Even if the capacity of node is greater than this value, Service Fabric will limit the total load of services within the application on each node to this value.
                 If set to zero, capacity for this metric is unlimited on each node.
                 When creating a new application with application capacity defined, the product of MaximumNodes and this value must always be smaller than or equal to TotalApplicationCapacity.
                 When updating existing application with application capacity, the product of MaximumNodes and this value must always be smaller than or equal to TotalApplicationCapacity.
          :param str name: The name of the metric.
          :param int reservation_capacity: The node reservation capacity for Service Fabric application.
                 This is the amount of load which is reserved on nodes which have instances of this application.
                 If MinimumNodes is specified, then the product of these values will be the capacity reserved in the cluster for the application.
                 If set to zero, no capacity is reserved for this metric.
                 When setting application capacity or when updating application capacity; this value must be smaller than or equal to MaximumCapacity for each metric.
          :param int total_application_capacity: The total metric capacity for Service Fabric application.
                 This is the total metric capacity for this application in the cluster. Service Fabric will try to limit the sum of loads of services within the application to this value.
                 When creating a new application with application capacity defined, the product of MaximumNodes and MaximumCapacity must always be smaller than or equal to this value.
          """
          if maximum_capacity is not None:
              pulumi.set(__self__, "maximum_capacity", maximum_capacity)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if reservation_capacity is not None:
              pulumi.set(__self__, "reservation_capacity", reservation_capacity)
          if total_application_capacity is not None:
              pulumi.set(__self__, "total_application_capacity", total_application_capacity)
  
      @property
      @pulumi.getter(name="maximumCapacity")
      def maximum_capacity(self) -> Optional[int]:
          """
          The maximum node capacity for Service Fabric application.
          This is the maximum Load for an instance of this application on a single node. Even if the capacity of node is greater than this value, Service Fabric will limit the total load of services within the application on each node to this value.
          If set to zero, capacity for this metric is unlimited on each node.
          When creating a new application with application capacity defined, the product of MaximumNodes and this value must always be smaller than or equal to TotalApplicationCapacity.
          When updating existing application with application capacity, the product of MaximumNodes and this value must always be smaller than or equal to TotalApplicationCapacity.
          """
          return pulumi.get(self, "maximum_capacity")
  
      @property
      @pulumi.getter
      def name(self) -> Optional[str]:
          """
          The name of the metric.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter(name="reservationCapacity")
      def reservation_capacity(self) -> Optional[int]:
          """
          The node reservation capacity for Service Fabric application.
          This is the amount of load which is reserved on nodes which have instances of this application.
          If MinimumNodes is specified, then the product of these values will be the capacity reserved in the cluster for the application.
          If set to zero, no capacity is reserved for this metric.
          When setting application capacity or when updating application capacity; this value must be smaller than or equal to MaximumCapacity for each metric.
          """
          return pulumi.get(self, "reservation_capacity")
  
      @property
      @pulumi.getter(name="totalApplicationCapacity")
      def total_application_capacity(self) -> Optional[int]:
          """
          The total metric capacity for Service Fabric application.
          This is the total metric capacity for this application in the cluster. Service Fabric will try to limit the sum of loads of services within the application to this value.
          When creating a new application with application capacity defined, the product of MaximumNodes and MaximumCapacity must always be smaller than or equal to this value.
          """
          return pulumi.get(self, "total_application_capacity")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ApplicationUpgradePolicyResponse(dict):
      """
      Describes the policy for a monitored application upgrade.
      """
      def __init__(__self__, *,
                   application_health_policy: Optional['outputs.ArmApplicationHealthPolicyResponse'] = None,
                   force_restart: Optional[bool] = None,
                   rolling_upgrade_monitoring_policy: Optional['outputs.ArmRollingUpgradeMonitoringPolicyResponse'] = None,
                   upgrade_replica_set_check_timeout: Optional[str] = None):
          """
          Describes the policy for a monitored application upgrade.
          :param 'ArmApplicationHealthPolicyResponseArgs' application_health_policy: Defines a health policy used to evaluate the health of an application or one of its children entities.
          :param bool force_restart: If true, then processes are forcefully restarted during upgrade even when the code version has not changed (the upgrade only changes configuration or data).
          :param 'ArmRollingUpgradeMonitoringPolicyResponseArgs' rolling_upgrade_monitoring_policy: The policy used for monitoring the application upgrade
          :param str upgrade_replica_set_check_timeout: The maximum amount of time to block processing of an upgrade domain and prevent loss of availability when there are unexpected issues. When this timeout expires, processing of the upgrade domain will proceed regardless of availability loss issues. The timeout is reset at the start of each upgrade domain. Valid values are between 0 and 42949672925 inclusive. (unsigned 32-bit integer).
          """
          if application_health_policy is not None:
              pulumi.set(__self__, "application_health_policy", application_health_policy)
          if force_restart is not None:
              pulumi.set(__self__, "force_restart", force_restart)
          if rolling_upgrade_monitoring_policy is not None:
              pulumi.set(__self__, "rolling_upgrade_monitoring_policy", rolling_upgrade_monitoring_policy)
          if upgrade_replica_set_check_timeout is not None:
              pulumi.set(__self__, "upgrade_replica_set_check_timeout", upgrade_replica_set_check_timeout)
  
      @property
      @pulumi.getter(name="applicationHealthPolicy")
      def application_health_policy(self) -> Optional['outputs.ArmApplicationHealthPolicyResponse']:
          """
          Defines a health policy used to evaluate the health of an application or one of its children entities.
          """
          return pulumi.get(self, "application_health_policy")
  
      @property
      @pulumi.getter(name="forceRestart")
      def force_restart(self) -> Optional[bool]:
          """
          If true, then processes are forcefully restarted during upgrade even when the code version has not changed (the upgrade only changes configuration or data).
          """
          return pulumi.get(self, "force_restart")
  
      @property
      @pulumi.getter(name="rollingUpgradeMonitoringPolicy")
      def rolling_upgrade_monitoring_policy(self) -> Optional['outputs.ArmRollingUpgradeMonitoringPolicyResponse']:
          """
          The policy used for monitoring the application upgrade
          """
          return pulumi.get(self, "rolling_upgrade_monitoring_policy")
  
      @property
      @pulumi.getter(name="upgradeReplicaSetCheckTimeout")
      def upgrade_replica_set_check_timeout(self) -> Optional[str]:
          """
          The maximum amount of time to block processing of an upgrade domain and prevent loss of availability when there are unexpected issues. When this timeout expires, processing of the upgrade domain will proceed regardless of availability loss issues. The timeout is reset at the start of each upgrade domain. Valid values are between 0 and 42949672925 inclusive. (unsigned 32-bit integer).
          """
          return pulumi.get(self, "upgrade_replica_set_check_timeout")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ApplicationUserAssignedIdentityResponse(dict):
      def __init__(__self__, *,
                   name: str,
                   principal_id: str):
          """
          :param str name: The friendly name of user assigned identity.
          :param str principal_id: The principal id of user assigned identity.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "principal_id", principal_id)
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          The friendly name of user assigned identity.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter(name="principalId")
      def principal_id(self) -> str:
          """
          The principal id of user assigned identity.
          """
          return pulumi.get(self, "principal_id")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ArmApplicationHealthPolicyResponse(dict):
      """
      Defines a health policy used to evaluate the health of an application or one of its children entities.
      """
      def __init__(__self__, *,
                   consider_warning_as_error: Optional[bool] = None,
                   default_service_type_health_policy: Optional['outputs.ArmServiceTypeHealthPolicyResponse'] = None,
                   max_percent_unhealthy_deployed_applications: Optional[int] = None,
                   service_type_health_policy_map: Optional[Mapping[str, 'outputs.ArmServiceTypeHealthPolicyResponse']] = None):
          """
          Defines a health policy used to evaluate the health of an application or one of its children entities.
  
          :param bool consider_warning_as_error: Indicates whether warnings are treated with the same severity as errors.
          :param 'ArmServiceTypeHealthPolicyResponseArgs' default_service_type_health_policy: The health policy used by default to evaluate the health of a service type.
          :param int max_percent_unhealthy_deployed_applications: The maximum allowed percentage of unhealthy deployed applications. Allowed values are Byte values from zero to 100.
                 The percentage represents the maximum tolerated percentage of deployed applications that can be unhealthy before the application is considered in error.
                 This is calculated by dividing the number of unhealthy deployed applications over the number of nodes where the application is currently deployed on in the cluster.
                 The computation rounds up to tolerate one failure on small numbers of nodes. Default percentage is zero.
          :param Mapping[str, 'ArmServiceTypeHealthPolicyResponseArgs'] service_type_health_policy_map: The map with service type health policy per service type name. The map is empty by default.
          """
          if consider_warning_as_error is not None:
              pulumi.set(__self__, "consider_warning_as_error", consider_warning_as_error)
          if default_service_type_health_policy is not None:
              pulumi.set(__self__, "default_service_type_health_policy", default_service_type_health_policy)
          if max_percent_unhealthy_deployed_applications is not None:
              pulumi.set(__self__, "max_percent_unhealthy_deployed_applications", max_percent_unhealthy_deployed_applications)
          if service_type_health_policy_map is not None:
              pulumi.set(__self__, "service_type_health_policy_map", service_type_health_policy_map)
  
      @property
      @pulumi.getter(name="considerWarningAsError")
      def consider_warning_as_error(self) -> Optional[bool]:
          """
          Indicates whether warnings are treated with the same severity as errors.
          """
          return pulumi.get(self, "consider_warning_as_error")
  
      @property
      @pulumi.getter(name="defaultServiceTypeHealthPolicy")
      def default_service_type_health_policy(self) -> Optional['outputs.ArmServiceTypeHealthPolicyResponse']:
          """
          The health policy used by default to evaluate the health of a service type.
          """
          return pulumi.get(self, "default_service_type_health_policy")
  
      @property
      @pulumi.getter(name="maxPercentUnhealthyDeployedApplications")
      def max_percent_unhealthy_deployed_applications(self) -> Optional[int]:
          """
          The maximum allowed percentage of unhealthy deployed applications. Allowed values are Byte values from zero to 100.
          The percentage represents the maximum tolerated percentage of deployed applications that can be unhealthy before the application is considered in error.
          This is calculated by dividing the number of unhealthy deployed applications over the number of nodes where the application is currently deployed on in the cluster.
          The computation rounds up to tolerate one failure on small numbers of nodes. Default percentage is zero.
          """
          return pulumi.get(self, "max_percent_unhealthy_deployed_applications")
  
      @property
      @pulumi.getter(name="serviceTypeHealthPolicyMap")
      def service_type_health_policy_map(self) -> Optional[Mapping[str, 'outputs.ArmServiceTypeHealthPolicyResponse']]:
          """
          The map with service type health policy per service type name. The map is empty by default.
          """
          return pulumi.get(self, "service_type_health_policy_map")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ArmRollingUpgradeMonitoringPolicyResponse(dict):
      """
      The policy used for monitoring the application upgrade
      """
      def __init__(__self__, *,
                   failure_action: Optional[str] = None,
                   health_check_retry_timeout: Optional[str] = None,
                   health_check_stable_duration: Optional[str] = None,
                   health_check_wait_duration: Optional[str] = None,
                   upgrade_domain_timeout: Optional[str] = None,
                   upgrade_timeout: Optional[str] = None):
          """
          The policy used for monitoring the application upgrade
          :param str failure_action: The activation Mode of the service package
          :param str health_check_retry_timeout: The amount of time to retry health evaluation when the application or cluster is unhealthy before FailureAction is executed. It is first interpreted as a string representing an ISO 8601 duration. If that fails, then it is interpreted as a number representing the total number of milliseconds.
          :param str health_check_stable_duration: The amount of time that the application or cluster must remain healthy before the upgrade proceeds to the next upgrade domain. It is first interpreted as a string representing an ISO 8601 duration. If that fails, then it is interpreted as a number representing the total number of milliseconds.
          :param str health_check_wait_duration: The amount of time to wait after completing an upgrade domain before applying health policies. It is first interpreted as a string representing an ISO 8601 duration. If that fails, then it is interpreted as a number representing the total number of milliseconds.
          :param str upgrade_domain_timeout: The amount of time each upgrade domain has to complete before FailureAction is executed. It is first interpreted as a string representing an ISO 8601 duration. If that fails, then it is interpreted as a number representing the total number of milliseconds.
          :param str upgrade_timeout: The amount of time the overall upgrade has to complete before FailureAction is executed. It is first interpreted as a string representing an ISO 8601 duration. If that fails, then it is interpreted as a number representing the total number of milliseconds.
          """
          if failure_action is not None:
              pulumi.set(__self__, "failure_action", failure_action)
          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 upgrade_domain_timeout is not None:
              pulumi.set(__self__, "upgrade_domain_timeout", upgrade_domain_timeout)
          if upgrade_timeout is not None:
              pulumi.set(__self__, "upgrade_timeout", upgrade_timeout)
  
      @property
      @pulumi.getter(name="failureAction")
      def failure_action(self) -> Optional[str]:
          """
          The activation Mode of the service package
          """
          return pulumi.get(self, "failure_action")
  
      @property
      @pulumi.getter(name="healthCheckRetryTimeout")
      def health_check_retry_timeout(self) -> Optional[str]:
          """
          The amount of time to retry health evaluation when the application or cluster is unhealthy before FailureAction is executed. It is first interpreted as a string representing an ISO 8601 duration. If that fails, then it is interpreted as a number representing the total number of milliseconds.
          """
          return pulumi.get(self, "health_check_retry_timeout")
  
      @property
      @pulumi.getter(name="healthCheckStableDuration")
      def health_check_stable_duration(self) -> Optional[str]:
          """
          The amount of time that the application or cluster must remain healthy before the upgrade proceeds to the next upgrade domain. It is first interpreted as a string representing an ISO 8601 duration. If that fails, then it is interpreted as a number representing the total number of milliseconds.
          """
          return pulumi.get(self, "health_check_stable_duration")
  
      @property
      @pulumi.getter(name="healthCheckWaitDuration")
      def health_check_wait_duration(self) -> Optional[str]:
          """
          The amount of time to wait after completing an upgrade domain before applying health policies. It is first interpreted as a string representing an ISO 8601 duration. If that fails, then it is interpreted as a number representing the total number of milliseconds.
          """
          return pulumi.get(self, "health_check_wait_duration")
  
      @property
      @pulumi.getter(name="upgradeDomainTimeout")
      def upgrade_domain_timeout(self) -> Optional[str]:
          """
          The amount of time each upgrade domain has to complete before FailureAction is executed. It is first interpreted as a string representing an ISO 8601 duration. If that fails, then it is interpreted as a number representing the total number of milliseconds.
          """
          return pulumi.get(self, "upgrade_domain_timeout")
  
      @property
      @pulumi.getter(name="upgradeTimeout")
      def upgrade_timeout(self) -> Optional[str]:
          """
          The amount of time the overall upgrade has to complete before FailureAction is executed. It is first interpreted as a string representing an ISO 8601 duration. If that fails, then it is interpreted as a number representing the total number of milliseconds.
          """
          return pulumi.get(self, "upgrade_timeout")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ArmServiceTypeHealthPolicyResponse(dict):
      """
      Represents the health policy used to evaluate the health of services belonging to a service type.
      """
      def __init__(__self__, *,
                   max_percent_unhealthy_partitions_per_service: Optional[int] = None,
                   max_percent_unhealthy_replicas_per_partition: Optional[int] = None,
                   max_percent_unhealthy_services: Optional[int] = None):
          """
          Represents the health policy used to evaluate the health of services belonging to a service type.
  
          :param int max_percent_unhealthy_partitions_per_service: The maximum percentage of partitions per service allowed to be unhealthy before your application is considered in error.
          :param int max_percent_unhealthy_replicas_per_partition: The maximum percentage of replicas per partition allowed to be unhealthy before your application is considered in error.
          :param int max_percent_unhealthy_services: The maximum percentage of services allowed to be unhealthy before your application is considered in error.
          """
          if max_percent_unhealthy_partitions_per_service is not None:
              pulumi.set(__self__, "max_percent_unhealthy_partitions_per_service", max_percent_unhealthy_partitions_per_service)
          if max_percent_unhealthy_replicas_per_partition is not None:
              pulumi.set(__self__, "max_percent_unhealthy_replicas_per_partition", max_percent_unhealthy_replicas_per_partition)
          if max_percent_unhealthy_services is not None:
              pulumi.set(__self__, "max_percent_unhealthy_services", max_percent_unhealthy_services)
  
      @property
      @pulumi.getter(name="maxPercentUnhealthyPartitionsPerService")
      def max_percent_unhealthy_partitions_per_service(self) -> Optional[int]:
          """
          The maximum percentage of partitions per service allowed to be unhealthy before your application is considered in error.
          """
          return pulumi.get(self, "max_percent_unhealthy_partitions_per_service")
  
      @property
      @pulumi.getter(name="maxPercentUnhealthyReplicasPerPartition")
      def max_percent_unhealthy_replicas_per_partition(self) -> Optional[int]:
          """
          The maximum percentage of replicas per partition allowed to be unhealthy before your application is considered in error.
          """
          return pulumi.get(self, "max_percent_unhealthy_replicas_per_partition")
  
      @property
      @pulumi.getter(name="maxPercentUnhealthyServices")
      def max_percent_unhealthy_services(self) -> Optional[int]:
          """
          The maximum percentage of services allowed to be unhealthy before your application is considered in error.
          """
          return pulumi.get(self, "max_percent_unhealthy_services")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class AzureActiveDirectoryResponse(dict):
      """
      The settings to enable AAD authentication on the cluster.
      """
      def __init__(__self__, *,
                   client_application: Optional[str] = None,
                   cluster_application: Optional[str] = None,
                   tenant_id: Optional[str] = None):
          """
          The settings to enable AAD authentication on the cluster.
          :param str client_application: Azure active directory client application id.
          :param str cluster_application: Azure active directory cluster application id.
          :param str tenant_id: Azure active directory tenant id.
          """
          if client_application is not None:
              pulumi.set(__self__, "client_application", client_application)
          if cluster_application is not None:
              pulumi.set(__self__, "cluster_application", cluster_application)
          if tenant_id is not None:
              pulumi.set(__self__, "tenant_id", tenant_id)
  
      @property
      @pulumi.getter(name="clientApplication")
      def client_application(self) -> Optional[str]:
          """
          Azure active directory client application id.
          """
          return pulumi.get(self, "client_application")
  
      @property
      @pulumi.getter(name="clusterApplication")
      def cluster_application(self) -> Optional[str]:
          """
          Azure active directory cluster application id.
          """
          return pulumi.get(self, "cluster_application")
  
      @property
      @pulumi.getter(name="tenantId")
      def tenant_id(self) -> Optional[str]:
          """
          Azure active directory tenant id.
          """
          return pulumi.get(self, "tenant_id")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class CertificateDescriptionResponse(dict):
      """
      Describes the certificate details.
      """
      def __init__(__self__, *,
                   thumbprint: str,
                   thumbprint_secondary: Optional[str] = None,
                   x509_store_name: Optional[str] = None):
          """
          Describes the certificate details.
          :param str thumbprint: Thumbprint of the primary certificate.
          :param str thumbprint_secondary: Thumbprint of the secondary certificate.
          :param str x509_store_name: The local certificate store location.
          """
          pulumi.set(__self__, "thumbprint", thumbprint)
          if thumbprint_secondary is not None:
              pulumi.set(__self__, "thumbprint_secondary", thumbprint_secondary)
          if x509_store_name is not None:
              pulumi.set(__self__, "x509_store_name", x509_store_name)
  
      @property
      @pulumi.getter
      def thumbprint(self) -> str:
          """
          Thumbprint of the primary certificate.
          """
          return pulumi.get(self, "thumbprint")
  
      @property
      @pulumi.getter(name="thumbprintSecondary")
      def thumbprint_secondary(self) -> Optional[str]:
          """
          Thumbprint of the secondary certificate.
          """
          return pulumi.get(self, "thumbprint_secondary")
  
      @property
      @pulumi.getter(name="x509StoreName")
      def x509_store_name(self) -> Optional[str]:
          """
          The local certificate store location.
          """
          return pulumi.get(self, "x509_store_name")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ClientCertificateCommonNameResponse(dict):
      """
      Describes the client certificate details using common name.
      """
      def __init__(__self__, *,
                   certificate_common_name: str,
                   certificate_issuer_thumbprint: str,
                   is_admin: bool):
          """
          Describes the client certificate details using common name.
          :param str certificate_common_name: The common name of the client certificate.
          :param str certificate_issuer_thumbprint: The issuer thumbprint of the client certificate.
          :param bool is_admin: Indicates if the client certificate has admin access to the cluster. Non admin clients can perform only read only operations on the cluster.
          """
          pulumi.set(__self__, "certificate_common_name", certificate_common_name)
          pulumi.set(__self__, "certificate_issuer_thumbprint", certificate_issuer_thumbprint)
          pulumi.set(__self__, "is_admin", is_admin)
  
      @property
      @pulumi.getter(name="certificateCommonName")
      def certificate_common_name(self) -> str:
          """
          The common name of the client certificate.
          """
          return pulumi.get(self, "certificate_common_name")
  
      @property
      @pulumi.getter(name="certificateIssuerThumbprint")
      def certificate_issuer_thumbprint(self) -> str:
          """
          The issuer thumbprint of the client certificate.
          """
          return pulumi.get(self, "certificate_issuer_thumbprint")
  
      @property
      @pulumi.getter(name="isAdmin")
      def is_admin(self) -> bool:
          """
          Indicates if the client certificate has admin access to the cluster. Non admin clients can perform only read only operations on the cluster.
          """
          return pulumi.get(self, "is_admin")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ClientCertificateThumbprintResponse(dict):
      """
      Describes the client certificate details using thumbprint.
      """
      def __init__(__self__, *,
                   certificate_thumbprint: str,
                   is_admin: bool):
          """
          Describes the client certificate details using thumbprint.
          :param str certificate_thumbprint: The thumbprint of the client certificate.
          :param bool is_admin: Indicates if the client certificate has admin access to the cluster. Non admin clients can perform only read only operations on the cluster.
          """
          pulumi.set(__self__, "certificate_thumbprint", certificate_thumbprint)
          pulumi.set(__self__, "is_admin", is_admin)
  
      @property
      @pulumi.getter(name="certificateThumbprint")
      def certificate_thumbprint(self) -> str:
          """
          The thumbprint of the client certificate.
          """
          return pulumi.get(self, "certificate_thumbprint")
  
      @property
      @pulumi.getter(name="isAdmin")
      def is_admin(self) -> bool:
          """
          Indicates if the client certificate has admin access to the cluster. Non admin clients can perform only read only operations on the cluster.
          """
          return pulumi.get(self, "is_admin")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ClusterHealthPolicyResponse(dict):
      """
      Defines a health policy used to evaluate the health of the cluster or of a cluster node.
      """
      def __init__(__self__, *,
                   application_health_policies: Optional[Mapping[str, 'outputs.ApplicationHealthPolicyResponse']] = None,
                   max_percent_unhealthy_applications: Optional[int] = None,
                   max_percent_unhealthy_nodes: Optional[int] = None):
          """
          Defines a health policy used to evaluate the health of the cluster or of a cluster node.
  
          :param Mapping[str, 'ApplicationHealthPolicyResponseArgs'] application_health_policies: Defines the application health policy map used to evaluate the health of an application or one of its children entities.
          :param int max_percent_unhealthy_applications: The maximum allowed percentage of unhealthy applications before reporting an error. For example, to allow 10% of applications to be unhealthy, this value would be 10.
                 
                 The percentage represents the maximum tolerated percentage of applications that can be unhealthy before the cluster is considered in error.
                 If the percentage is respected but there is at least one unhealthy application, the health is evaluated as Warning.
                 This is calculated by dividing the number of unhealthy applications over the total number of application instances in the cluster, excluding applications of application types that are included in the ApplicationTypeHealthPolicyMap.
                 The computation rounds up to tolerate one failure on small numbers of applications. Default percentage is zero.
          :param int max_percent_unhealthy_nodes: The maximum allowed percentage of unhealthy nodes before reporting an error. For example, to allow 10% of nodes to be unhealthy, this value would be 10.
                 
                 The percentage represents the maximum tolerated percentage of nodes that can be unhealthy before the cluster is considered in error.
                 If the percentage is respected but there is at least one unhealthy node, the health is evaluated as Warning.
                 The percentage is calculated by dividing the number of unhealthy nodes over the total number of nodes in the cluster.
                 The computation rounds up to tolerate one failure on small numbers of nodes. Default percentage is zero.
                 
                 In large clusters, some nodes will always be down or out for repairs, so this percentage should be configured to tolerate that.
          """
          if application_health_policies is not None:
              pulumi.set(__self__, "application_health_policies", application_health_policies)
          if max_percent_unhealthy_applications is not None:
              pulumi.set(__self__, "max_percent_unhealthy_applications", max_percent_unhealthy_applications)
          if max_percent_unhealthy_nodes is not None:
              pulumi.set(__self__, "max_percent_unhealthy_nodes", max_percent_unhealthy_nodes)
  
      @property
      @pulumi.getter(name="applicationHealthPolicies")
      def application_health_policies(self) -> Optional[Mapping[str, 'outputs.ApplicationHealthPolicyResponse']]:
          """
          Defines the application health policy map used to evaluate the health of an application or one of its children entities.
          """
          return pulumi.get(self, "application_health_policies")
  
      @property
      @pulumi.getter(name="maxPercentUnhealthyApplications")
      def max_percent_unhealthy_applications(self) -> Optional[int]:
          """
          The maximum allowed percentage of unhealthy applications before reporting an error. For example, to allow 10% of applications to be unhealthy, this value would be 10.
  
          The percentage represents the maximum tolerated percentage of applications that can be unhealthy before the cluster is considered in error.
          If the percentage is respected but there is at least one unhealthy application, the health is evaluated as Warning.
          This is calculated by dividing the number of unhealthy applications over the total number of application instances in the cluster, excluding applications of application types that are included in the ApplicationTypeHealthPolicyMap.
          The computation rounds up to tolerate one failure on small numbers of applications. Default percentage is zero.
          """
          return pulumi.get(self, "max_percent_unhealthy_applications")
  
      @property
      @pulumi.getter(name="maxPercentUnhealthyNodes")
      def max_percent_unhealthy_nodes(self) -> Optional[int]:
          """
          The maximum allowed percentage of unhealthy nodes before reporting an error. For example, to allow 10% of nodes to be unhealthy, this value would be 10.
  
          The percentage represents the maximum tolerated percentage of nodes that can be unhealthy before the cluster is considered in error.
          If the percentage is respected but there is at least one unhealthy node, the health is evaluated as Warning.
          The percentage is calculated by dividing the number of unhealthy nodes over the total number of nodes in the cluster.
          The computation rounds up to tolerate one failure on small numbers of nodes. Default percentage is zero.
  
          In large clusters, some nodes will always be down or out for repairs, so this percentage should be configured to tolerate that.
          """
          return pulumi.get(self, "max_percent_unhealthy_nodes")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ClusterUpgradeDeltaHealthPolicyResponse(dict):
      """
      Describes the delta health policies for the cluster upgrade.
      """
      def __init__(__self__, *,
                   max_percent_delta_unhealthy_applications: int,
                   max_percent_delta_unhealthy_nodes: int,
                   max_percent_upgrade_domain_delta_unhealthy_nodes: int,
                   application_delta_health_policies: Optional[Mapping[str, 'outputs.ApplicationDeltaHealthPolicyResponse']] = None):
          """
          Describes the delta health policies for the cluster upgrade.
          :param int max_percent_delta_unhealthy_applications: The maximum allowed percentage of applications health degradation allowed during cluster upgrades.
                 The delta is measured between the state of the applications at the beginning of upgrade and the state of the applications at the time of the health evaluation.
                 The check is performed after every upgrade domain upgrade completion to make sure the global state of the cluster is within tolerated limits. System services are not included in this.
          :param int max_percent_delta_unhealthy_nodes: The maximum allowed percentage of nodes health degradation allowed during cluster upgrades.
                 The delta is measured between the state of the nodes at the beginning of upgrade and the state of the nodes at the time of the health evaluation.
                 The check is performed after every upgrade domain upgrade completion to make sure the global state of the cluster is within tolerated limits.
          :param int max_percent_upgrade_domain_delta_unhealthy_nodes: The maximum allowed percentage of upgrade domain nodes health degradation allowed during cluster upgrades.
                 The delta is measured between the state of the upgrade domain nodes at the beginning of upgrade and the state of the upgrade domain nodes at the time of the health evaluation.
                 The check is performed after every upgrade domain upgrade completion for all completed upgrade domains to make sure the state of the upgrade domains is within tolerated limits.
          :param Mapping[str, 'ApplicationDeltaHealthPolicyResponseArgs'] application_delta_health_policies: Defines the application delta health policy map used to evaluate the health of an application or one of its child entities when upgrading the cluster.
          """
          pulumi.set(__self__, "max_percent_delta_unhealthy_applications", max_percent_delta_unhealthy_applications)
          pulumi.set(__self__, "max_percent_delta_unhealthy_nodes", max_percent_delta_unhealthy_nodes)
          pulumi.set(__self__, "max_percent_upgrade_domain_delta_unhealthy_nodes", max_percent_upgrade_domain_delta_unhealthy_nodes)
          if application_delta_health_policies is not None:
              pulumi.set(__self__, "application_delta_health_policies", application_delta_health_policies)
  
      @property
      @pulumi.getter(name="maxPercentDeltaUnhealthyApplications")
      def max_percent_delta_unhealthy_applications(self) -> int:
          """
          The maximum allowed percentage of applications health degradation allowed during cluster upgrades.
          The delta is measured between the state of the applications at the beginning of upgrade and the state of the applications at the time of the health evaluation.
          The check is performed after every upgrade domain upgrade completion to make sure the global state of the cluster is within tolerated limits. System services are not included in this.
          """
          return pulumi.get(self, "max_percent_delta_unhealthy_applications")
  
      @property
      @pulumi.getter(name="maxPercentDeltaUnhealthyNodes")
      def max_percent_delta_unhealthy_nodes(self) -> int:
          """
          The maximum allowed percentage of nodes health degradation allowed during cluster upgrades.
          The delta is measured between the state of the nodes at the beginning of upgrade and the state of the nodes at the time of the health evaluation.
          The check is performed after every upgrade domain upgrade completion to make sure the global state of the cluster is within tolerated limits.
          """
          return pulumi.get(self, "max_percent_delta_unhealthy_nodes")
  
      @property
      @pulumi.getter(name="maxPercentUpgradeDomainDeltaUnhealthyNodes")
      def max_percent_upgrade_domain_delta_unhealthy_nodes(self) -> int:
          """
          The maximum allowed percentage of upgrade domain nodes health degradation allowed during cluster upgrades.
          The delta is measured between the state of the upgrade domain nodes at the beginning of upgrade and the state of the upgrade domain nodes at the time of the health evaluation.
          The check is performed after every upgrade domain upgrade completion for all completed upgrade domains to make sure the state of the upgrade domains is within tolerated limits.
          """
          return pulumi.get(self, "max_percent_upgrade_domain_delta_unhealthy_nodes")
  
      @property
      @pulumi.getter(name="applicationDeltaHealthPolicies")
      def application_delta_health_policies(self) -> Optional[Mapping[str, 'outputs.ApplicationDeltaHealthPolicyResponse']]:
          """
          Defines the application delta health policy map used to evaluate the health of an application or one of its child entities when upgrading the cluster.
          """
          return pulumi.get(self, "application_delta_health_policies")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ClusterUpgradePolicyResponse(dict):
      """
      Describes the policy used when upgrading the cluster.
      """
      def __init__(__self__, *,
                   health_check_retry_timeout: str,
                   health_check_stable_duration: str,
                   health_check_wait_duration: str,
                   health_policy: 'outputs.ClusterHealthPolicyResponse',
                   upgrade_domain_timeout: str,
                   upgrade_replica_set_check_timeout: str,
                   upgrade_timeout: str,
                   delta_health_policy: Optional['outputs.ClusterUpgradeDeltaHealthPolicyResponse'] = None,
                   force_restart: Optional[bool] = None):
          """
          Describes the policy used when upgrading the cluster.
          :param str health_check_retry_timeout: The amount of time to retry health evaluation when the application or cluster is unhealthy before the upgrade rolls back. The timeout can be in either hh:mm:ss or in d.hh:mm:ss.ms format.
          :param str health_check_stable_duration: The amount of time that the application or cluster must remain healthy before the upgrade proceeds to the next upgrade domain. The duration can be in either hh:mm:ss or in d.hh:mm:ss.ms format.
          :param str health_check_wait_duration: The length of time to wait after completing an upgrade domain before performing health checks. The duration can be in either hh:mm:ss or in d.hh:mm:ss.ms format.
          :param 'ClusterHealthPolicyResponseArgs' health_policy: The cluster health policy used when upgrading the cluster.
          :param str upgrade_domain_timeout: The amount of time each upgrade domain has to complete before the upgrade rolls back. The timeout can be in either hh:mm:ss or in d.hh:mm:ss.ms format.
          :param str upgrade_replica_set_check_timeout: The maximum amount of time to block processing of an upgrade domain and prevent loss of availability when there are unexpected issues. When this timeout expires, processing of the upgrade domain will proceed regardless of availability loss issues. The timeout is reset at the start of each upgrade domain. The timeout can be in either hh:mm:ss or in d.hh:mm:ss.ms format.
          :param str upgrade_timeout: The amount of time the overall upgrade has to complete before the upgrade rolls back. The timeout can be in either hh:mm:ss or in d.hh:mm:ss.ms format.
          :param 'ClusterUpgradeDeltaHealthPolicyResponseArgs' delta_health_policy: The cluster delta health policy used when upgrading the cluster.
          :param bool force_restart: If true, then processes are forcefully restarted during upgrade even when the code version has not changed (the upgrade only changes configuration or data).
          """
          pulumi.set(__self__, "health_check_retry_timeout", health_check_retry_timeout)
          pulumi.set(__self__, "health_check_stable_duration", health_check_stable_duration)
          pulumi.set(__self__, "health_check_wait_duration", health_check_wait_duration)
          pulumi.set(__self__, "health_policy", health_policy)
          pulumi.set(__self__, "upgrade_domain_timeout", upgrade_domain_timeout)
          pulumi.set(__self__, "upgrade_replica_set_check_timeout", upgrade_replica_set_check_timeout)
          pulumi.set(__self__, "upgrade_timeout", upgrade_timeout)
          if delta_health_policy is not None:
              pulumi.set(__self__, "delta_health_policy", delta_health_policy)
          if force_restart is not None:
              pulumi.set(__self__, "force_restart", force_restart)
  
      @property
      @pulumi.getter(name="healthCheckRetryTimeout")
      def health_check_retry_timeout(self) -> str:
          """
          The amount of time to retry health evaluation when the application or cluster is unhealthy before the upgrade rolls back. The timeout can be in either hh:mm:ss or in d.hh:mm:ss.ms format.
          """
          return pulumi.get(self, "health_check_retry_timeout")
  
      @property
      @pulumi.getter(name="healthCheckStableDuration")
      def health_check_stable_duration(self) -> str:
          """
          The amount of time that the application or cluster must remain healthy before the upgrade proceeds to the next upgrade domain. The duration can be in either hh:mm:ss or in d.hh:mm:ss.ms format.
          """
          return pulumi.get(self, "health_check_stable_duration")
  
      @property
      @pulumi.getter(name="healthCheckWaitDuration")
      def health_check_wait_duration(self) -> str:
          """
          The length of time to wait after completing an upgrade domain before performing health checks. The duration can be in either hh:mm:ss or in d.hh:mm:ss.ms format.
          """
          return pulumi.get(self, "health_check_wait_duration")
  
      @property
      @pulumi.getter(name="healthPolicy")
      def health_policy(self) -> 'outputs.ClusterHealthPolicyResponse':
          """
          The cluster health policy used when upgrading the cluster.
          """
          return pulumi.get(self, "health_policy")
  
      @property
      @pulumi.getter(name="upgradeDomainTimeout")
      def upgrade_domain_timeout(self) -> str:
          """
          The amount of time each upgrade domain has to complete before the upgrade rolls back. The timeout can be in either hh:mm:ss or in d.hh:mm:ss.ms format.
          """
          return pulumi.get(self, "upgrade_domain_timeout")
  
      @property
      @pulumi.getter(name="upgradeReplicaSetCheckTimeout")
      def upgrade_replica_set_check_timeout(self) -> str:
          """
          The maximum amount of time to block processing of an upgrade domain and prevent loss of availability when there are unexpected issues. When this timeout expires, processing of the upgrade domain will proceed regardless of availability loss issues. The timeout is reset at the start of each upgrade domain. The timeout can be in either hh:mm:ss or in d.hh:mm:ss.ms format.
          """
          return pulumi.get(self, "upgrade_replica_set_check_timeout")
  
      @property
      @pulumi.getter(name="upgradeTimeout")
      def upgrade_timeout(self) -> str:
          """
          The amount of time the overall upgrade has to complete before the upgrade rolls back. The timeout can be in either hh:mm:ss or in d.hh:mm:ss.ms format.
          """
          return pulumi.get(self, "upgrade_timeout")
  
      @property
      @pulumi.getter(name="deltaHealthPolicy")
      def delta_health_policy(self) -> Optional['outputs.ClusterUpgradeDeltaHealthPolicyResponse']:
          """
          The cluster delta health policy used when upgrading the cluster.
          """
          return pulumi.get(self, "delta_health_policy")
  
      @property
      @pulumi.getter(name="forceRestart")
      def force_restart(self) -> Optional[bool]:
          """
          If true, then processes are forcefully restarted during upgrade even when the code version has not changed (the upgrade only changes configuration or data).
          """
          return pulumi.get(self, "force_restart")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ClusterVersionDetailsResponse(dict):
      """
      The detail of the Service Fabric runtime version result
      """
      def __init__(__self__, *,
                   code_version: Optional[str] = None,
                   environment: Optional[str] = None,
                   support_expiry_utc: Optional[str] = None):
          """
          The detail of the Service Fabric runtime version result
          :param str code_version: The Service Fabric runtime version of the cluster.
          :param str environment: Indicates if this version is for Windows or Linux operating system.
          :param str support_expiry_utc: The date of expiry of support of the version.
          """
          if code_version is not None:
              pulumi.set(__self__, "code_version", code_version)
          if environment is not None:
              pulumi.set(__self__, "environment", environment)
          if support_expiry_utc is not None:
              pulumi.set(__self__, "support_expiry_utc", support_expiry_utc)
  
      @property
      @pulumi.getter(name="codeVersion")
      def code_version(self) -> Optional[str]:
          """
          The Service Fabric runtime version of the cluster.
          """
          return pulumi.get(self, "code_version")
  
      @property
      @pulumi.getter
      def environment(self) -> Optional[str]:
          """
          Indicates if this version is for Windows or Linux operating system.
          """
          return pulumi.get(self, "environment")
  
      @property
      @pulumi.getter(name="supportExpiryUtc")
      def support_expiry_utc(self) -> Optional[str]:
          """
          The date of expiry of support of the version.
          """
          return pulumi.get(self, "support_expiry_utc")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class DiagnosticsStorageAccountConfigResponse(dict):
      """
      The storage account information for storing Service Fabric diagnostic logs.
      """
      def __init__(__self__, *,
                   blob_endpoint: str,
                   protected_account_key_name: str,
                   queue_endpoint: str,
                   storage_account_name: str,
                   table_endpoint: str,
                   protected_account_key_name2: Optional[str] = None):
          """
          The storage account information for storing Service Fabric diagnostic logs.
          :param str blob_endpoint: The blob endpoint of the azure storage account.
          :param str protected_account_key_name: The protected diagnostics storage key name.
          :param str queue_endpoint: The queue endpoint of the azure storage account.
          :param str storage_account_name: The Azure storage account name.
          :param str table_endpoint: The table endpoint of the azure storage account.
          :param str protected_account_key_name2: The secondary protected diagnostics storage key name. If one of the storage account keys is rotated the cluster will fallback to using the other.
          """
          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)
          if protected_account_key_name2 is not None:
              pulumi.set(__self__, "protected_account_key_name2", protected_account_key_name2)
  
      @property
      @pulumi.getter(name="blobEndpoint")
      def blob_endpoint(self) -> str:
          """
          The blob endpoint of the azure 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.
          """
          return pulumi.get(self, "protected_account_key_name")
  
      @property
      @pulumi.getter(name="queueEndpoint")
      def queue_endpoint(self) -> str:
          """
          The queue endpoint of the azure storage account.
          """
          return pulumi.get(self, "queue_endpoint")
  
      @property
      @pulumi.getter(name="storageAccountName")
      def storage_account_name(self) -> str:
          """
          The Azure storage account name.
          """
          return pulumi.get(self, "storage_account_name")
  
      @property
      @pulumi.getter(name="tableEndpoint")
      def table_endpoint(self) -> str:
          """
          The table endpoint of the azure storage account.
          """
          return pulumi.get(self, "table_endpoint")
  
      @property
      @pulumi.getter(name="protectedAccountKeyName2")
      def protected_account_key_name2(self) -> Optional[str]:
          """
          The secondary protected diagnostics storage key name. If one of the storage account keys is rotated the cluster will fallback to using the other.
          """
          return pulumi.get(self, "protected_account_key_name2")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class EndpointRangeDescriptionResponse(dict):
      """
      Port range details
      """
      def __init__(__self__, *,
                   end_port: int,
                   start_port: int):
          """
          Port range details
          :param int end_port: End port of a range of ports
          :param int start_port: Starting port of a range of ports
          """
          pulumi.set(__self__, "end_port", end_port)
          pulumi.set(__self__, "start_port", start_port)
  
      @property
      @pulumi.getter(name="endPort")
      def end_port(self) -> int:
          """
          End port of a range of ports
          """
          return pulumi.get(self, "end_port")
  
      @property
      @pulumi.getter(name="startPort")
      def start_port(self) -> int:
          """
          Starting port of a range of ports
          """
          return pulumi.get(self, "start_port")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ManagedIdentityResponse(dict):
      """
      Describes the managed identities for an Azure resource.
      """
      def __init__(__self__, *,
                   principal_id: str,
                   tenant_id: str,
                   type: Optional[str] = None,
                   user_assigned_identities: Optional[Mapping[str, 'outputs.UserAssignedIdentityResponse']] = None):
          """
          Describes the managed identities for an Azure resource.
          :param str principal_id: The principal id of the managed identity. This property will only be provided for a system assigned identity.
          :param str tenant_id: The tenant id of the managed identity. This property will only be provided for a system assigned identity.
          :param str type: The type of managed identity for the resource.
          :param Mapping[str, 'UserAssignedIdentityResponseArgs'] user_assigned_identities: The list of user identities associated with the resource. The user identity dictionary key references will be ARM resource ids in the form:
                 '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
          """
          pulumi.set(__self__, "principal_id", principal_id)
          pulumi.set(__self__, "tenant_id", tenant_id)
          if type is not None:
              pulumi.set(__self__, "type", type)
          if user_assigned_identities is not None:
              pulumi.set(__self__, "user_assigned_identities", user_assigned_identities)
  
      @property
      @pulumi.getter(name="principalId")
      def principal_id(self) -> str:
          """
          The principal id of the managed identity. This property will only be provided for a system assigned identity.
          """
          return pulumi.get(self, "principal_id")
  
      @property
      @pulumi.getter(name="tenantId")
      def tenant_id(self) -> str:
          """
          The tenant id of the managed identity. This property will only be provided for a system assigned identity.
          """
          return pulumi.get(self, "tenant_id")
  
      @property
      @pulumi.getter
      def type(self) -> Optional[str]:
          """
          The type of managed identity for the resource.
          """
          return pulumi.get(self, "type")
  
      @property
      @pulumi.getter(name="userAssignedIdentities")
      def user_assigned_identities(self) -> Optional[Mapping[str, 'outputs.UserAssignedIdentityResponse']]:
          """
          The list of user identities associated with the resource. The user identity dictionary key references will be ARM resource ids in the form:
          '/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.ManagedIdentity/userAssignedIdentities/{identityName}'.
          """
          return pulumi.get(self, "user_assigned_identities")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class NamedPartitionSchemeDescriptionResponse(dict):
      """
      Describes the named partition scheme of the service.
      """
      def __init__(__self__, *,
                   count: int,
                   names: Sequence[str],
                   partition_scheme: str):
          """
          Describes the named partition scheme of the service.
          :param int count: The number of partitions.
          :param Sequence[str] names: Array of size specified by the ‘Count’ parameter, for the names of the partitions.
          :param str partition_scheme: Specifies how the service is partitioned.
          """
          pulumi.set(__self__, "count", count)
          pulumi.set(__self__, "names", names)
          pulumi.set(__self__, "partition_scheme", 'Named')
  
      @property
      @pulumi.getter
      def count(self) -> int:
          """
          The number of partitions.
          """
          return pulumi.get(self, "count")
  
      @property
      @pulumi.getter
      def names(self) -> Sequence[str]:
          """
          Array of size specified by the ‘Count’ parameter, for the names of the partitions.
          """
          return pulumi.get(self, "names")
  
      @property
      @pulumi.getter(name="partitionScheme")
      def partition_scheme(self) -> str:
          """
          Specifies how the service is partitioned.
          """
          return pulumi.get(self, "partition_scheme")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class NodeTypeDescriptionResponse(dict):
      """
      Describes a node type in the cluster, each node type represents sub set of nodes in the cluster.
      """
      def __init__(__self__, *,
                   client_connection_endpoint_port: int,
                   http_gateway_endpoint_port: int,
                   is_primary: bool,
                   name: str,
                   vm_instance_count: int,
                   application_ports: Optional['outputs.EndpointRangeDescriptionResponse'] = None,
                   capacities: Optional[Mapping[str, str]] = None,
                   durability_level: Optional[str] = None,
                   ephemeral_ports: Optional['outputs.EndpointRangeDescriptionResponse'] = None,
                   placement_properties: Optional[Mapping[str, str]] = None,
                   reverse_proxy_endpoint_port: Optional[int] = None):
          """
          Describes a node type in the cluster, each node type represents sub set of nodes in the cluster.
          :param int client_connection_endpoint_port: The TCP cluster management endpoint port.
          :param int http_gateway_endpoint_port: The HTTP cluster management endpoint port.
          :param bool is_primary: The node type on which system services will run. Only one node type should be marked as primary. Primary node type cannot be deleted or changed for existing clusters.
          :param str name: The name of the node type.
          :param int vm_instance_count: The number of nodes in the node type. This count should match the capacity property in the corresponding VirtualMachineScaleSet resource.
          :param 'EndpointRangeDescriptionResponseArgs' application_ports: The range of ports from which cluster assigned port to Service Fabric applications.
          :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 of the node type. Learn about [DurabilityLevel](https://docs.microsoft.com/azure/service-fabric/service-fabric-cluster-capacity).
                 
                   - Bronze - No privileges. This is the default.
                   - Silver - The infrastructure jobs can be paused for a duration of 10 minutes per UD.
                   - Gold - The infrastructure jobs can be paused for a duration of 2 hours per UD. Gold durability can be enabled only on full node VM skus like D15_V2, G5 etc.
          :param 'EndpointRangeDescriptionResponseArgs' ephemeral_ports: The range of ephemeral ports that nodes in this node type should be configured with.
          :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 endpoint used by reverse proxy.
          """
          pulumi.set(__self__, "client_connection_endpoint_port", client_connection_endpoint_port)
          pulumi.set(__self__, "http_gateway_endpoint_port", http_gateway_endpoint_port)
          pulumi.set(__self__, "is_primary", is_primary)
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "vm_instance_count", vm_instance_count)
          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="clientConnectionEndpointPort")
      def client_connection_endpoint_port(self) -> int:
          """
          The TCP cluster management endpoint port.
          """
          return pulumi.get(self, "client_connection_endpoint_port")
  
      @property
      @pulumi.getter(name="httpGatewayEndpointPort")
      def http_gateway_endpoint_port(self) -> int:
          """
          The HTTP cluster management endpoint port.
          """
          return pulumi.get(self, "http_gateway_endpoint_port")
  
      @property
      @pulumi.getter(name="isPrimary")
      def is_primary(self) -> bool:
          """
          The node type on which system services will run. Only one node type should be marked as primary. Primary node type cannot be deleted or changed for existing clusters.
          """
          return pulumi.get(self, "is_primary")
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          The name of the node type.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter(name="vmInstanceCount")
      def vm_instance_count(self) -> int:
          """
          The number of nodes in the node type. This count should match the capacity property in the corresponding VirtualMachineScaleSet resource.
          """
          return pulumi.get(self, "vm_instance_count")
  
      @property
      @pulumi.getter(name="applicationPorts")
      def application_ports(self) -> Optional['outputs.EndpointRangeDescriptionResponse']:
          """
          The range of ports from which cluster assigned port to Service Fabric applications.
          """
          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 of the node type. Learn about [DurabilityLevel](https://docs.microsoft.com/azure/service-fabric/service-fabric-cluster-capacity).
  
            - Bronze - No privileges. This is the default.
            - Silver - The infrastructure jobs can be paused for a duration of 10 minutes per UD.
            - Gold - The infrastructure jobs can be paused for a duration of 2 hours per UD. Gold durability can be enabled only on full node VM skus like D15_V2, G5 etc.
          """
          return pulumi.get(self, "durability_level")
  
      @property
      @pulumi.getter(name="ephemeralPorts")
      def ephemeral_ports(self) -> Optional['outputs.EndpointRangeDescriptionResponse']:
          """
          The range of ephemeral ports that nodes in this node type should be configured with.
          """
          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 endpoint used by reverse proxy.
          """
          return pulumi.get(self, "reverse_proxy_endpoint_port")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ServerCertificateCommonNameResponse(dict):
      """
      Describes the server certificate details using common name.
      """
      def __init__(__self__, *,
                   certificate_common_name: str,
                   certificate_issuer_thumbprint: str):
          """
          Describes the server certificate details using common name.
          :param str certificate_common_name: The common name of the server certificate.
          :param str certificate_issuer_thumbprint: The issuer thumbprint of the server certificate.
          """
          pulumi.set(__self__, "certificate_common_name", certificate_common_name)
          pulumi.set(__self__, "certificate_issuer_thumbprint", certificate_issuer_thumbprint)
  
      @property
      @pulumi.getter(name="certificateCommonName")
      def certificate_common_name(self) -> str:
          """
          The common name of the server certificate.
          """
          return pulumi.get(self, "certificate_common_name")
  
      @property
      @pulumi.getter(name="certificateIssuerThumbprint")
      def certificate_issuer_thumbprint(self) -> str:
          """
          The issuer thumbprint of the server certificate.
          """
          return pulumi.get(self, "certificate_issuer_thumbprint")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ServerCertificateCommonNamesResponse(dict):
      """
      Describes a list of server certificates referenced by common name that are used to secure the cluster.
      """
      def __init__(__self__, *,
                   common_names: Optional[Sequence['outputs.ServerCertificateCommonNameResponse']] = None,
                   x509_store_name: Optional[str] = None):
          """
          Describes a list of server certificates referenced by common name that are used to secure the cluster.
          :param Sequence['ServerCertificateCommonNameResponseArgs'] common_names: The list of server certificates referenced by common name that are used to secure the cluster.
          :param str x509_store_name: The local certificate store location.
          """
          if common_names is not None:
              pulumi.set(__self__, "common_names", common_names)
          if x509_store_name is not None:
              pulumi.set(__self__, "x509_store_name", x509_store_name)
  
      @property
      @pulumi.getter(name="commonNames")
      def common_names(self) -> Optional[Sequence['outputs.ServerCertificateCommonNameResponse']]:
          """
          The list of server certificates referenced by common name that are used to secure the cluster.
          """
          return pulumi.get(self, "common_names")
  
      @property
      @pulumi.getter(name="x509StoreName")
      def x509_store_name(self) -> Optional[str]:
          """
          The local certificate store location.
          """
          return pulumi.get(self, "x509_store_name")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ServiceCorrelationDescriptionResponse(dict):
      """
      Creates a particular correlation between services.
      """
      def __init__(__self__, *,
                   scheme: str,
                   service_name: str):
          """
          Creates a particular correlation between services.
          :param str scheme: The ServiceCorrelationScheme which describes the relationship between this service and the service specified via ServiceName.
          :param str service_name: The name of the service that the correlation relationship is established with.
          """
          pulumi.set(__self__, "scheme", scheme)
          pulumi.set(__self__, "service_name", service_name)
  
      @property
      @pulumi.getter
      def scheme(self) -> str:
          """
          The ServiceCorrelationScheme which describes the relationship between this service and the service specified via ServiceName.
          """
          return pulumi.get(self, "scheme")
  
      @property
      @pulumi.getter(name="serviceName")
      def service_name(self) -> str:
          """
          The name of the service that the correlation relationship is established with.
          """
          return pulumi.get(self, "service_name")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ServiceLoadMetricDescriptionResponse(dict):
      """
      Specifies a metric to load balance a service during runtime.
      """
      def __init__(__self__, *,
                   name: str,
                   default_load: Optional[int] = None,
                   primary_default_load: Optional[int] = None,
                   secondary_default_load: Optional[int] = None,
                   weight: Optional[str] = None):
          """
          Specifies a metric to load balance a service during runtime.
          :param str name: The name of the metric. If the service chooses to report load during runtime, the load metric name should match the name that is specified in Name exactly. Note that metric names are case sensitive.
          :param int default_load: Used only for Stateless services. The default amount of load, as a number, that this service creates for this metric.
          :param int primary_default_load: Used only for Stateful services. The default amount of load, as a number, that this service creates for this metric when it is a Primary replica.
          :param int secondary_default_load: Used only for Stateful services. The default amount of load, as a number, that this service creates for this metric when it is a Secondary replica.
          :param str weight: The service load metric relative weight, compared to other metrics configured for this service, as a number.
          """
          pulumi.set(__self__, "name", name)
          if default_load is not None:
              pulumi.set(__self__, "default_load", default_load)
          if primary_default_load is not None:
              pulumi.set(__self__, "primary_default_load", primary_default_load)
          if secondary_default_load is not None:
              pulumi.set(__self__, "secondary_default_load", secondary_default_load)
          if weight is not None:
              pulumi.set(__self__, "weight", weight)
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          The name of the metric. If the service chooses to report load during runtime, the load metric name should match the name that is specified in Name exactly. Note that metric names are case sensitive.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter(name="defaultLoad")
      def default_load(self) -> Optional[int]:
          """
          Used only for Stateless services. The default amount of load, as a number, that this service creates for this metric.
          """
          return pulumi.get(self, "default_load")
  
      @property
      @pulumi.getter(name="primaryDefaultLoad")
      def primary_default_load(self) -> Optional[int]:
          """
          Used only for Stateful services. The default amount of load, as a number, that this service creates for this metric when it is a Primary replica.
          """
          return pulumi.get(self, "primary_default_load")
  
      @property
      @pulumi.getter(name="secondaryDefaultLoad")
      def secondary_default_load(self) -> Optional[int]:
          """
          Used only for Stateful services. The default amount of load, as a number, that this service creates for this metric when it is a Secondary replica.
          """
          return pulumi.get(self, "secondary_default_load")
  
      @property
      @pulumi.getter
      def weight(self) -> Optional[str]:
          """
          The service load metric relative weight, compared to other metrics configured for this service, as a number.
          """
          return pulumi.get(self, "weight")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ServicePlacementPolicyDescriptionResponse(dict):
      """
      Describes the policy to be used for placement of a Service Fabric service.
      """
      def __init__(__self__, *,
                   type: str):
          """
          Describes the policy to be used for placement of a Service Fabric service.
          :param str type: The type of placement policy for a service fabric service. Following are the possible values.
          """
          pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter
      def type(self) -> str:
          """
          The type of placement policy for a service fabric service. Following are the possible values.
          """
          return pulumi.get(self, "type")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ServiceTypeDeltaHealthPolicyResponse(dict):
      """
      Represents the delta health policy used to evaluate the health of services belonging to a service type when upgrading the cluster.
      """
      def __init__(__self__, *,
                   max_percent_delta_unhealthy_services: Optional[int] = None):
          """
          Represents the delta health policy used to evaluate the health of services belonging to a service type when upgrading the cluster.
  
          :param int max_percent_delta_unhealthy_services: The maximum allowed percentage of services health degradation allowed during cluster upgrades.
                 The delta is measured between the state of the services at the beginning of upgrade and the state of the services at the time of the health evaluation.
                 The check is performed after every upgrade domain upgrade completion to make sure the global state of the cluster is within tolerated limits.
          """
          if max_percent_delta_unhealthy_services is not None:
              pulumi.set(__self__, "max_percent_delta_unhealthy_services", max_percent_delta_unhealthy_services)
  
      @property
      @pulumi.getter(name="maxPercentDeltaUnhealthyServices")
      def max_percent_delta_unhealthy_services(self) -> Optional[int]:
          """
          The maximum allowed percentage of services health degradation allowed during cluster upgrades.
          The delta is measured between the state of the services at the beginning of upgrade and the state of the services at the time of the health evaluation.
          The check is performed after every upgrade domain upgrade completion to make sure the global state of the cluster is within tolerated limits.
          """
          return pulumi.get(self, "max_percent_delta_unhealthy_services")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class ServiceTypeHealthPolicyResponse(dict):
      """
      Represents the health policy used to evaluate the health of services belonging to a service type.
      """
      def __init__(__self__, *,
                   max_percent_unhealthy_services: Optional[int] = None):
          """
          Represents the health policy used to evaluate the health of services belonging to a service type.
  
          :param int max_percent_unhealthy_services: The maximum percentage of services allowed to be unhealthy before your application is considered in error.
          """
          if max_percent_unhealthy_services is not None:
              pulumi.set(__self__, "max_percent_unhealthy_services", max_percent_unhealthy_services)
  
      @property
      @pulumi.getter(name="maxPercentUnhealthyServices")
      def max_percent_unhealthy_services(self) -> Optional[int]:
          """
          The maximum percentage of services allowed to be unhealthy before your application is considered in error.
          """
          return pulumi.get(self, "max_percent_unhealthy_services")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class SettingsParameterDescriptionResponse(dict):
      """
      Describes a parameter in fabric settings of the cluster.
      """
      def __init__(__self__, *,
                   name: str,
                   value: str):
          """
          Describes a parameter in fabric settings of the cluster.
          :param str name: The parameter name of fabric setting.
          :param str value: The parameter value of fabric setting.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "value", value)
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          The parameter name of fabric setting.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter
      def value(self) -> str:
          """
          The parameter value of fabric setting.
          """
          return pulumi.get(self, "value")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class SettingsSectionDescriptionResponse(dict):
      """
      Describes a section in the fabric settings of the cluster.
      """
      def __init__(__self__, *,
                   name: str,
                   parameters: Sequence['outputs.SettingsParameterDescriptionResponse']):
          """
          Describes a section in the fabric settings of the cluster.
          :param str name: The section name of the fabric settings.
          :param Sequence['SettingsParameterDescriptionResponseArgs'] parameters: The collection of parameters in the section.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "parameters", parameters)
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          The section name of the fabric settings.
          """
          return pulumi.get(self, "name")
  
      @property
      @pulumi.getter
      def parameters(self) -> Sequence['outputs.SettingsParameterDescriptionResponse']:
          """
          The collection of parameters in the section.
          """
          return pulumi.get(self, "parameters")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class SingletonPartitionSchemeDescriptionResponse(dict):
      """
      Describes the partition scheme of a singleton-partitioned, or non-partitioned service.
      """
      def __init__(__self__, *,
                   partition_scheme: str):
          """
          Describes the partition scheme of a singleton-partitioned, or non-partitioned service.
          :param str partition_scheme: Specifies how the service is partitioned.
          """
          pulumi.set(__self__, "partition_scheme", 'Singleton')
  
      @property
      @pulumi.getter(name="partitionScheme")
      def partition_scheme(self) -> str:
          """
          Specifies how the service is partitioned.
          """
          return pulumi.get(self, "partition_scheme")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class UniformInt64RangePartitionSchemeDescriptionResponse(dict):
      """
      Describes a partitioning scheme where an integer range is allocated evenly across a number of partitions.
      """
      def __init__(__self__, *,
                   count: int,
                   high_key: str,
                   low_key: str,
                   partition_scheme: str):
          """
          Describes a partitioning scheme where an integer range is allocated evenly across a number of partitions.
          :param int count: The number of partitions.
          :param str high_key: String indicating the upper bound of the partition key range that
                 should be split between the partition ‘Count’
          :param str low_key: String indicating the lower bound of the partition key range that
                 should be split between the partition ‘Count’
          :param str partition_scheme: Specifies how the service is partitioned.
          """
          pulumi.set(__self__, "count", count)
          pulumi.set(__self__, "high_key", high_key)
          pulumi.set(__self__, "low_key", low_key)
          pulumi.set(__self__, "partition_scheme", 'UniformInt64Range')
  
      @property
      @pulumi.getter
      def count(self) -> int:
          """
          The number of partitions.
          """
          return pulumi.get(self, "count")
  
      @property
      @pulumi.getter(name="highKey")
      def high_key(self) -> str:
          """
          String indicating the upper bound of the partition key range that
          should be split between the partition ‘Count’
          """
          return pulumi.get(self, "high_key")
  
      @property
      @pulumi.getter(name="lowKey")
      def low_key(self) -> str:
          """
          String indicating the lower bound of the partition key range that
          should be split between the partition ‘Count’
          """
          return pulumi.get(self, "low_key")
  
      @property
      @pulumi.getter(name="partitionScheme")
      def partition_scheme(self) -> str:
          """
          Specifies how the service is partitioned.
          """
          return pulumi.get(self, "partition_scheme")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  @pulumi.output_type
  class UserAssignedIdentityResponse(dict):
      def __init__(__self__, *,
                   client_id: str,
                   principal_id: str):
          """
          :param str client_id: The client id of user assigned identity.
          :param str principal_id: The principal id of user assigned identity.
          """
          pulumi.set(__self__, "client_id", client_id)
          pulumi.set(__self__, "principal_id", principal_id)
  
      @property
      @pulumi.getter(name="clientId")
      def client_id(self) -> str:
          """
          The client id of user assigned identity.
          """
          return pulumi.get(self, "client_id")
  
      @property
      @pulumi.getter(name="principalId")
      def principal_id(self) -> str:
          """
          The principal id of user assigned identity.
          """
          return pulumi.get(self, "principal_id")
  
      def _translate_property(self, prop):
          return _tables.CAMEL_TO_SNAKE_CASE_TABLE.get(prop) or prop
  
  
  