text: # coding=utf-8
  # *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
  # *** Do not edit by hand unless you're certain you know what you are doing! ***
  
  import warnings
  import pulumi
  import pulumi.runtime
  from typing import Any, Mapping, Optional, Sequence, Union, overload
  from . import _utilities
  
  __all__ = [
      'AlbBackendGroupGrpcBackendArgs',
      'AlbBackendGroupGrpcBackendHealthcheckArgs',
      'AlbBackendGroupGrpcBackendHealthcheckGrpcHealthcheckArgs',
      'AlbBackendGroupGrpcBackendHealthcheckHttpHealthcheckArgs',
      'AlbBackendGroupGrpcBackendHealthcheckStreamHealthcheckArgs',
      'AlbBackendGroupGrpcBackendLoadBalancingConfigArgs',
      'AlbBackendGroupGrpcBackendTlsArgs',
      'AlbBackendGroupGrpcBackendTlsValidationContextArgs',
      'AlbBackendGroupHttpBackendArgs',
      'AlbBackendGroupHttpBackendHealthcheckArgs',
      'AlbBackendGroupHttpBackendHealthcheckGrpcHealthcheckArgs',
      'AlbBackendGroupHttpBackendHealthcheckHttpHealthcheckArgs',
      'AlbBackendGroupHttpBackendHealthcheckStreamHealthcheckArgs',
      'AlbBackendGroupHttpBackendLoadBalancingConfigArgs',
      'AlbBackendGroupHttpBackendTlsArgs',
      'AlbBackendGroupHttpBackendTlsValidationContextArgs',
      'AlbLoadBalancerAllocationPolicyArgs',
      'AlbLoadBalancerAllocationPolicyLocationArgs',
      'AlbLoadBalancerListenerArgs',
      'AlbLoadBalancerListenerEndpointArgs',
      'AlbLoadBalancerListenerEndpointAddressArgs',
      'AlbLoadBalancerListenerEndpointAddressExternalIpv4AddressArgs',
      'AlbLoadBalancerListenerEndpointAddressExternalIpv6AddressArgs',
      'AlbLoadBalancerListenerEndpointAddressInternalIpv4AddressArgs',
      'AlbLoadBalancerListenerHttpArgs',
      'AlbLoadBalancerListenerHttpHandlerArgs',
      'AlbLoadBalancerListenerHttpHandlerHttp2OptionsArgs',
      'AlbLoadBalancerListenerHttpRedirectsArgs',
      'AlbLoadBalancerListenerTlsArgs',
      'AlbLoadBalancerListenerTlsDefaultHandlerArgs',
      'AlbLoadBalancerListenerTlsDefaultHandlerHttpHandlerArgs',
      'AlbLoadBalancerListenerTlsDefaultHandlerHttpHandlerHttp2OptionsArgs',
      'AlbLoadBalancerListenerTlsSniHandlerArgs',
      'AlbLoadBalancerListenerTlsSniHandlerHandlerArgs',
      'AlbLoadBalancerListenerTlsSniHandlerHandlerHttpHandlerArgs',
      'AlbLoadBalancerListenerTlsSniHandlerHandlerHttpHandlerHttp2OptionsArgs',
      'AlbTargetGroupTargetArgs',
      'AlbVirtualHostModifyRequestHeaderArgs',
      'AlbVirtualHostModifyResponseHeaderArgs',
      'AlbVirtualHostRouteArgs',
      'AlbVirtualHostRouteGrpcRouteArgs',
      'AlbVirtualHostRouteGrpcRouteGrpcMatchArgs',
      'AlbVirtualHostRouteGrpcRouteGrpcMatchFqmnArgs',
      'AlbVirtualHostRouteGrpcRouteGrpcRouteActionArgs',
      'AlbVirtualHostRouteGrpcRouteGrpcStatusResponseActionArgs',
      'AlbVirtualHostRouteHttpRouteArgs',
      'AlbVirtualHostRouteHttpRouteDirectResponseActionArgs',
      'AlbVirtualHostRouteHttpRouteHttpMatchArgs',
      'AlbVirtualHostRouteHttpRouteHttpMatchPathArgs',
      'AlbVirtualHostRouteHttpRouteHttpRouteActionArgs',
      'AlbVirtualHostRouteHttpRouteRedirectActionArgs',
      'ComputeDiskDiskPlacementPolicyArgs',
      'ComputeInstanceBootDiskArgs',
      'ComputeInstanceBootDiskInitializeParamsArgs',
      'ComputeInstanceGroupAllocationPolicyArgs',
      'ComputeInstanceGroupApplicationLoadBalancerArgs',
      'ComputeInstanceGroupDeployPolicyArgs',
      'ComputeInstanceGroupHealthCheckArgs',
      'ComputeInstanceGroupHealthCheckHttpOptionArgs',
      'ComputeInstanceGroupHealthCheckTcpOptionArgs',
      'ComputeInstanceGroupInstanceArgs',
      'ComputeInstanceGroupInstanceNetworkInterfaceArgs',
      'ComputeInstanceGroupInstanceTemplateArgs',
      'ComputeInstanceGroupInstanceTemplateBootDiskArgs',
      'ComputeInstanceGroupInstanceTemplateBootDiskInitializeParamsArgs',
      'ComputeInstanceGroupInstanceTemplateNetworkInterfaceArgs',
      'ComputeInstanceGroupInstanceTemplateNetworkInterfaceDnsRecordArgs',
      'ComputeInstanceGroupInstanceTemplateNetworkInterfaceIpv6DnsRecordArgs',
      'ComputeInstanceGroupInstanceTemplateNetworkInterfaceNatDnsRecordArgs',
      'ComputeInstanceGroupInstanceTemplateNetworkSettingArgs',
      'ComputeInstanceGroupInstanceTemplatePlacementPolicyArgs',
      'ComputeInstanceGroupInstanceTemplateResourcesArgs',
      'ComputeInstanceGroupInstanceTemplateSchedulingPolicyArgs',
      'ComputeInstanceGroupInstanceTemplateSecondaryDiskArgs',
      'ComputeInstanceGroupInstanceTemplateSecondaryDiskInitializeParamsArgs',
      'ComputeInstanceGroupLoadBalancerArgs',
      'ComputeInstanceGroupScalePolicyArgs',
      'ComputeInstanceGroupScalePolicyAutoScaleArgs',
      'ComputeInstanceGroupScalePolicyAutoScaleCustomRuleArgs',
      'ComputeInstanceGroupScalePolicyFixedScaleArgs',
      'ComputeInstanceGroupScalePolicyTestAutoScaleArgs',
      'ComputeInstanceGroupScalePolicyTestAutoScaleCustomRuleArgs',
      'ComputeInstanceNetworkInterfaceArgs',
      'ComputeInstanceNetworkInterfaceDnsRecordArgs',
      'ComputeInstanceNetworkInterfaceIpv6DnsRecordArgs',
      'ComputeInstanceNetworkInterfaceNatDnsRecordArgs',
      'ComputeInstancePlacementPolicyArgs',
      'ComputeInstanceResourcesArgs',
      'ComputeInstanceSchedulingPolicyArgs',
      'ComputeInstanceSecondaryDiskArgs',
      'DataprocClusterClusterConfigArgs',
      'DataprocClusterClusterConfigHadoopArgs',
      'DataprocClusterClusterConfigSubclusterSpecArgs',
      'DataprocClusterClusterConfigSubclusterSpecAutoscalingConfigArgs',
      'DataprocClusterClusterConfigSubclusterSpecResourcesArgs',
      'FunctionContentArgs',
      'FunctionPackageArgs',
      'FunctionScalingPolicyPolicyArgs',
      'FunctionTriggerDlqArgs',
      'FunctionTriggerFunctionArgs',
      'FunctionTriggerIotArgs',
      'FunctionTriggerLogGroupArgs',
      'FunctionTriggerLoggingArgs',
      'FunctionTriggerMessageQueueArgs',
      'FunctionTriggerObjectStorageArgs',
      'FunctionTriggerTimerArgs',
      'KubernetesClusterKmsProviderArgs',
      'KubernetesClusterMasterArgs',
      'KubernetesClusterMasterMaintenancePolicyArgs',
      'KubernetesClusterMasterMaintenancePolicyMaintenanceWindowArgs',
      'KubernetesClusterMasterRegionalArgs',
      'KubernetesClusterMasterRegionalLocationArgs',
      'KubernetesClusterMasterVersionInfoArgs',
      'KubernetesClusterMasterZonalArgs',
      'KubernetesClusterNetworkImplementationArgs',
      'KubernetesClusterNetworkImplementationCiliumArgs',
      'KubernetesNodeGroupAllocationPolicyArgs',
      'KubernetesNodeGroupAllocationPolicyLocationArgs',
      'KubernetesNodeGroupDeployPolicyArgs',
      'KubernetesNodeGroupInstanceTemplateArgs',
      'KubernetesNodeGroupInstanceTemplateBootDiskArgs',
      'KubernetesNodeGroupInstanceTemplateNetworkInterfaceArgs',
      'KubernetesNodeGroupInstanceTemplatePlacementPolicyArgs',
      'KubernetesNodeGroupInstanceTemplateResourcesArgs',
      'KubernetesNodeGroupInstanceTemplateSchedulingPolicyArgs',
      'KubernetesNodeGroupMaintenancePolicyArgs',
      'KubernetesNodeGroupMaintenancePolicyMaintenanceWindowArgs',
      'KubernetesNodeGroupScalePolicyArgs',
      'KubernetesNodeGroupScalePolicyAutoScaleArgs',
      'KubernetesNodeGroupScalePolicyFixedScaleArgs',
      'KubernetesNodeGroupVersionInfoArgs',
      'LbNetworkLoadBalancerAttachedTargetGroupArgs',
      'LbNetworkLoadBalancerAttachedTargetGroupHealthcheckArgs',
      'LbNetworkLoadBalancerAttachedTargetGroupHealthcheckHttpOptionsArgs',
      'LbNetworkLoadBalancerAttachedTargetGroupHealthcheckTcpOptionsArgs',
      'LbNetworkLoadBalancerListenerArgs',
      'LbNetworkLoadBalancerListenerExternalAddressSpecArgs',
      'LbNetworkLoadBalancerListenerInternalAddressSpecArgs',
      'LbTargetGroupTargetArgs',
      'MdbClickhouseClusterAccessArgs',
      'MdbClickhouseClusterBackupWindowStartArgs',
      'MdbClickhouseClusterClickhouseArgs',
      'MdbClickhouseClusterClickhouseConfigArgs',
      'MdbClickhouseClusterClickhouseConfigCompressionArgs',
      'MdbClickhouseClusterClickhouseConfigGraphiteRollupArgs',
      'MdbClickhouseClusterClickhouseConfigGraphiteRollupPatternArgs',
      'MdbClickhouseClusterClickhouseConfigGraphiteRollupPatternRetentionArgs',
      'MdbClickhouseClusterClickhouseConfigKafkaArgs',
      'MdbClickhouseClusterClickhouseConfigKafkaTopicArgs',
      'MdbClickhouseClusterClickhouseConfigKafkaTopicSettingsArgs',
      'MdbClickhouseClusterClickhouseConfigMergeTreeArgs',
      'MdbClickhouseClusterClickhouseConfigRabbitmqArgs',
      'MdbClickhouseClusterClickhouseResourcesArgs',
      'MdbClickhouseClusterCloudStorageArgs',
      'MdbClickhouseClusterDatabaseArgs',
      'MdbClickhouseClusterFormatSchemaArgs',
      'MdbClickhouseClusterHostArgs',
      'MdbClickhouseClusterMaintenanceWindowArgs',
      'MdbClickhouseClusterMlModelArgs',
      'MdbClickhouseClusterShardGroupArgs',
      'MdbClickhouseClusterUserArgs',
      'MdbClickhouseClusterUserPermissionArgs',
      'MdbClickhouseClusterUserQuotaArgs',
      'MdbClickhouseClusterUserSettingsArgs',
      'MdbClickhouseClusterZookeeperArgs',
      'MdbClickhouseClusterZookeeperResourcesArgs',
      'MdbElasticSearchClusterConfigArgs',
      'MdbElasticSearchClusterConfigDataNodeArgs',
      'MdbElasticSearchClusterConfigDataNodeResourcesArgs',
      'MdbElasticSearchClusterConfigMasterNodeArgs',
      'MdbElasticSearchClusterConfigMasterNodeResourcesArgs',
      'MdbElasticSearchClusterHostArgs',
      'MdbGreenplumClusterAccessArgs',
      'MdbGreenplumClusterBackupWindowStartArgs',
      'MdbGreenplumClusterMasterHostArgs',
      'MdbGreenplumClusterMasterSubclusterArgs',
      'MdbGreenplumClusterMasterSubclusterResourcesArgs',
      'MdbGreenplumClusterSegmentHostArgs',
      'MdbGreenplumClusterSegmentSubclusterArgs',
      'MdbGreenplumClusterSegmentSubclusterResourcesArgs',
      'MdbKafkaClusterConfigArgs',
      'MdbKafkaClusterConfigKafkaArgs',
      'MdbKafkaClusterConfigKafkaKafkaConfigArgs',
      'MdbKafkaClusterConfigKafkaResourcesArgs',
      'MdbKafkaClusterConfigZookeeperArgs',
      'MdbKafkaClusterConfigZookeeperResourcesArgs',
      'MdbKafkaClusterHostArgs',
      'MdbKafkaClusterTopicArgs',
      'MdbKafkaClusterTopicTopicConfigArgs',
      'MdbKafkaClusterUserArgs',
      'MdbKafkaClusterUserPermissionArgs',
      'MdbKafkaTopicTopicConfigArgs',
      'MdbMongodbClusterClusterConfigArgs',
      'MdbMongodbClusterClusterConfigAccessArgs',
      'MdbMongodbClusterClusterConfigBackupWindowStartArgs',
      'MdbMongodbClusterDatabaseArgs',
      'MdbMongodbClusterHostArgs',
      'MdbMongodbClusterMaintenanceWindowArgs',
      'MdbMongodbClusterResourcesArgs',
      'MdbMongodbClusterUserArgs',
      'MdbMongodbClusterUserPermissionArgs',
      'MdbMysqlClusterAccessArgs',
      'MdbMysqlClusterBackupWindowStartArgs',
      'MdbMysqlClusterDatabaseArgs',
      'MdbMysqlClusterHostArgs',
      'MdbMysqlClusterMaintenanceWindowArgs',
      'MdbMysqlClusterResourcesArgs',
      'MdbMysqlClusterRestoreArgs',
      'MdbMysqlClusterUserArgs',
      'MdbMysqlClusterUserConnectionLimitsArgs',
      'MdbMysqlClusterUserPermissionArgs',
      'MdbRedisClusterConfigArgs',
      'MdbRedisClusterHostArgs',
      'MdbRedisClusterMaintenanceWindowArgs',
      'MdbRedisClusterResourcesArgs',
      'MdbSqlServerClusterBackupWindowStartArgs',
      'MdbSqlServerClusterDatabaseArgs',
      'MdbSqlServerClusterHostArgs',
      'MdbSqlServerClusterResourcesArgs',
      'MdbSqlServerClusterUserArgs',
      'MdbSqlServerClusterUserPermissionArgs',
      'StorageBucketCorsRuleArgs',
      'StorageBucketGrantArgs',
      'StorageBucketLifecycleRuleArgs',
      'StorageBucketLifecycleRuleExpirationArgs',
      'StorageBucketLifecycleRuleNoncurrentVersionExpirationArgs',
      'StorageBucketLifecycleRuleNoncurrentVersionTransitionArgs',
      'StorageBucketLifecycleRuleTransitionArgs',
      'StorageBucketLoggingArgs',
      'StorageBucketServerSideEncryptionConfigurationArgs',
      'StorageBucketServerSideEncryptionConfigurationRuleArgs',
      'StorageBucketServerSideEncryptionConfigurationRuleApplyServerSideEncryptionByDefaultArgs',
      'StorageBucketVersioningArgs',
      'StorageBucketWebsiteArgs',
      'VpcAddressExternalIpv4AddressArgs',
      'VpcDefaultSecurityGroupEgressArgs',
      'VpcDefaultSecurityGroupIngressArgs',
      'VpcRouteTableStaticRouteArgs',
      'VpcSecurityGroupEgressArgs',
      'VpcSecurityGroupIngressArgs',
      'VpcSubnetDhcpOptionsArgs',
      'YdbDatabaseDedicatedLocationArgs',
      'YdbDatabaseDedicatedLocationRegionArgs',
      'YdbDatabaseDedicatedScalePolicyArgs',
      'YdbDatabaseDedicatedScalePolicyFixedScaleArgs',
      'YdbDatabaseDedicatedStorageConfigArgs',
      'GetAlbBackendGroupGrpcBackendArgs',
      'GetAlbBackendGroupGrpcBackendHealthcheckArgs',
      'GetAlbBackendGroupGrpcBackendHealthcheckGrpcHealthcheckArgs',
      'GetAlbBackendGroupGrpcBackendHealthcheckHttpHealthcheckArgs',
      'GetAlbBackendGroupGrpcBackendHealthcheckStreamHealthcheckArgs',
      'GetAlbBackendGroupGrpcBackendLoadBalancingConfigArgs',
      'GetAlbBackendGroupGrpcBackendTlsArgs',
      'GetAlbBackendGroupGrpcBackendTlsValidationContextArgs',
      'GetAlbBackendGroupHttpBackendArgs',
      'GetAlbBackendGroupHttpBackendHealthcheckArgs',
      'GetAlbBackendGroupHttpBackendHealthcheckGrpcHealthcheckArgs',
      'GetAlbBackendGroupHttpBackendHealthcheckHttpHealthcheckArgs',
      'GetAlbBackendGroupHttpBackendHealthcheckStreamHealthcheckArgs',
      'GetAlbBackendGroupHttpBackendLoadBalancingConfigArgs',
      'GetAlbBackendGroupHttpBackendTlsArgs',
      'GetAlbBackendGroupHttpBackendTlsValidationContextArgs',
      'GetComputeDiskDiskPlacementPolicyArgs',
      'GetComputeInstancePlacementPolicyArgs',
      'GetComputeInstanceSchedulingPolicyArgs',
      'GetFunctionScalingPolicyPolicyArgs',
      'GetIamPolicyBindingArgs',
      'GetMdbClickhouseClusterCloudStorageArgs',
      'GetMdbKafkaClusterConfigArgs',
      'GetMdbKafkaClusterConfigKafkaArgs',
      'GetMdbKafkaClusterConfigKafkaKafkaConfigArgs',
      'GetMdbKafkaClusterConfigKafkaResourcesArgs',
      'GetMdbKafkaClusterConfigZookeeperArgs',
      'GetMdbKafkaClusterConfigZookeeperResourcesArgs',
      'GetMdbKafkaClusterTopicArgs',
      'GetMdbKafkaClusterTopicTopicConfigArgs',
      'GetMdbKafkaClusterUserArgs',
      'GetMdbKafkaClusterUserPermissionArgs',
      'GetMdbMysqlClusterAccessArgs',
  ]
  
  @pulumi.input_type
  class AlbBackendGroupGrpcBackendArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   target_group_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
                   healthcheck: Optional[pulumi.Input['AlbBackendGroupGrpcBackendHealthcheckArgs']] = None,
                   load_balancing_config: Optional[pulumi.Input['AlbBackendGroupGrpcBackendLoadBalancingConfigArgs']] = None,
                   port: Optional[pulumi.Input[int]] = None,
                   tls: Optional[pulumi.Input['AlbBackendGroupGrpcBackendTlsArgs']] = None,
                   weight: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] name: Name of the backend.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] target_group_ids: References target groups for the backend.
          :param pulumi.Input['AlbBackendGroupGrpcBackendHealthcheckArgs'] healthcheck: Healthcheck specification that will be used by this backend. Structure is documented below.
          :param pulumi.Input['AlbBackendGroupGrpcBackendLoadBalancingConfigArgs'] load_balancing_config: Load Balancing Config specification that will be used by this backend. Structure is documented below.
          :param pulumi.Input[int] port: Port for incoming traffic.
          :param pulumi.Input['AlbBackendGroupGrpcBackendTlsArgs'] tls: Tls specification that will be used by this backend. Structure is documented below.
          :param pulumi.Input[int] weight: Weight of the backend. Traffic will be split between backends of the same BackendGroup according to their weights.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "target_group_ids", target_group_ids)
          if healthcheck is not None:
              pulumi.set(__self__, "healthcheck", healthcheck)
          if load_balancing_config is not None:
              pulumi.set(__self__, "load_balancing_config", load_balancing_config)
          if port is not None:
              pulumi.set(__self__, "port", port)
          if tls is not None:
              pulumi.set(__self__, "tls", tls)
          if weight is not None:
              pulumi.set(__self__, "weight", weight)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          Name of the backend.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="targetGroupIds")
      def target_group_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          """
          References target groups for the backend.
          """
          return pulumi.get(self, "target_group_ids")
  
      @target_group_ids.setter
      def target_group_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "target_group_ids", value)
  
      @property
      @pulumi.getter
      def healthcheck(self) -> Optional[pulumi.Input['AlbBackendGroupGrpcBackendHealthcheckArgs']]:
          """
          Healthcheck specification that will be used by this backend. Structure is documented below.
          """
          return pulumi.get(self, "healthcheck")
  
      @healthcheck.setter
      def healthcheck(self, value: Optional[pulumi.Input['AlbBackendGroupGrpcBackendHealthcheckArgs']]):
          pulumi.set(self, "healthcheck", value)
  
      @property
      @pulumi.getter(name="loadBalancingConfig")
      def load_balancing_config(self) -> Optional[pulumi.Input['AlbBackendGroupGrpcBackendLoadBalancingConfigArgs']]:
          """
          Load Balancing Config specification that will be used by this backend. Structure is documented below.
          """
          return pulumi.get(self, "load_balancing_config")
  
      @load_balancing_config.setter
      def load_balancing_config(self, value: Optional[pulumi.Input['AlbBackendGroupGrpcBackendLoadBalancingConfigArgs']]):
          pulumi.set(self, "load_balancing_config", value)
  
      @property
      @pulumi.getter
      def port(self) -> Optional[pulumi.Input[int]]:
          """
          Port for incoming traffic.
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "port", value)
  
      @property
      @pulumi.getter
      def tls(self) -> Optional[pulumi.Input['AlbBackendGroupGrpcBackendTlsArgs']]:
          """
          Tls specification that will be used by this backend. Structure is documented below.
          """
          return pulumi.get(self, "tls")
  
      @tls.setter
      def tls(self, value: Optional[pulumi.Input['AlbBackendGroupGrpcBackendTlsArgs']]):
          pulumi.set(self, "tls", value)
  
      @property
      @pulumi.getter
      def weight(self) -> Optional[pulumi.Input[int]]:
          """
          Weight of the backend. Traffic will be split between backends of the same BackendGroup according to their weights.
          """
          return pulumi.get(self, "weight")
  
      @weight.setter
      def weight(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "weight", value)
  
  
  @pulumi.input_type
  class AlbBackendGroupGrpcBackendHealthcheckArgs:
      def __init__(__self__, *,
                   interval: pulumi.Input[str],
                   timeout: pulumi.Input[str],
                   grpc_healthcheck: Optional[pulumi.Input['AlbBackendGroupGrpcBackendHealthcheckGrpcHealthcheckArgs']] = None,
                   healthcheck_port: Optional[pulumi.Input[int]] = None,
                   healthy_threshold: Optional[pulumi.Input[int]] = None,
                   http_healthcheck: Optional[pulumi.Input['AlbBackendGroupGrpcBackendHealthcheckHttpHealthcheckArgs']] = None,
                   interval_jitter_percent: Optional[pulumi.Input[float]] = None,
                   stream_healthcheck: Optional[pulumi.Input['AlbBackendGroupGrpcBackendHealthcheckStreamHealthcheckArgs']] = None,
                   unhealthy_threshold: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] interval: Interval between health checks.
          :param pulumi.Input[str] timeout: Time to wait for a health check response.
          :param pulumi.Input['AlbBackendGroupGrpcBackendHealthcheckGrpcHealthcheckArgs'] grpc_healthcheck: Grpc Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          :param pulumi.Input[int] healthcheck_port: Optional alternative port for health checking.
          :param pulumi.Input[int] healthy_threshold: Number of consecutive successful health checks required to promote endpoint into the healthy state. 0 means 1. Note that during startup, only a single successful health check is required to mark a host healthy.
          :param pulumi.Input['AlbBackendGroupGrpcBackendHealthcheckHttpHealthcheckArgs'] http_healthcheck: Http Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          :param pulumi.Input[float] interval_jitter_percent: An optional jitter amount as a percentage of interval. If specified, during every interval value of (interval_ms * interval_jitter_percent / 100) will be added to the wait time.
          :param pulumi.Input['AlbBackendGroupGrpcBackendHealthcheckStreamHealthcheckArgs'] stream_healthcheck: Stream Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          :param pulumi.Input[int] unhealthy_threshold: Number of consecutive failed health checks required to demote endpoint into the unhealthy state. 0 means 1. Note that for HTTP health checks, a single 503 immediately makes endpoint unhealthy.
          """
          pulumi.set(__self__, "interval", interval)
          pulumi.set(__self__, "timeout", timeout)
          if grpc_healthcheck is not None:
              pulumi.set(__self__, "grpc_healthcheck", grpc_healthcheck)
          if healthcheck_port is not None:
              pulumi.set(__self__, "healthcheck_port", healthcheck_port)
          if healthy_threshold is not None:
              pulumi.set(__self__, "healthy_threshold", healthy_threshold)
          if http_healthcheck is not None:
              pulumi.set(__self__, "http_healthcheck", http_healthcheck)
          if interval_jitter_percent is not None:
              pulumi.set(__self__, "interval_jitter_percent", interval_jitter_percent)
          if stream_healthcheck is not None:
              pulumi.set(__self__, "stream_healthcheck", stream_healthcheck)
          if unhealthy_threshold is not None:
              pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
  
      @property
      @pulumi.getter
      def interval(self) -> pulumi.Input[str]:
          """
          Interval between health checks.
          """
          return pulumi.get(self, "interval")
  
      @interval.setter
      def interval(self, value: pulumi.Input[str]):
          pulumi.set(self, "interval", value)
  
      @property
      @pulumi.getter
      def timeout(self) -> pulumi.Input[str]:
          """
          Time to wait for a health check response.
          """
          return pulumi.get(self, "timeout")
  
      @timeout.setter
      def timeout(self, value: pulumi.Input[str]):
          pulumi.set(self, "timeout", value)
  
      @property
      @pulumi.getter(name="grpcHealthcheck")
      def grpc_healthcheck(self) -> Optional[pulumi.Input['AlbBackendGroupGrpcBackendHealthcheckGrpcHealthcheckArgs']]:
          """
          Grpc Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          """
          return pulumi.get(self, "grpc_healthcheck")
  
      @grpc_healthcheck.setter
      def grpc_healthcheck(self, value: Optional[pulumi.Input['AlbBackendGroupGrpcBackendHealthcheckGrpcHealthcheckArgs']]):
          pulumi.set(self, "grpc_healthcheck", value)
  
      @property
      @pulumi.getter(name="healthcheckPort")
      def healthcheck_port(self) -> Optional[pulumi.Input[int]]:
          """
          Optional alternative port for health checking.
          """
          return pulumi.get(self, "healthcheck_port")
  
      @healthcheck_port.setter
      def healthcheck_port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "healthcheck_port", value)
  
      @property
      @pulumi.getter(name="healthyThreshold")
      def healthy_threshold(self) -> Optional[pulumi.Input[int]]:
          """
          Number of consecutive successful health checks required to promote endpoint into the healthy state. 0 means 1. Note that during startup, only a single successful health check is required to mark a host healthy.
          """
          return pulumi.get(self, "healthy_threshold")
  
      @healthy_threshold.setter
      def healthy_threshold(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "healthy_threshold", value)
  
      @property
      @pulumi.getter(name="httpHealthcheck")
      def http_healthcheck(self) -> Optional[pulumi.Input['AlbBackendGroupGrpcBackendHealthcheckHttpHealthcheckArgs']]:
          """
          Http Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          """
          return pulumi.get(self, "http_healthcheck")
  
      @http_healthcheck.setter
      def http_healthcheck(self, value: Optional[pulumi.Input['AlbBackendGroupGrpcBackendHealthcheckHttpHealthcheckArgs']]):
          pulumi.set(self, "http_healthcheck", value)
  
      @property
      @pulumi.getter(name="intervalJitterPercent")
      def interval_jitter_percent(self) -> Optional[pulumi.Input[float]]:
          """
          An optional jitter amount as a percentage of interval. If specified, during every interval value of (interval_ms * interval_jitter_percent / 100) will be added to the wait time.
          """
          return pulumi.get(self, "interval_jitter_percent")
  
      @interval_jitter_percent.setter
      def interval_jitter_percent(self, value: Optional[pulumi.Input[float]]):
          pulumi.set(self, "interval_jitter_percent", value)
  
      @property
      @pulumi.getter(name="streamHealthcheck")
      def stream_healthcheck(self) -> Optional[pulumi.Input['AlbBackendGroupGrpcBackendHealthcheckStreamHealthcheckArgs']]:
          """
          Stream Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          """
          return pulumi.get(self, "stream_healthcheck")
  
      @stream_healthcheck.setter
      def stream_healthcheck(self, value: Optional[pulumi.Input['AlbBackendGroupGrpcBackendHealthcheckStreamHealthcheckArgs']]):
          pulumi.set(self, "stream_healthcheck", value)
  
      @property
      @pulumi.getter(name="unhealthyThreshold")
      def unhealthy_threshold(self) -> Optional[pulumi.Input[int]]:
          """
          Number of consecutive failed health checks required to demote endpoint into the unhealthy state. 0 means 1. Note that for HTTP health checks, a single 503 immediately makes endpoint unhealthy.
          """
          return pulumi.get(self, "unhealthy_threshold")
  
      @unhealthy_threshold.setter
      def unhealthy_threshold(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "unhealthy_threshold", value)
  
  
  @pulumi.input_type
  class AlbBackendGroupGrpcBackendHealthcheckGrpcHealthcheckArgs:
      def __init__(__self__, *,
                   service_name: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] service_name: Service name for grpc.health.v1.HealthCheckRequest message.
          """
          if service_name is not None:
              pulumi.set(__self__, "service_name", service_name)
  
      @property
      @pulumi.getter(name="serviceName")
      def service_name(self) -> Optional[pulumi.Input[str]]:
          """
          Service name for grpc.health.v1.HealthCheckRequest message.
          """
          return pulumi.get(self, "service_name")
  
      @service_name.setter
      def service_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "service_name", value)
  
  
  @pulumi.input_type
  class AlbBackendGroupGrpcBackendHealthcheckHttpHealthcheckArgs:
      def __init__(__self__, *,
                   path: pulumi.Input[str],
                   host: Optional[pulumi.Input[str]] = None,
                   http2: Optional[pulumi.Input[bool]] = None):
          """
          :param pulumi.Input[str] path: HTTP path.
          :param pulumi.Input[str] host: "Host" HTTP header value.
          :param pulumi.Input[bool] http2: If set, health checks will use HTTP2.
          """
          pulumi.set(__self__, "path", path)
          if host is not None:
              pulumi.set(__self__, "host", host)
          if http2 is not None:
              pulumi.set(__self__, "http2", http2)
  
      @property
      @pulumi.getter
      def path(self) -> pulumi.Input[str]:
          """
          HTTP path.
          """
          return pulumi.get(self, "path")
  
      @path.setter
      def path(self, value: pulumi.Input[str]):
          pulumi.set(self, "path", value)
  
      @property
      @pulumi.getter
      def host(self) -> Optional[pulumi.Input[str]]:
          """
          "Host" HTTP header value.
          """
          return pulumi.get(self, "host")
  
      @host.setter
      def host(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "host", value)
  
      @property
      @pulumi.getter
      def http2(self) -> Optional[pulumi.Input[bool]]:
          """
          If set, health checks will use HTTP2.
          """
          return pulumi.get(self, "http2")
  
      @http2.setter
      def http2(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "http2", value)
  
  
  @pulumi.input_type
  class AlbBackendGroupGrpcBackendHealthcheckStreamHealthcheckArgs:
      def __init__(__self__, *,
                   receive: Optional[pulumi.Input[str]] = None,
                   send: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] receive: Text to search in reply.
          :param pulumi.Input[str] send: Message to send. If empty, it's a connect-only health check.
          """
          if receive is not None:
              pulumi.set(__self__, "receive", receive)
          if send is not None:
              pulumi.set(__self__, "send", send)
  
      @property
      @pulumi.getter
      def receive(self) -> Optional[pulumi.Input[str]]:
          """
          Text to search in reply.
          """
          return pulumi.get(self, "receive")
  
      @receive.setter
      def receive(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "receive", value)
  
      @property
      @pulumi.getter
      def send(self) -> Optional[pulumi.Input[str]]:
          """
          Message to send. If empty, it's a connect-only health check.
          """
          return pulumi.get(self, "send")
  
      @send.setter
      def send(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "send", value)
  
  
  @pulumi.input_type
  class AlbBackendGroupGrpcBackendLoadBalancingConfigArgs:
      def __init__(__self__, *,
                   locality_aware_routing_percent: Optional[pulumi.Input[int]] = None,
                   panic_threshold: Optional[pulumi.Input[int]] = None,
                   strict_locality: Optional[pulumi.Input[bool]] = None):
          """
          :param pulumi.Input[int] locality_aware_routing_percent: Percent of traffic to be sent to the same availability zone. The rest will be equally divided between other zones.
          :param pulumi.Input[int] panic_threshold: If percentage of healthy hosts in the backend is lower than panic_threshold, traffic will be routed to all backends no matter what the health status is. This helps to avoid healthy backends overloading  when everything is bad. Zero means no panic threshold.
          :param pulumi.Input[bool] strict_locality: If set, will route requests only to the same availability zone. Balancer won't know about endpoints in other zones.
          """
          if locality_aware_routing_percent is not None:
              pulumi.set(__self__, "locality_aware_routing_percent", locality_aware_routing_percent)
          if panic_threshold is not None:
              pulumi.set(__self__, "panic_threshold", panic_threshold)
          if strict_locality is not None:
              pulumi.set(__self__, "strict_locality", strict_locality)
  
      @property
      @pulumi.getter(name="localityAwareRoutingPercent")
      def locality_aware_routing_percent(self) -> Optional[pulumi.Input[int]]:
          """
          Percent of traffic to be sent to the same availability zone. The rest will be equally divided between other zones.
          """
          return pulumi.get(self, "locality_aware_routing_percent")
  
      @locality_aware_routing_percent.setter
      def locality_aware_routing_percent(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "locality_aware_routing_percent", value)
  
      @property
      @pulumi.getter(name="panicThreshold")
      def panic_threshold(self) -> Optional[pulumi.Input[int]]:
          """
          If percentage of healthy hosts in the backend is lower than panic_threshold, traffic will be routed to all backends no matter what the health status is. This helps to avoid healthy backends overloading  when everything is bad. Zero means no panic threshold.
          """
          return pulumi.get(self, "panic_threshold")
  
      @panic_threshold.setter
      def panic_threshold(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "panic_threshold", value)
  
      @property
      @pulumi.getter(name="strictLocality")
      def strict_locality(self) -> Optional[pulumi.Input[bool]]:
          """
          If set, will route requests only to the same availability zone. Balancer won't know about endpoints in other zones.
          """
          return pulumi.get(self, "strict_locality")
  
      @strict_locality.setter
      def strict_locality(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "strict_locality", value)
  
  
  @pulumi.input_type
  class AlbBackendGroupGrpcBackendTlsArgs:
      def __init__(__self__, *,
                   sni: Optional[pulumi.Input[str]] = None,
                   validation_context: Optional[pulumi.Input['AlbBackendGroupGrpcBackendTlsValidationContextArgs']] = None):
          """
          :param pulumi.Input[str] sni: [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication) string for TLS connections.
                 * `validation_context.0.trusted_ca_id` - (Optional) Trusted CA certificate ID in the Certificate Manager.
                 * `validation_context.0.trusted_ca_bytes` - (Optional) PEM-encoded trusted CA certificate chain.
          """
          if sni is not None:
              pulumi.set(__self__, "sni", sni)
          if validation_context is not None:
              pulumi.set(__self__, "validation_context", validation_context)
  
      @property
      @pulumi.getter
      def sni(self) -> Optional[pulumi.Input[str]]:
          """
          [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication) string for TLS connections.
          * `validation_context.0.trusted_ca_id` - (Optional) Trusted CA certificate ID in the Certificate Manager.
          * `validation_context.0.trusted_ca_bytes` - (Optional) PEM-encoded trusted CA certificate chain.
          """
          return pulumi.get(self, "sni")
  
      @sni.setter
      def sni(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "sni", value)
  
      @property
      @pulumi.getter(name="validationContext")
      def validation_context(self) -> Optional[pulumi.Input['AlbBackendGroupGrpcBackendTlsValidationContextArgs']]:
          return pulumi.get(self, "validation_context")
  
      @validation_context.setter
      def validation_context(self, value: Optional[pulumi.Input['AlbBackendGroupGrpcBackendTlsValidationContextArgs']]):
          pulumi.set(self, "validation_context", value)
  
  
  @pulumi.input_type
  class AlbBackendGroupGrpcBackendTlsValidationContextArgs:
      def __init__(__self__, *,
                   trusted_ca_bytes: Optional[pulumi.Input[str]] = None,
                   trusted_ca_id: Optional[pulumi.Input[str]] = None):
          if trusted_ca_bytes is not None:
              pulumi.set(__self__, "trusted_ca_bytes", trusted_ca_bytes)
          if trusted_ca_id is not None:
              pulumi.set(__self__, "trusted_ca_id", trusted_ca_id)
  
      @property
      @pulumi.getter(name="trustedCaBytes")
      def trusted_ca_bytes(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "trusted_ca_bytes")
  
      @trusted_ca_bytes.setter
      def trusted_ca_bytes(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "trusted_ca_bytes", value)
  
      @property
      @pulumi.getter(name="trustedCaId")
      def trusted_ca_id(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "trusted_ca_id")
  
      @trusted_ca_id.setter
      def trusted_ca_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "trusted_ca_id", value)
  
  
  @pulumi.input_type
  class AlbBackendGroupHttpBackendArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   target_group_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
                   healthcheck: Optional[pulumi.Input['AlbBackendGroupHttpBackendHealthcheckArgs']] = None,
                   http2: Optional[pulumi.Input[bool]] = None,
                   load_balancing_config: Optional[pulumi.Input['AlbBackendGroupHttpBackendLoadBalancingConfigArgs']] = None,
                   port: Optional[pulumi.Input[int]] = None,
                   tls: Optional[pulumi.Input['AlbBackendGroupHttpBackendTlsArgs']] = None,
                   weight: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] name: Name of the backend.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] target_group_ids: References target groups for the backend.
          :param pulumi.Input['AlbBackendGroupHttpBackendHealthcheckArgs'] healthcheck: Healthcheck specification that will be used by this backend. Structure is documented below.
          :param pulumi.Input[bool] http2: If set, health checks will use HTTP2.
          :param pulumi.Input['AlbBackendGroupHttpBackendLoadBalancingConfigArgs'] load_balancing_config: Load Balancing Config specification that will be used by this backend. Structure is documented below.
          :param pulumi.Input[int] port: Port for incoming traffic.
          :param pulumi.Input['AlbBackendGroupHttpBackendTlsArgs'] tls: Tls specification that will be used by this backend. Structure is documented below.
          :param pulumi.Input[int] weight: Weight of the backend. Traffic will be split between backends of the same BackendGroup according to their weights.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "target_group_ids", target_group_ids)
          if healthcheck is not None:
              pulumi.set(__self__, "healthcheck", healthcheck)
          if http2 is not None:
              pulumi.set(__self__, "http2", http2)
          if load_balancing_config is not None:
              pulumi.set(__self__, "load_balancing_config", load_balancing_config)
          if port is not None:
              pulumi.set(__self__, "port", port)
          if tls is not None:
              pulumi.set(__self__, "tls", tls)
          if weight is not None:
              pulumi.set(__self__, "weight", weight)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          Name of the backend.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="targetGroupIds")
      def target_group_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          """
          References target groups for the backend.
          """
          return pulumi.get(self, "target_group_ids")
  
      @target_group_ids.setter
      def target_group_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "target_group_ids", value)
  
      @property
      @pulumi.getter
      def healthcheck(self) -> Optional[pulumi.Input['AlbBackendGroupHttpBackendHealthcheckArgs']]:
          """
          Healthcheck specification that will be used by this backend. Structure is documented below.
          """
          return pulumi.get(self, "healthcheck")
  
      @healthcheck.setter
      def healthcheck(self, value: Optional[pulumi.Input['AlbBackendGroupHttpBackendHealthcheckArgs']]):
          pulumi.set(self, "healthcheck", value)
  
      @property
      @pulumi.getter
      def http2(self) -> Optional[pulumi.Input[bool]]:
          """
          If set, health checks will use HTTP2.
          """
          return pulumi.get(self, "http2")
  
      @http2.setter
      def http2(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "http2", value)
  
      @property
      @pulumi.getter(name="loadBalancingConfig")
      def load_balancing_config(self) -> Optional[pulumi.Input['AlbBackendGroupHttpBackendLoadBalancingConfigArgs']]:
          """
          Load Balancing Config specification that will be used by this backend. Structure is documented below.
          """
          return pulumi.get(self, "load_balancing_config")
  
      @load_balancing_config.setter
      def load_balancing_config(self, value: Optional[pulumi.Input['AlbBackendGroupHttpBackendLoadBalancingConfigArgs']]):
          pulumi.set(self, "load_balancing_config", value)
  
      @property
      @pulumi.getter
      def port(self) -> Optional[pulumi.Input[int]]:
          """
          Port for incoming traffic.
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "port", value)
  
      @property
      @pulumi.getter
      def tls(self) -> Optional[pulumi.Input['AlbBackendGroupHttpBackendTlsArgs']]:
          """
          Tls specification that will be used by this backend. Structure is documented below.
          """
          return pulumi.get(self, "tls")
  
      @tls.setter
      def tls(self, value: Optional[pulumi.Input['AlbBackendGroupHttpBackendTlsArgs']]):
          pulumi.set(self, "tls", value)
  
      @property
      @pulumi.getter
      def weight(self) -> Optional[pulumi.Input[int]]:
          """
          Weight of the backend. Traffic will be split between backends of the same BackendGroup according to their weights.
          """
          return pulumi.get(self, "weight")
  
      @weight.setter
      def weight(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "weight", value)
  
  
  @pulumi.input_type
  class AlbBackendGroupHttpBackendHealthcheckArgs:
      def __init__(__self__, *,
                   interval: pulumi.Input[str],
                   timeout: pulumi.Input[str],
                   grpc_healthcheck: Optional[pulumi.Input['AlbBackendGroupHttpBackendHealthcheckGrpcHealthcheckArgs']] = None,
                   healthcheck_port: Optional[pulumi.Input[int]] = None,
                   healthy_threshold: Optional[pulumi.Input[int]] = None,
                   http_healthcheck: Optional[pulumi.Input['AlbBackendGroupHttpBackendHealthcheckHttpHealthcheckArgs']] = None,
                   interval_jitter_percent: Optional[pulumi.Input[float]] = None,
                   stream_healthcheck: Optional[pulumi.Input['AlbBackendGroupHttpBackendHealthcheckStreamHealthcheckArgs']] = None,
                   unhealthy_threshold: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] interval: Interval between health checks.
          :param pulumi.Input[str] timeout: Time to wait for a health check response.
          :param pulumi.Input['AlbBackendGroupHttpBackendHealthcheckGrpcHealthcheckArgs'] grpc_healthcheck: Grpc Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          :param pulumi.Input[int] healthcheck_port: Optional alternative port for health checking.
          :param pulumi.Input[int] healthy_threshold: Number of consecutive successful health checks required to promote endpoint into the healthy state. 0 means 1. Note that during startup, only a single successful health check is required to mark a host healthy.
          :param pulumi.Input['AlbBackendGroupHttpBackendHealthcheckHttpHealthcheckArgs'] http_healthcheck: Http Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          :param pulumi.Input[float] interval_jitter_percent: An optional jitter amount as a percentage of interval. If specified, during every interval value of (interval_ms * interval_jitter_percent / 100) will be added to the wait time.
          :param pulumi.Input['AlbBackendGroupHttpBackendHealthcheckStreamHealthcheckArgs'] stream_healthcheck: Stream Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          :param pulumi.Input[int] unhealthy_threshold: Number of consecutive failed health checks required to demote endpoint into the unhealthy state. 0 means 1. Note that for HTTP health checks, a single 503 immediately makes endpoint unhealthy.
          """
          pulumi.set(__self__, "interval", interval)
          pulumi.set(__self__, "timeout", timeout)
          if grpc_healthcheck is not None:
              pulumi.set(__self__, "grpc_healthcheck", grpc_healthcheck)
          if healthcheck_port is not None:
              pulumi.set(__self__, "healthcheck_port", healthcheck_port)
          if healthy_threshold is not None:
              pulumi.set(__self__, "healthy_threshold", healthy_threshold)
          if http_healthcheck is not None:
              pulumi.set(__self__, "http_healthcheck", http_healthcheck)
          if interval_jitter_percent is not None:
              pulumi.set(__self__, "interval_jitter_percent", interval_jitter_percent)
          if stream_healthcheck is not None:
              pulumi.set(__self__, "stream_healthcheck", stream_healthcheck)
          if unhealthy_threshold is not None:
              pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
  
      @property
      @pulumi.getter
      def interval(self) -> pulumi.Input[str]:
          """
          Interval between health checks.
          """
          return pulumi.get(self, "interval")
  
      @interval.setter
      def interval(self, value: pulumi.Input[str]):
          pulumi.set(self, "interval", value)
  
      @property
      @pulumi.getter
      def timeout(self) -> pulumi.Input[str]:
          """
          Time to wait for a health check response.
          """
          return pulumi.get(self, "timeout")
  
      @timeout.setter
      def timeout(self, value: pulumi.Input[str]):
          pulumi.set(self, "timeout", value)
  
      @property
      @pulumi.getter(name="grpcHealthcheck")
      def grpc_healthcheck(self) -> Optional[pulumi.Input['AlbBackendGroupHttpBackendHealthcheckGrpcHealthcheckArgs']]:
          """
          Grpc Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          """
          return pulumi.get(self, "grpc_healthcheck")
  
      @grpc_healthcheck.setter
      def grpc_healthcheck(self, value: Optional[pulumi.Input['AlbBackendGroupHttpBackendHealthcheckGrpcHealthcheckArgs']]):
          pulumi.set(self, "grpc_healthcheck", value)
  
      @property
      @pulumi.getter(name="healthcheckPort")
      def healthcheck_port(self) -> Optional[pulumi.Input[int]]:
          """
          Optional alternative port for health checking.
          """
          return pulumi.get(self, "healthcheck_port")
  
      @healthcheck_port.setter
      def healthcheck_port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "healthcheck_port", value)
  
      @property
      @pulumi.getter(name="healthyThreshold")
      def healthy_threshold(self) -> Optional[pulumi.Input[int]]:
          """
          Number of consecutive successful health checks required to promote endpoint into the healthy state. 0 means 1. Note that during startup, only a single successful health check is required to mark a host healthy.
          """
          return pulumi.get(self, "healthy_threshold")
  
      @healthy_threshold.setter
      def healthy_threshold(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "healthy_threshold", value)
  
      @property
      @pulumi.getter(name="httpHealthcheck")
      def http_healthcheck(self) -> Optional[pulumi.Input['AlbBackendGroupHttpBackendHealthcheckHttpHealthcheckArgs']]:
          """
          Http Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          """
          return pulumi.get(self, "http_healthcheck")
  
      @http_healthcheck.setter
      def http_healthcheck(self, value: Optional[pulumi.Input['AlbBackendGroupHttpBackendHealthcheckHttpHealthcheckArgs']]):
          pulumi.set(self, "http_healthcheck", value)
  
      @property
      @pulumi.getter(name="intervalJitterPercent")
      def interval_jitter_percent(self) -> Optional[pulumi.Input[float]]:
          """
          An optional jitter amount as a percentage of interval. If specified, during every interval value of (interval_ms * interval_jitter_percent / 100) will be added to the wait time.
          """
          return pulumi.get(self, "interval_jitter_percent")
  
      @interval_jitter_percent.setter
      def interval_jitter_percent(self, value: Optional[pulumi.Input[float]]):
          pulumi.set(self, "interval_jitter_percent", value)
  
      @property
      @pulumi.getter(name="streamHealthcheck")
      def stream_healthcheck(self) -> Optional[pulumi.Input['AlbBackendGroupHttpBackendHealthcheckStreamHealthcheckArgs']]:
          """
          Stream Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          """
          return pulumi.get(self, "stream_healthcheck")
  
      @stream_healthcheck.setter
      def stream_healthcheck(self, value: Optional[pulumi.Input['AlbBackendGroupHttpBackendHealthcheckStreamHealthcheckArgs']]):
          pulumi.set(self, "stream_healthcheck", value)
  
      @property
      @pulumi.getter(name="unhealthyThreshold")
      def unhealthy_threshold(self) -> Optional[pulumi.Input[int]]:
          """
          Number of consecutive failed health checks required to demote endpoint into the unhealthy state. 0 means 1. Note that for HTTP health checks, a single 503 immediately makes endpoint unhealthy.
          """
          return pulumi.get(self, "unhealthy_threshold")
  
      @unhealthy_threshold.setter
      def unhealthy_threshold(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "unhealthy_threshold", value)
  
  
  @pulumi.input_type
  class AlbBackendGroupHttpBackendHealthcheckGrpcHealthcheckArgs:
      def __init__(__self__, *,
                   service_name: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] service_name: Service name for grpc.health.v1.HealthCheckRequest message.
          """
          if service_name is not None:
              pulumi.set(__self__, "service_name", service_name)
  
      @property
      @pulumi.getter(name="serviceName")
      def service_name(self) -> Optional[pulumi.Input[str]]:
          """
          Service name for grpc.health.v1.HealthCheckRequest message.
          """
          return pulumi.get(self, "service_name")
  
      @service_name.setter
      def service_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "service_name", value)
  
  
  @pulumi.input_type
  class AlbBackendGroupHttpBackendHealthcheckHttpHealthcheckArgs:
      def __init__(__self__, *,
                   path: pulumi.Input[str],
                   host: Optional[pulumi.Input[str]] = None,
                   http2: Optional[pulumi.Input[bool]] = None):
          """
          :param pulumi.Input[str] path: HTTP path.
          :param pulumi.Input[str] host: "Host" HTTP header value.
          :param pulumi.Input[bool] http2: If set, health checks will use HTTP2.
          """
          pulumi.set(__self__, "path", path)
          if host is not None:
              pulumi.set(__self__, "host", host)
          if http2 is not None:
              pulumi.set(__self__, "http2", http2)
  
      @property
      @pulumi.getter
      def path(self) -> pulumi.Input[str]:
          """
          HTTP path.
          """
          return pulumi.get(self, "path")
  
      @path.setter
      def path(self, value: pulumi.Input[str]):
          pulumi.set(self, "path", value)
  
      @property
      @pulumi.getter
      def host(self) -> Optional[pulumi.Input[str]]:
          """
          "Host" HTTP header value.
          """
          return pulumi.get(self, "host")
  
      @host.setter
      def host(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "host", value)
  
      @property
      @pulumi.getter
      def http2(self) -> Optional[pulumi.Input[bool]]:
          """
          If set, health checks will use HTTP2.
          """
          return pulumi.get(self, "http2")
  
      @http2.setter
      def http2(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "http2", value)
  
  
  @pulumi.input_type
  class AlbBackendGroupHttpBackendHealthcheckStreamHealthcheckArgs:
      def __init__(__self__, *,
                   receive: Optional[pulumi.Input[str]] = None,
                   send: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] receive: Text to search in reply.
          :param pulumi.Input[str] send: Message to send. If empty, it's a connect-only health check.
          """
          if receive is not None:
              pulumi.set(__self__, "receive", receive)
          if send is not None:
              pulumi.set(__self__, "send", send)
  
      @property
      @pulumi.getter
      def receive(self) -> Optional[pulumi.Input[str]]:
          """
          Text to search in reply.
          """
          return pulumi.get(self, "receive")
  
      @receive.setter
      def receive(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "receive", value)
  
      @property
      @pulumi.getter
      def send(self) -> Optional[pulumi.Input[str]]:
          """
          Message to send. If empty, it's a connect-only health check.
          """
          return pulumi.get(self, "send")
  
      @send.setter
      def send(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "send", value)
  
  
  @pulumi.input_type
  class AlbBackendGroupHttpBackendLoadBalancingConfigArgs:
      def __init__(__self__, *,
                   locality_aware_routing_percent: Optional[pulumi.Input[int]] = None,
                   panic_threshold: Optional[pulumi.Input[int]] = None,
                   strict_locality: Optional[pulumi.Input[bool]] = None):
          """
          :param pulumi.Input[int] locality_aware_routing_percent: Percent of traffic to be sent to the same availability zone. The rest will be equally divided between other zones.
          :param pulumi.Input[int] panic_threshold: If percentage of healthy hosts in the backend is lower than panic_threshold, traffic will be routed to all backends no matter what the health status is. This helps to avoid healthy backends overloading  when everything is bad. Zero means no panic threshold.
          :param pulumi.Input[bool] strict_locality: If set, will route requests only to the same availability zone. Balancer won't know about endpoints in other zones.
          """
          if locality_aware_routing_percent is not None:
              pulumi.set(__self__, "locality_aware_routing_percent", locality_aware_routing_percent)
          if panic_threshold is not None:
              pulumi.set(__self__, "panic_threshold", panic_threshold)
          if strict_locality is not None:
              pulumi.set(__self__, "strict_locality", strict_locality)
  
      @property
      @pulumi.getter(name="localityAwareRoutingPercent")
      def locality_aware_routing_percent(self) -> Optional[pulumi.Input[int]]:
          """
          Percent of traffic to be sent to the same availability zone. The rest will be equally divided between other zones.
          """
          return pulumi.get(self, "locality_aware_routing_percent")
  
      @locality_aware_routing_percent.setter
      def locality_aware_routing_percent(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "locality_aware_routing_percent", value)
  
      @property
      @pulumi.getter(name="panicThreshold")
      def panic_threshold(self) -> Optional[pulumi.Input[int]]:
          """
          If percentage of healthy hosts in the backend is lower than panic_threshold, traffic will be routed to all backends no matter what the health status is. This helps to avoid healthy backends overloading  when everything is bad. Zero means no panic threshold.
          """
          return pulumi.get(self, "panic_threshold")
  
      @panic_threshold.setter
      def panic_threshold(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "panic_threshold", value)
  
      @property
      @pulumi.getter(name="strictLocality")
      def strict_locality(self) -> Optional[pulumi.Input[bool]]:
          """
          If set, will route requests only to the same availability zone. Balancer won't know about endpoints in other zones.
          """
          return pulumi.get(self, "strict_locality")
  
      @strict_locality.setter
      def strict_locality(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "strict_locality", value)
  
  
  @pulumi.input_type
  class AlbBackendGroupHttpBackendTlsArgs:
      def __init__(__self__, *,
                   sni: Optional[pulumi.Input[str]] = None,
                   validation_context: Optional[pulumi.Input['AlbBackendGroupHttpBackendTlsValidationContextArgs']] = None):
          """
          :param pulumi.Input[str] sni: [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication) string for TLS connections.
                 * `validation_context.0.trusted_ca_id` - (Optional) Trusted CA certificate ID in the Certificate Manager.
                 * `validation_context.0.trusted_ca_bytes` - (Optional) PEM-encoded trusted CA certificate chain.
          """
          if sni is not None:
              pulumi.set(__self__, "sni", sni)
          if validation_context is not None:
              pulumi.set(__self__, "validation_context", validation_context)
  
      @property
      @pulumi.getter
      def sni(self) -> Optional[pulumi.Input[str]]:
          """
          [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication) string for TLS connections.
          * `validation_context.0.trusted_ca_id` - (Optional) Trusted CA certificate ID in the Certificate Manager.
          * `validation_context.0.trusted_ca_bytes` - (Optional) PEM-encoded trusted CA certificate chain.
          """
          return pulumi.get(self, "sni")
  
      @sni.setter
      def sni(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "sni", value)
  
      @property
      @pulumi.getter(name="validationContext")
      def validation_context(self) -> Optional[pulumi.Input['AlbBackendGroupHttpBackendTlsValidationContextArgs']]:
          return pulumi.get(self, "validation_context")
  
      @validation_context.setter
      def validation_context(self, value: Optional[pulumi.Input['AlbBackendGroupHttpBackendTlsValidationContextArgs']]):
          pulumi.set(self, "validation_context", value)
  
  
  @pulumi.input_type
  class AlbBackendGroupHttpBackendTlsValidationContextArgs:
      def __init__(__self__, *,
                   trusted_ca_bytes: Optional[pulumi.Input[str]] = None,
                   trusted_ca_id: Optional[pulumi.Input[str]] = None):
          if trusted_ca_bytes is not None:
              pulumi.set(__self__, "trusted_ca_bytes", trusted_ca_bytes)
          if trusted_ca_id is not None:
              pulumi.set(__self__, "trusted_ca_id", trusted_ca_id)
  
      @property
      @pulumi.getter(name="trustedCaBytes")
      def trusted_ca_bytes(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "trusted_ca_bytes")
  
      @trusted_ca_bytes.setter
      def trusted_ca_bytes(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "trusted_ca_bytes", value)
  
      @property
      @pulumi.getter(name="trustedCaId")
      def trusted_ca_id(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "trusted_ca_id")
  
      @trusted_ca_id.setter
      def trusted_ca_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "trusted_ca_id", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerAllocationPolicyArgs:
      def __init__(__self__, *,
                   locations: pulumi.Input[Sequence[pulumi.Input['AlbLoadBalancerAllocationPolicyLocationArgs']]]):
          """
          :param pulumi.Input[Sequence[pulumi.Input['AlbLoadBalancerAllocationPolicyLocationArgs']]] locations: Unique set of locations. The structure is documented below.
          """
          pulumi.set(__self__, "locations", locations)
  
      @property
      @pulumi.getter
      def locations(self) -> pulumi.Input[Sequence[pulumi.Input['AlbLoadBalancerAllocationPolicyLocationArgs']]]:
          """
          Unique set of locations. The structure is documented below.
          """
          return pulumi.get(self, "locations")
  
      @locations.setter
      def locations(self, value: pulumi.Input[Sequence[pulumi.Input['AlbLoadBalancerAllocationPolicyLocationArgs']]]):
          pulumi.set(self, "locations", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerAllocationPolicyLocationArgs:
      def __init__(__self__, *,
                   subnet_id: pulumi.Input[str],
                   zone_id: pulumi.Input[str],
                   disable_traffic: Optional[pulumi.Input[bool]] = None):
          """
          :param pulumi.Input[str] subnet_id: Provided by the client or computed automatically.
          :param pulumi.Input[str] zone_id: ID of the zone that location is located at.
          :param pulumi.Input[bool] disable_traffic: If set, will disable all L7 instances in the zone for request handling.
          """
          pulumi.set(__self__, "subnet_id", subnet_id)
          pulumi.set(__self__, "zone_id", zone_id)
          if disable_traffic is not None:
              pulumi.set(__self__, "disable_traffic", disable_traffic)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> pulumi.Input[str]:
          """
          Provided by the client or computed automatically.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "subnet_id", value)
  
      @property
      @pulumi.getter(name="zoneId")
      def zone_id(self) -> pulumi.Input[str]:
          """
          ID of the zone that location is located at.
          """
          return pulumi.get(self, "zone_id")
  
      @zone_id.setter
      def zone_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "zone_id", value)
  
      @property
      @pulumi.getter(name="disableTraffic")
      def disable_traffic(self) -> Optional[pulumi.Input[bool]]:
          """
          If set, will disable all L7 instances in the zone for request handling.
          """
          return pulumi.get(self, "disable_traffic")
  
      @disable_traffic.setter
      def disable_traffic(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "disable_traffic", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   endpoints: Optional[pulumi.Input[Sequence[pulumi.Input['AlbLoadBalancerListenerEndpointArgs']]]] = None,
                   http: Optional[pulumi.Input['AlbLoadBalancerListenerHttpArgs']] = None,
                   tls: Optional[pulumi.Input['AlbLoadBalancerListenerTlsArgs']] = None):
          """
          :param pulumi.Input[str] name: name of SNI match.
          :param pulumi.Input[Sequence[pulumi.Input['AlbLoadBalancerListenerEndpointArgs']]] endpoints: Network endpoints (addresses and ports) of the listener. The structure is documented below.
          :param pulumi.Input['AlbLoadBalancerListenerHttpArgs'] http: HTTP listener resource. The structure is documented below.
          :param pulumi.Input['AlbLoadBalancerListenerTlsArgs'] tls: TLS listener resource. The structure is documented below.
          """
          pulumi.set(__self__, "name", name)
          if endpoints is not None:
              pulumi.set(__self__, "endpoints", endpoints)
          if http is not None:
              pulumi.set(__self__, "http", http)
          if tls is not None:
              pulumi.set(__self__, "tls", tls)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          name of SNI match.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def endpoints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AlbLoadBalancerListenerEndpointArgs']]]]:
          """
          Network endpoints (addresses and ports) of the listener. The structure is documented below.
          """
          return pulumi.get(self, "endpoints")
  
      @endpoints.setter
      def endpoints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AlbLoadBalancerListenerEndpointArgs']]]]):
          pulumi.set(self, "endpoints", value)
  
      @property
      @pulumi.getter
      def http(self) -> Optional[pulumi.Input['AlbLoadBalancerListenerHttpArgs']]:
          """
          HTTP listener resource. The structure is documented below.
          """
          return pulumi.get(self, "http")
  
      @http.setter
      def http(self, value: Optional[pulumi.Input['AlbLoadBalancerListenerHttpArgs']]):
          pulumi.set(self, "http", value)
  
      @property
      @pulumi.getter
      def tls(self) -> Optional[pulumi.Input['AlbLoadBalancerListenerTlsArgs']]:
          """
          TLS listener resource. The structure is documented below.
          """
          return pulumi.get(self, "tls")
  
      @tls.setter
      def tls(self, value: Optional[pulumi.Input['AlbLoadBalancerListenerTlsArgs']]):
          pulumi.set(self, "tls", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerEndpointArgs:
      def __init__(__self__, *,
                   addresses: pulumi.Input[Sequence[pulumi.Input['AlbLoadBalancerListenerEndpointAddressArgs']]],
                   ports: pulumi.Input[Sequence[pulumi.Input[int]]]):
          """
          :param pulumi.Input[Sequence[pulumi.Input['AlbLoadBalancerListenerEndpointAddressArgs']]] addresses: Provided by the client or computed automatically.
          :param pulumi.Input[Sequence[pulumi.Input[int]]] ports: One or more ports to listen on.
          """
          pulumi.set(__self__, "addresses", addresses)
          pulumi.set(__self__, "ports", ports)
  
      @property
      @pulumi.getter
      def addresses(self) -> pulumi.Input[Sequence[pulumi.Input['AlbLoadBalancerListenerEndpointAddressArgs']]]:
          """
          Provided by the client or computed automatically.
          """
          return pulumi.get(self, "addresses")
  
      @addresses.setter
      def addresses(self, value: pulumi.Input[Sequence[pulumi.Input['AlbLoadBalancerListenerEndpointAddressArgs']]]):
          pulumi.set(self, "addresses", value)
  
      @property
      @pulumi.getter
      def ports(self) -> pulumi.Input[Sequence[pulumi.Input[int]]]:
          """
          One or more ports to listen on.
          """
          return pulumi.get(self, "ports")
  
      @ports.setter
      def ports(self, value: pulumi.Input[Sequence[pulumi.Input[int]]]):
          pulumi.set(self, "ports", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerEndpointAddressArgs:
      def __init__(__self__, *,
                   external_ipv4_address: Optional[pulumi.Input['AlbLoadBalancerListenerEndpointAddressExternalIpv4AddressArgs']] = None,
                   external_ipv6_address: Optional[pulumi.Input['AlbLoadBalancerListenerEndpointAddressExternalIpv6AddressArgs']] = None,
                   internal_ipv4_address: Optional[pulumi.Input['AlbLoadBalancerListenerEndpointAddressInternalIpv4AddressArgs']] = None):
          """
          :param pulumi.Input['AlbLoadBalancerListenerEndpointAddressExternalIpv4AddressArgs'] external_ipv4_address: External IPv4 address. The structure is documented below.
          :param pulumi.Input['AlbLoadBalancerListenerEndpointAddressExternalIpv6AddressArgs'] external_ipv6_address: External IPv6 address. The structure is documented below.
          :param pulumi.Input['AlbLoadBalancerListenerEndpointAddressInternalIpv4AddressArgs'] internal_ipv4_address: Internal IPv4 address. The structure is documented below.
          """
          if external_ipv4_address is not None:
              pulumi.set(__self__, "external_ipv4_address", external_ipv4_address)
          if external_ipv6_address is not None:
              pulumi.set(__self__, "external_ipv6_address", external_ipv6_address)
          if internal_ipv4_address is not None:
              pulumi.set(__self__, "internal_ipv4_address", internal_ipv4_address)
  
      @property
      @pulumi.getter(name="externalIpv4Address")
      def external_ipv4_address(self) -> Optional[pulumi.Input['AlbLoadBalancerListenerEndpointAddressExternalIpv4AddressArgs']]:
          """
          External IPv4 address. The structure is documented below.
          """
          return pulumi.get(self, "external_ipv4_address")
  
      @external_ipv4_address.setter
      def external_ipv4_address(self, value: Optional[pulumi.Input['AlbLoadBalancerListenerEndpointAddressExternalIpv4AddressArgs']]):
          pulumi.set(self, "external_ipv4_address", value)
  
      @property
      @pulumi.getter(name="externalIpv6Address")
      def external_ipv6_address(self) -> Optional[pulumi.Input['AlbLoadBalancerListenerEndpointAddressExternalIpv6AddressArgs']]:
          """
          External IPv6 address. The structure is documented below.
          """
          return pulumi.get(self, "external_ipv6_address")
  
      @external_ipv6_address.setter
      def external_ipv6_address(self, value: Optional[pulumi.Input['AlbLoadBalancerListenerEndpointAddressExternalIpv6AddressArgs']]):
          pulumi.set(self, "external_ipv6_address", value)
  
      @property
      @pulumi.getter(name="internalIpv4Address")
      def internal_ipv4_address(self) -> Optional[pulumi.Input['AlbLoadBalancerListenerEndpointAddressInternalIpv4AddressArgs']]:
          """
          Internal IPv4 address. The structure is documented below.
          """
          return pulumi.get(self, "internal_ipv4_address")
  
      @internal_ipv4_address.setter
      def internal_ipv4_address(self, value: Optional[pulumi.Input['AlbLoadBalancerListenerEndpointAddressInternalIpv4AddressArgs']]):
          pulumi.set(self, "internal_ipv4_address", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerEndpointAddressExternalIpv4AddressArgs:
      def __init__(__self__, *,
                   address: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] address: Provided by the client or computed automatically.
          """
          if address is not None:
              pulumi.set(__self__, "address", address)
  
      @property
      @pulumi.getter
      def address(self) -> Optional[pulumi.Input[str]]:
          """
          Provided by the client or computed automatically.
          """
          return pulumi.get(self, "address")
  
      @address.setter
      def address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "address", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerEndpointAddressExternalIpv6AddressArgs:
      def __init__(__self__, *,
                   address: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] address: Provided by the client or computed automatically.
          """
          if address is not None:
              pulumi.set(__self__, "address", address)
  
      @property
      @pulumi.getter
      def address(self) -> Optional[pulumi.Input[str]]:
          """
          Provided by the client or computed automatically.
          """
          return pulumi.get(self, "address")
  
      @address.setter
      def address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "address", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerEndpointAddressInternalIpv4AddressArgs:
      def __init__(__self__, *,
                   address: Optional[pulumi.Input[str]] = None,
                   subnet_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] address: Provided by the client or computed automatically.
          :param pulumi.Input[str] subnet_id: Provided by the client or computed automatically.
          """
          if address is not None:
              pulumi.set(__self__, "address", address)
          if subnet_id is not None:
              pulumi.set(__self__, "subnet_id", subnet_id)
  
      @property
      @pulumi.getter
      def address(self) -> Optional[pulumi.Input[str]]:
          """
          Provided by the client or computed automatically.
          """
          return pulumi.get(self, "address")
  
      @address.setter
      def address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "address", value)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> Optional[pulumi.Input[str]]:
          """
          Provided by the client or computed automatically.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "subnet_id", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerHttpArgs:
      def __init__(__self__, *,
                   handler: Optional[pulumi.Input['AlbLoadBalancerListenerHttpHandlerArgs']] = None,
                   redirects: Optional[pulumi.Input['AlbLoadBalancerListenerHttpRedirectsArgs']] = None):
          """
          :param pulumi.Input['AlbLoadBalancerListenerHttpHandlerArgs'] handler: HTTP handler that sets plaintext HTTP router. The structure is documented below.
          :param pulumi.Input['AlbLoadBalancerListenerHttpRedirectsArgs'] redirects: Shortcut for adding http > https redirects. The structure is documented below.
          """
          if handler is not None:
              pulumi.set(__self__, "handler", handler)
          if redirects is not None:
              pulumi.set(__self__, "redirects", redirects)
  
      @property
      @pulumi.getter
      def handler(self) -> Optional[pulumi.Input['AlbLoadBalancerListenerHttpHandlerArgs']]:
          """
          HTTP handler that sets plaintext HTTP router. The structure is documented below.
          """
          return pulumi.get(self, "handler")
  
      @handler.setter
      def handler(self, value: Optional[pulumi.Input['AlbLoadBalancerListenerHttpHandlerArgs']]):
          pulumi.set(self, "handler", value)
  
      @property
      @pulumi.getter
      def redirects(self) -> Optional[pulumi.Input['AlbLoadBalancerListenerHttpRedirectsArgs']]:
          """
          Shortcut for adding http > https redirects. The structure is documented below.
          """
          return pulumi.get(self, "redirects")
  
      @redirects.setter
      def redirects(self, value: Optional[pulumi.Input['AlbLoadBalancerListenerHttpRedirectsArgs']]):
          pulumi.set(self, "redirects", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerHttpHandlerArgs:
      def __init__(__self__, *,
                   allow_http10: Optional[pulumi.Input[bool]] = None,
                   http2_options: Optional[pulumi.Input['AlbLoadBalancerListenerHttpHandlerHttp2OptionsArgs']] = None,
                   http_router_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[bool] allow_http10: If set, will enable only HTTP1 protocol with HTTP1.0 support.
          :param pulumi.Input['AlbLoadBalancerListenerHttpHandlerHttp2OptionsArgs'] http2_options: If set, will enable HTTP2 protocol for the handler. The structure is documented below.
          :param pulumi.Input[str] http_router_id: HTTP router id.
          """
          if allow_http10 is not None:
              pulumi.set(__self__, "allow_http10", allow_http10)
          if http2_options is not None:
              pulumi.set(__self__, "http2_options", http2_options)
          if http_router_id is not None:
              pulumi.set(__self__, "http_router_id", http_router_id)
  
      @property
      @pulumi.getter(name="allowHttp10")
      def allow_http10(self) -> Optional[pulumi.Input[bool]]:
          """
          If set, will enable only HTTP1 protocol with HTTP1.0 support.
          """
          return pulumi.get(self, "allow_http10")
  
      @allow_http10.setter
      def allow_http10(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "allow_http10", value)
  
      @property
      @pulumi.getter(name="http2Options")
      def http2_options(self) -> Optional[pulumi.Input['AlbLoadBalancerListenerHttpHandlerHttp2OptionsArgs']]:
          """
          If set, will enable HTTP2 protocol for the handler. The structure is documented below.
          """
          return pulumi.get(self, "http2_options")
  
      @http2_options.setter
      def http2_options(self, value: Optional[pulumi.Input['AlbLoadBalancerListenerHttpHandlerHttp2OptionsArgs']]):
          pulumi.set(self, "http2_options", value)
  
      @property
      @pulumi.getter(name="httpRouterId")
      def http_router_id(self) -> Optional[pulumi.Input[str]]:
          """
          HTTP router id.
          """
          return pulumi.get(self, "http_router_id")
  
      @http_router_id.setter
      def http_router_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "http_router_id", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerHttpHandlerHttp2OptionsArgs:
      def __init__(__self__, *,
                   max_concurrent_streams: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] max_concurrent_streams: Maximum number of concurrent streams.
          """
          if max_concurrent_streams is not None:
              pulumi.set(__self__, "max_concurrent_streams", max_concurrent_streams)
  
      @property
      @pulumi.getter(name="maxConcurrentStreams")
      def max_concurrent_streams(self) -> Optional[pulumi.Input[int]]:
          """
          Maximum number of concurrent streams.
          """
          return pulumi.get(self, "max_concurrent_streams")
  
      @max_concurrent_streams.setter
      def max_concurrent_streams(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_concurrent_streams", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerHttpRedirectsArgs:
      def __init__(__self__, *,
                   http_to_https: Optional[pulumi.Input[bool]] = None):
          if http_to_https is not None:
              pulumi.set(__self__, "http_to_https", http_to_https)
  
      @property
      @pulumi.getter(name="httpToHttps")
      def http_to_https(self) -> Optional[pulumi.Input[bool]]:
          return pulumi.get(self, "http_to_https")
  
      @http_to_https.setter
      def http_to_https(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "http_to_https", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerTlsArgs:
      def __init__(__self__, *,
                   default_handler: pulumi.Input['AlbLoadBalancerListenerTlsDefaultHandlerArgs'],
                   sni_handlers: Optional[pulumi.Input[Sequence[pulumi.Input['AlbLoadBalancerListenerTlsSniHandlerArgs']]]] = None):
          """
          :param pulumi.Input['AlbLoadBalancerListenerTlsDefaultHandlerArgs'] default_handler: TLS handler resource. The structure is documented below.
          :param pulumi.Input[Sequence[pulumi.Input['AlbLoadBalancerListenerTlsSniHandlerArgs']]] sni_handlers: SNI match resource. The structure is documented below.
          """
          pulumi.set(__self__, "default_handler", default_handler)
          if sni_handlers is not None:
              pulumi.set(__self__, "sni_handlers", sni_handlers)
  
      @property
      @pulumi.getter(name="defaultHandler")
      def default_handler(self) -> pulumi.Input['AlbLoadBalancerListenerTlsDefaultHandlerArgs']:
          """
          TLS handler resource. The structure is documented below.
          """
          return pulumi.get(self, "default_handler")
  
      @default_handler.setter
      def default_handler(self, value: pulumi.Input['AlbLoadBalancerListenerTlsDefaultHandlerArgs']):
          pulumi.set(self, "default_handler", value)
  
      @property
      @pulumi.getter(name="sniHandlers")
      def sni_handlers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AlbLoadBalancerListenerTlsSniHandlerArgs']]]]:
          """
          SNI match resource. The structure is documented below.
          """
          return pulumi.get(self, "sni_handlers")
  
      @sni_handlers.setter
      def sni_handlers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AlbLoadBalancerListenerTlsSniHandlerArgs']]]]):
          pulumi.set(self, "sni_handlers", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerTlsDefaultHandlerArgs:
      def __init__(__self__, *,
                   certificate_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
                   http_handler: Optional[pulumi.Input['AlbLoadBalancerListenerTlsDefaultHandlerHttpHandlerArgs']] = None):
          """
          :param pulumi.Input[Sequence[pulumi.Input[str]]] certificate_ids: Certificate IDs in the Certificate Manager. Multiple TLS certificates can be associated
                 with the same context to allow both RSA and ECDSA certificates. Only the first certificate of each type will be used.
          :param pulumi.Input['AlbLoadBalancerListenerTlsDefaultHandlerHttpHandlerArgs'] http_handler: HTTP handler resource. The structure is documented below.
          """
          pulumi.set(__self__, "certificate_ids", certificate_ids)
          if http_handler is not None:
              pulumi.set(__self__, "http_handler", http_handler)
  
      @property
      @pulumi.getter(name="certificateIds")
      def certificate_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          """
          Certificate IDs in the Certificate Manager. Multiple TLS certificates can be associated
          with the same context to allow both RSA and ECDSA certificates. Only the first certificate of each type will be used.
          """
          return pulumi.get(self, "certificate_ids")
  
      @certificate_ids.setter
      def certificate_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "certificate_ids", value)
  
      @property
      @pulumi.getter(name="httpHandler")
      def http_handler(self) -> Optional[pulumi.Input['AlbLoadBalancerListenerTlsDefaultHandlerHttpHandlerArgs']]:
          """
          HTTP handler resource. The structure is documented below.
          """
          return pulumi.get(self, "http_handler")
  
      @http_handler.setter
      def http_handler(self, value: Optional[pulumi.Input['AlbLoadBalancerListenerTlsDefaultHandlerHttpHandlerArgs']]):
          pulumi.set(self, "http_handler", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerTlsDefaultHandlerHttpHandlerArgs:
      def __init__(__self__, *,
                   allow_http10: Optional[pulumi.Input[bool]] = None,
                   http2_options: Optional[pulumi.Input['AlbLoadBalancerListenerTlsDefaultHandlerHttpHandlerHttp2OptionsArgs']] = None,
                   http_router_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[bool] allow_http10: If set, will enable only HTTP1 protocol with HTTP1.0 support.
          :param pulumi.Input['AlbLoadBalancerListenerTlsDefaultHandlerHttpHandlerHttp2OptionsArgs'] http2_options: If set, will enable HTTP2 protocol for the handler. The structure is documented below.
          :param pulumi.Input[str] http_router_id: HTTP router id.
          """
          if allow_http10 is not None:
              pulumi.set(__self__, "allow_http10", allow_http10)
          if http2_options is not None:
              pulumi.set(__self__, "http2_options", http2_options)
          if http_router_id is not None:
              pulumi.set(__self__, "http_router_id", http_router_id)
  
      @property
      @pulumi.getter(name="allowHttp10")
      def allow_http10(self) -> Optional[pulumi.Input[bool]]:
          """
          If set, will enable only HTTP1 protocol with HTTP1.0 support.
          """
          return pulumi.get(self, "allow_http10")
  
      @allow_http10.setter
      def allow_http10(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "allow_http10", value)
  
      @property
      @pulumi.getter(name="http2Options")
      def http2_options(self) -> Optional[pulumi.Input['AlbLoadBalancerListenerTlsDefaultHandlerHttpHandlerHttp2OptionsArgs']]:
          """
          If set, will enable HTTP2 protocol for the handler. The structure is documented below.
          """
          return pulumi.get(self, "http2_options")
  
      @http2_options.setter
      def http2_options(self, value: Optional[pulumi.Input['AlbLoadBalancerListenerTlsDefaultHandlerHttpHandlerHttp2OptionsArgs']]):
          pulumi.set(self, "http2_options", value)
  
      @property
      @pulumi.getter(name="httpRouterId")
      def http_router_id(self) -> Optional[pulumi.Input[str]]:
          """
          HTTP router id.
          """
          return pulumi.get(self, "http_router_id")
  
      @http_router_id.setter
      def http_router_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "http_router_id", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerTlsDefaultHandlerHttpHandlerHttp2OptionsArgs:
      def __init__(__self__, *,
                   max_concurrent_streams: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] max_concurrent_streams: Maximum number of concurrent streams.
          """
          if max_concurrent_streams is not None:
              pulumi.set(__self__, "max_concurrent_streams", max_concurrent_streams)
  
      @property
      @pulumi.getter(name="maxConcurrentStreams")
      def max_concurrent_streams(self) -> Optional[pulumi.Input[int]]:
          """
          Maximum number of concurrent streams.
          """
          return pulumi.get(self, "max_concurrent_streams")
  
      @max_concurrent_streams.setter
      def max_concurrent_streams(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_concurrent_streams", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerTlsSniHandlerArgs:
      def __init__(__self__, *,
                   handler: pulumi.Input['AlbLoadBalancerListenerTlsSniHandlerHandlerArgs'],
                   name: pulumi.Input[str],
                   server_names: pulumi.Input[Sequence[pulumi.Input[str]]]):
          """
          :param pulumi.Input['AlbLoadBalancerListenerTlsSniHandlerHandlerArgs'] handler: HTTP handler that sets plaintext HTTP router. The structure is documented below.
          :param pulumi.Input[str] name: name of SNI match.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] server_names: A set of server names.
          """
          pulumi.set(__self__, "handler", handler)
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "server_names", server_names)
  
      @property
      @pulumi.getter
      def handler(self) -> pulumi.Input['AlbLoadBalancerListenerTlsSniHandlerHandlerArgs']:
          """
          HTTP handler that sets plaintext HTTP router. The structure is documented below.
          """
          return pulumi.get(self, "handler")
  
      @handler.setter
      def handler(self, value: pulumi.Input['AlbLoadBalancerListenerTlsSniHandlerHandlerArgs']):
          pulumi.set(self, "handler", value)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          name of SNI match.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="serverNames")
      def server_names(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          """
          A set of server names.
          """
          return pulumi.get(self, "server_names")
  
      @server_names.setter
      def server_names(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "server_names", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerTlsSniHandlerHandlerArgs:
      def __init__(__self__, *,
                   certificate_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
                   http_handler: Optional[pulumi.Input['AlbLoadBalancerListenerTlsSniHandlerHandlerHttpHandlerArgs']] = None):
          """
          :param pulumi.Input[Sequence[pulumi.Input[str]]] certificate_ids: Certificate IDs in the Certificate Manager. Multiple TLS certificates can be associated
                 with the same context to allow both RSA and ECDSA certificates. Only the first certificate of each type will be used.
          :param pulumi.Input['AlbLoadBalancerListenerTlsSniHandlerHandlerHttpHandlerArgs'] http_handler: HTTP handler resource. The structure is documented below.
          """
          pulumi.set(__self__, "certificate_ids", certificate_ids)
          if http_handler is not None:
              pulumi.set(__self__, "http_handler", http_handler)
  
      @property
      @pulumi.getter(name="certificateIds")
      def certificate_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          """
          Certificate IDs in the Certificate Manager. Multiple TLS certificates can be associated
          with the same context to allow both RSA and ECDSA certificates. Only the first certificate of each type will be used.
          """
          return pulumi.get(self, "certificate_ids")
  
      @certificate_ids.setter
      def certificate_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "certificate_ids", value)
  
      @property
      @pulumi.getter(name="httpHandler")
      def http_handler(self) -> Optional[pulumi.Input['AlbLoadBalancerListenerTlsSniHandlerHandlerHttpHandlerArgs']]:
          """
          HTTP handler resource. The structure is documented below.
          """
          return pulumi.get(self, "http_handler")
  
      @http_handler.setter
      def http_handler(self, value: Optional[pulumi.Input['AlbLoadBalancerListenerTlsSniHandlerHandlerHttpHandlerArgs']]):
          pulumi.set(self, "http_handler", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerTlsSniHandlerHandlerHttpHandlerArgs:
      def __init__(__self__, *,
                   allow_http10: Optional[pulumi.Input[bool]] = None,
                   http2_options: Optional[pulumi.Input['AlbLoadBalancerListenerTlsSniHandlerHandlerHttpHandlerHttp2OptionsArgs']] = None,
                   http_router_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[bool] allow_http10: If set, will enable only HTTP1 protocol with HTTP1.0 support.
          :param pulumi.Input['AlbLoadBalancerListenerTlsSniHandlerHandlerHttpHandlerHttp2OptionsArgs'] http2_options: If set, will enable HTTP2 protocol for the handler. The structure is documented below.
          :param pulumi.Input[str] http_router_id: HTTP router id.
          """
          if allow_http10 is not None:
              pulumi.set(__self__, "allow_http10", allow_http10)
          if http2_options is not None:
              pulumi.set(__self__, "http2_options", http2_options)
          if http_router_id is not None:
              pulumi.set(__self__, "http_router_id", http_router_id)
  
      @property
      @pulumi.getter(name="allowHttp10")
      def allow_http10(self) -> Optional[pulumi.Input[bool]]:
          """
          If set, will enable only HTTP1 protocol with HTTP1.0 support.
          """
          return pulumi.get(self, "allow_http10")
  
      @allow_http10.setter
      def allow_http10(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "allow_http10", value)
  
      @property
      @pulumi.getter(name="http2Options")
      def http2_options(self) -> Optional[pulumi.Input['AlbLoadBalancerListenerTlsSniHandlerHandlerHttpHandlerHttp2OptionsArgs']]:
          """
          If set, will enable HTTP2 protocol for the handler. The structure is documented below.
          """
          return pulumi.get(self, "http2_options")
  
      @http2_options.setter
      def http2_options(self, value: Optional[pulumi.Input['AlbLoadBalancerListenerTlsSniHandlerHandlerHttpHandlerHttp2OptionsArgs']]):
          pulumi.set(self, "http2_options", value)
  
      @property
      @pulumi.getter(name="httpRouterId")
      def http_router_id(self) -> Optional[pulumi.Input[str]]:
          """
          HTTP router id.
          """
          return pulumi.get(self, "http_router_id")
  
      @http_router_id.setter
      def http_router_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "http_router_id", value)
  
  
  @pulumi.input_type
  class AlbLoadBalancerListenerTlsSniHandlerHandlerHttpHandlerHttp2OptionsArgs:
      def __init__(__self__, *,
                   max_concurrent_streams: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] max_concurrent_streams: Maximum number of concurrent streams.
          """
          if max_concurrent_streams is not None:
              pulumi.set(__self__, "max_concurrent_streams", max_concurrent_streams)
  
      @property
      @pulumi.getter(name="maxConcurrentStreams")
      def max_concurrent_streams(self) -> Optional[pulumi.Input[int]]:
          """
          Maximum number of concurrent streams.
          """
          return pulumi.get(self, "max_concurrent_streams")
  
      @max_concurrent_streams.setter
      def max_concurrent_streams(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_concurrent_streams", value)
  
  
  @pulumi.input_type
  class AlbTargetGroupTargetArgs:
      def __init__(__self__, *,
                   ip_address: pulumi.Input[str],
                   subnet_id: pulumi.Input[str]):
          """
          :param pulumi.Input[str] ip_address: IP address of the target.
          :param pulumi.Input[str] subnet_id: ID of the subnet that targets are connected to.
                 All targets in the target group must be connected to the same subnet within a single availability zone.
          """
          pulumi.set(__self__, "ip_address", ip_address)
          pulumi.set(__self__, "subnet_id", subnet_id)
  
      @property
      @pulumi.getter(name="ipAddress")
      def ip_address(self) -> pulumi.Input[str]:
          """
          IP address of the target.
          """
          return pulumi.get(self, "ip_address")
  
      @ip_address.setter
      def ip_address(self, value: pulumi.Input[str]):
          pulumi.set(self, "ip_address", value)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> pulumi.Input[str]:
          """
          ID of the subnet that targets are connected to.
          All targets in the target group must be connected to the same subnet within a single availability zone.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "subnet_id", value)
  
  
  @pulumi.input_type
  class AlbVirtualHostModifyRequestHeaderArgs:
      def __init__(__self__, *,
                   append: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   remove: Optional[pulumi.Input[bool]] = None,
                   replace: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] append: Append string to the header value.
          :param pulumi.Input[str] name: name of the route.
          :param pulumi.Input[bool] remove: If set, remove the header.
          :param pulumi.Input[str] replace: New value for a header. Header values support the following 
                 [formatters](https://www.envoyproxy.io/docs/envoy/latest/configuration/http/http_conn_man/headers#custom-request-response-headers).
          """
          if append is not None:
              pulumi.set(__self__, "append", append)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if remove is not None:
              pulumi.set(__self__, "remove", remove)
          if replace is not None:
              pulumi.set(__self__, "replace", replace)
  
      @property
      @pulumi.getter
      def append(self) -> Optional[pulumi.Input[str]]:
          """
          Append string to the header value.
          """
          return pulumi.get(self, "append")
  
      @append.setter
      def append(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "append", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          name of the route.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def remove(self) -> Optional[pulumi.Input[bool]]:
          """
          If set, remove the header.
          """
          return pulumi.get(self, "remove")
  
      @remove.setter
      def remove(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "remove", value)
  
      @property
      @pulumi.getter
      def replace(self) -> Optional[pulumi.Input[str]]:
          """
          New value for a header. Header values support the following 
          [formatters](https://www.envoyproxy.io/docs/envoy/latest/configuration/http/http_conn_man/headers#custom-request-response-headers).
          """
          return pulumi.get(self, "replace")
  
      @replace.setter
      def replace(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "replace", value)
  
  
  @pulumi.input_type
  class AlbVirtualHostModifyResponseHeaderArgs:
      def __init__(__self__, *,
                   append: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   remove: Optional[pulumi.Input[bool]] = None,
                   replace: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] append: Append string to the header value.
          :param pulumi.Input[str] name: name of the route.
          :param pulumi.Input[bool] remove: If set, remove the header.
          :param pulumi.Input[str] replace: New value for a header. Header values support the following 
                 [formatters](https://www.envoyproxy.io/docs/envoy/latest/configuration/http/http_conn_man/headers#custom-request-response-headers).
          """
          if append is not None:
              pulumi.set(__self__, "append", append)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if remove is not None:
              pulumi.set(__self__, "remove", remove)
          if replace is not None:
              pulumi.set(__self__, "replace", replace)
  
      @property
      @pulumi.getter
      def append(self) -> Optional[pulumi.Input[str]]:
          """
          Append string to the header value.
          """
          return pulumi.get(self, "append")
  
      @append.setter
      def append(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "append", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          name of the route.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def remove(self) -> Optional[pulumi.Input[bool]]:
          """
          If set, remove the header.
          """
          return pulumi.get(self, "remove")
  
      @remove.setter
      def remove(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "remove", value)
  
      @property
      @pulumi.getter
      def replace(self) -> Optional[pulumi.Input[str]]:
          """
          New value for a header. Header values support the following 
          [formatters](https://www.envoyproxy.io/docs/envoy/latest/configuration/http/http_conn_man/headers#custom-request-response-headers).
          """
          return pulumi.get(self, "replace")
  
      @replace.setter
      def replace(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "replace", value)
  
  
  @pulumi.input_type
  class AlbVirtualHostRouteArgs:
      def __init__(__self__, *,
                   grpc_route: Optional[pulumi.Input['AlbVirtualHostRouteGrpcRouteArgs']] = None,
                   http_route: Optional[pulumi.Input['AlbVirtualHostRouteHttpRouteArgs']] = None,
                   name: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input['AlbVirtualHostRouteGrpcRouteArgs'] grpc_route: GRPC route resource. The structure is documented below.
          :param pulumi.Input['AlbVirtualHostRouteHttpRouteArgs'] http_route: HTTP route resource. The structure is documented below.
          :param pulumi.Input[str] name: name of the route.
          """
          if grpc_route is not None:
              pulumi.set(__self__, "grpc_route", grpc_route)
          if http_route is not None:
              pulumi.set(__self__, "http_route", http_route)
          if name is not None:
              pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter(name="grpcRoute")
      def grpc_route(self) -> Optional[pulumi.Input['AlbVirtualHostRouteGrpcRouteArgs']]:
          """
          GRPC route resource. The structure is documented below.
          """
          return pulumi.get(self, "grpc_route")
  
      @grpc_route.setter
      def grpc_route(self, value: Optional[pulumi.Input['AlbVirtualHostRouteGrpcRouteArgs']]):
          pulumi.set(self, "grpc_route", value)
  
      @property
      @pulumi.getter(name="httpRoute")
      def http_route(self) -> Optional[pulumi.Input['AlbVirtualHostRouteHttpRouteArgs']]:
          """
          HTTP route resource. The structure is documented below.
          """
          return pulumi.get(self, "http_route")
  
      @http_route.setter
      def http_route(self, value: Optional[pulumi.Input['AlbVirtualHostRouteHttpRouteArgs']]):
          pulumi.set(self, "http_route", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          name of the route.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class AlbVirtualHostRouteGrpcRouteArgs:
      def __init__(__self__, *,
                   grpc_matches: Optional[pulumi.Input[Sequence[pulumi.Input['AlbVirtualHostRouteGrpcRouteGrpcMatchArgs']]]] = None,
                   grpc_route_action: Optional[pulumi.Input['AlbVirtualHostRouteGrpcRouteGrpcRouteActionArgs']] = None,
                   grpc_status_response_action: Optional[pulumi.Input['AlbVirtualHostRouteGrpcRouteGrpcStatusResponseActionArgs']] = None):
          """
          :param pulumi.Input[Sequence[pulumi.Input['AlbVirtualHostRouteGrpcRouteGrpcMatchArgs']]] grpc_matches: Checks "/" prefix by default. The structure is documented below.
          :param pulumi.Input['AlbVirtualHostRouteGrpcRouteGrpcRouteActionArgs'] grpc_route_action: GRPC route action resource. The structure is documented below.
          :param pulumi.Input['AlbVirtualHostRouteGrpcRouteGrpcStatusResponseActionArgs'] grpc_status_response_action: GRPC status response action resource. The structure is documented below.
          """
          if grpc_matches is not None:
              pulumi.set(__self__, "grpc_matches", grpc_matches)
          if grpc_route_action is not None:
              pulumi.set(__self__, "grpc_route_action", grpc_route_action)
          if grpc_status_response_action is not None:
              pulumi.set(__self__, "grpc_status_response_action", grpc_status_response_action)
  
      @property
      @pulumi.getter(name="grpcMatches")
      def grpc_matches(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AlbVirtualHostRouteGrpcRouteGrpcMatchArgs']]]]:
          """
          Checks "/" prefix by default. The structure is documented below.
          """
          return pulumi.get(self, "grpc_matches")
  
      @grpc_matches.setter
      def grpc_matches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AlbVirtualHostRouteGrpcRouteGrpcMatchArgs']]]]):
          pulumi.set(self, "grpc_matches", value)
  
      @property
      @pulumi.getter(name="grpcRouteAction")
      def grpc_route_action(self) -> Optional[pulumi.Input['AlbVirtualHostRouteGrpcRouteGrpcRouteActionArgs']]:
          """
          GRPC route action resource. The structure is documented below.
          """
          return pulumi.get(self, "grpc_route_action")
  
      @grpc_route_action.setter
      def grpc_route_action(self, value: Optional[pulumi.Input['AlbVirtualHostRouteGrpcRouteGrpcRouteActionArgs']]):
          pulumi.set(self, "grpc_route_action", value)
  
      @property
      @pulumi.getter(name="grpcStatusResponseAction")
      def grpc_status_response_action(self) -> Optional[pulumi.Input['AlbVirtualHostRouteGrpcRouteGrpcStatusResponseActionArgs']]:
          """
          GRPC status response action resource. The structure is documented below.
          """
          return pulumi.get(self, "grpc_status_response_action")
  
      @grpc_status_response_action.setter
      def grpc_status_response_action(self, value: Optional[pulumi.Input['AlbVirtualHostRouteGrpcRouteGrpcStatusResponseActionArgs']]):
          pulumi.set(self, "grpc_status_response_action", value)
  
  
  @pulumi.input_type
  class AlbVirtualHostRouteGrpcRouteGrpcMatchArgs:
      def __init__(__self__, *,
                   fqmn: Optional[pulumi.Input['AlbVirtualHostRouteGrpcRouteGrpcMatchFqmnArgs']] = None):
          """
          :param pulumi.Input['AlbVirtualHostRouteGrpcRouteGrpcMatchFqmnArgs'] fqmn: If not set, all services/methods are assumed. The structure is documented below.
          """
          if fqmn is not None:
              pulumi.set(__self__, "fqmn", fqmn)
  
      @property
      @pulumi.getter
      def fqmn(self) -> Optional[pulumi.Input['AlbVirtualHostRouteGrpcRouteGrpcMatchFqmnArgs']]:
          """
          If not set, all services/methods are assumed. The structure is documented below.
          """
          return pulumi.get(self, "fqmn")
  
      @fqmn.setter
      def fqmn(self, value: Optional[pulumi.Input['AlbVirtualHostRouteGrpcRouteGrpcMatchFqmnArgs']]):
          pulumi.set(self, "fqmn", value)
  
  
  @pulumi.input_type
  class AlbVirtualHostRouteGrpcRouteGrpcMatchFqmnArgs:
      def __init__(__self__, *,
                   exact: Optional[pulumi.Input[str]] = None,
                   prefix: Optional[pulumi.Input[str]] = None):
          if exact is not None:
              pulumi.set(__self__, "exact", exact)
          if prefix is not None:
              pulumi.set(__self__, "prefix", prefix)
  
      @property
      @pulumi.getter
      def exact(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "exact")
  
      @exact.setter
      def exact(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "exact", value)
  
      @property
      @pulumi.getter
      def prefix(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "prefix")
  
      @prefix.setter
      def prefix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "prefix", value)
  
  
  @pulumi.input_type
  class AlbVirtualHostRouteGrpcRouteGrpcRouteActionArgs:
      def __init__(__self__, *,
                   backend_group_id: pulumi.Input[str],
                   auto_host_rewrite: Optional[pulumi.Input[bool]] = None,
                   host_rewrite: Optional[pulumi.Input[str]] = None,
                   idle_timeout: Optional[pulumi.Input[str]] = None,
                   max_timeout: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] backend_group_id: Backend group to route requests.
          :param pulumi.Input[bool] auto_host_rewrite: If set, will automatically rewrite host.
          :param pulumi.Input[str] host_rewrite: Host rewrite specifier.
          :param pulumi.Input[str] idle_timeout: Specifies the idle timeout (time without any data transfer for the active request) for the
                 route. It is useful for streaming scenarios - one should set idle_timeout to something meaningful and max_timeout
                 to the maximum time the stream is allowed to be alive. If not specified, there is no
                 per-route idle timeout.
          :param pulumi.Input[str] max_timeout: Lower timeout may be specified by the client (using grpc-timeout header). If not set, default is 
                 60 seconds.
          """
          pulumi.set(__self__, "backend_group_id", backend_group_id)
          if auto_host_rewrite is not None:
              pulumi.set(__self__, "auto_host_rewrite", auto_host_rewrite)
          if host_rewrite is not None:
              pulumi.set(__self__, "host_rewrite", host_rewrite)
          if idle_timeout is not None:
              pulumi.set(__self__, "idle_timeout", idle_timeout)
          if max_timeout is not None:
              pulumi.set(__self__, "max_timeout", max_timeout)
  
      @property
      @pulumi.getter(name="backendGroupId")
      def backend_group_id(self) -> pulumi.Input[str]:
          """
          Backend group to route requests.
          """
          return pulumi.get(self, "backend_group_id")
  
      @backend_group_id.setter
      def backend_group_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "backend_group_id", value)
  
      @property
      @pulumi.getter(name="autoHostRewrite")
      def auto_host_rewrite(self) -> Optional[pulumi.Input[bool]]:
          """
          If set, will automatically rewrite host.
          """
          return pulumi.get(self, "auto_host_rewrite")
  
      @auto_host_rewrite.setter
      def auto_host_rewrite(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "auto_host_rewrite", value)
  
      @property
      @pulumi.getter(name="hostRewrite")
      def host_rewrite(self) -> Optional[pulumi.Input[str]]:
          """
          Host rewrite specifier.
          """
          return pulumi.get(self, "host_rewrite")
  
      @host_rewrite.setter
      def host_rewrite(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "host_rewrite", value)
  
      @property
      @pulumi.getter(name="idleTimeout")
      def idle_timeout(self) -> Optional[pulumi.Input[str]]:
          """
          Specifies the idle timeout (time without any data transfer for the active request) for the
          route. It is useful for streaming scenarios - one should set idle_timeout to something meaningful and max_timeout
          to the maximum time the stream is allowed to be alive. If not specified, there is no
          per-route idle timeout.
          """
          return pulumi.get(self, "idle_timeout")
  
      @idle_timeout.setter
      def idle_timeout(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "idle_timeout", value)
  
      @property
      @pulumi.getter(name="maxTimeout")
      def max_timeout(self) -> Optional[pulumi.Input[str]]:
          """
          Lower timeout may be specified by the client (using grpc-timeout header). If not set, default is 
          60 seconds.
          """
          return pulumi.get(self, "max_timeout")
  
      @max_timeout.setter
      def max_timeout(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "max_timeout", value)
  
  
  @pulumi.input_type
  class AlbVirtualHostRouteGrpcRouteGrpcStatusResponseActionArgs:
      def __init__(__self__, *,
                   status: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] status: The status of the response. Supported values are: ok, invalid_argumet, not_found, 
                 permission_denied, unauthenticated, unimplemented, internal, unavailable.
          """
          if status is not None:
              pulumi.set(__self__, "status", status)
  
      @property
      @pulumi.getter
      def status(self) -> Optional[pulumi.Input[str]]:
          """
          The status of the response. Supported values are: ok, invalid_argumet, not_found, 
          permission_denied, unauthenticated, unimplemented, internal, unavailable.
          """
          return pulumi.get(self, "status")
  
      @status.setter
      def status(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "status", value)
  
  
  @pulumi.input_type
  class AlbVirtualHostRouteHttpRouteArgs:
      def __init__(__self__, *,
                   direct_response_action: Optional[pulumi.Input['AlbVirtualHostRouteHttpRouteDirectResponseActionArgs']] = None,
                   http_matches: Optional[pulumi.Input[Sequence[pulumi.Input['AlbVirtualHostRouteHttpRouteHttpMatchArgs']]]] = None,
                   http_route_action: Optional[pulumi.Input['AlbVirtualHostRouteHttpRouteHttpRouteActionArgs']] = None,
                   redirect_action: Optional[pulumi.Input['AlbVirtualHostRouteHttpRouteRedirectActionArgs']] = None):
          """
          :param pulumi.Input['AlbVirtualHostRouteHttpRouteDirectResponseActionArgs'] direct_response_action: Direct response action resource. The structure is documented below.
          :param pulumi.Input[Sequence[pulumi.Input['AlbVirtualHostRouteHttpRouteHttpMatchArgs']]] http_matches: Checks "/" prefix by default. The structure is documented below.
          :param pulumi.Input['AlbVirtualHostRouteHttpRouteHttpRouteActionArgs'] http_route_action: HTTP route action resource. The structure is documented below.
          :param pulumi.Input['AlbVirtualHostRouteHttpRouteRedirectActionArgs'] redirect_action: Redirect action resource. The structure is documented below.
          """
          if direct_response_action is not None:
              pulumi.set(__self__, "direct_response_action", direct_response_action)
          if http_matches is not None:
              pulumi.set(__self__, "http_matches", http_matches)
          if http_route_action is not None:
              pulumi.set(__self__, "http_route_action", http_route_action)
          if redirect_action is not None:
              pulumi.set(__self__, "redirect_action", redirect_action)
  
      @property
      @pulumi.getter(name="directResponseAction")
      def direct_response_action(self) -> Optional[pulumi.Input['AlbVirtualHostRouteHttpRouteDirectResponseActionArgs']]:
          """
          Direct response action resource. The structure is documented below.
          """
          return pulumi.get(self, "direct_response_action")
  
      @direct_response_action.setter
      def direct_response_action(self, value: Optional[pulumi.Input['AlbVirtualHostRouteHttpRouteDirectResponseActionArgs']]):
          pulumi.set(self, "direct_response_action", value)
  
      @property
      @pulumi.getter(name="httpMatches")
      def http_matches(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AlbVirtualHostRouteHttpRouteHttpMatchArgs']]]]:
          """
          Checks "/" prefix by default. The structure is documented below.
          """
          return pulumi.get(self, "http_matches")
  
      @http_matches.setter
      def http_matches(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AlbVirtualHostRouteHttpRouteHttpMatchArgs']]]]):
          pulumi.set(self, "http_matches", value)
  
      @property
      @pulumi.getter(name="httpRouteAction")
      def http_route_action(self) -> Optional[pulumi.Input['AlbVirtualHostRouteHttpRouteHttpRouteActionArgs']]:
          """
          HTTP route action resource. The structure is documented below.
          """
          return pulumi.get(self, "http_route_action")
  
      @http_route_action.setter
      def http_route_action(self, value: Optional[pulumi.Input['AlbVirtualHostRouteHttpRouteHttpRouteActionArgs']]):
          pulumi.set(self, "http_route_action", value)
  
      @property
      @pulumi.getter(name="redirectAction")
      def redirect_action(self) -> Optional[pulumi.Input['AlbVirtualHostRouteHttpRouteRedirectActionArgs']]:
          """
          Redirect action resource. The structure is documented below.
          """
          return pulumi.get(self, "redirect_action")
  
      @redirect_action.setter
      def redirect_action(self, value: Optional[pulumi.Input['AlbVirtualHostRouteHttpRouteRedirectActionArgs']]):
          pulumi.set(self, "redirect_action", value)
  
  
  @pulumi.input_type
  class AlbVirtualHostRouteHttpRouteDirectResponseActionArgs:
      def __init__(__self__, *,
                   body: Optional[pulumi.Input[str]] = None,
                   status: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] body: Response body text.
          :param pulumi.Input[int] status: The status of the response. Supported values are: ok, invalid_argumet, not_found, 
                 permission_denied, unauthenticated, unimplemented, internal, unavailable.
          """
          if body is not None:
              pulumi.set(__self__, "body", body)
          if status is not None:
              pulumi.set(__self__, "status", status)
  
      @property
      @pulumi.getter
      def body(self) -> Optional[pulumi.Input[str]]:
          """
          Response body text.
          """
          return pulumi.get(self, "body")
  
      @body.setter
      def body(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "body", value)
  
      @property
      @pulumi.getter
      def status(self) -> Optional[pulumi.Input[int]]:
          """
          The status of the response. Supported values are: ok, invalid_argumet, not_found, 
          permission_denied, unauthenticated, unimplemented, internal, unavailable.
          """
          return pulumi.get(self, "status")
  
      @status.setter
      def status(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "status", value)
  
  
  @pulumi.input_type
  class AlbVirtualHostRouteHttpRouteHttpMatchArgs:
      def __init__(__self__, *,
                   http_methods: Optional[pulumi.Input[Sequence[Any]]] = None,
                   path: Optional[pulumi.Input['AlbVirtualHostRouteHttpRouteHttpMatchPathArgs']] = None):
          """
          :param pulumi.Input[Sequence[Any]] http_methods: List of methods(strings).
          :param pulumi.Input['AlbVirtualHostRouteHttpRouteHttpMatchPathArgs'] path: If not set, '/' is assumed. The structure is documented below.
          """
          if http_methods is not None:
              pulumi.set(__self__, "http_methods", http_methods)
          if path is not None:
              pulumi.set(__self__, "path", path)
  
      @property
      @pulumi.getter(name="httpMethods")
      def http_methods(self) -> Optional[pulumi.Input[Sequence[Any]]]:
          """
          List of methods(strings).
          """
          return pulumi.get(self, "http_methods")
  
      @http_methods.setter
      def http_methods(self, value: Optional[pulumi.Input[Sequence[Any]]]):
          pulumi.set(self, "http_methods", value)
  
      @property
      @pulumi.getter
      def path(self) -> Optional[pulumi.Input['AlbVirtualHostRouteHttpRouteHttpMatchPathArgs']]:
          """
          If not set, '/' is assumed. The structure is documented below.
          """
          return pulumi.get(self, "path")
  
      @path.setter
      def path(self, value: Optional[pulumi.Input['AlbVirtualHostRouteHttpRouteHttpMatchPathArgs']]):
          pulumi.set(self, "path", value)
  
  
  @pulumi.input_type
  class AlbVirtualHostRouteHttpRouteHttpMatchPathArgs:
      def __init__(__self__, *,
                   exact: Optional[pulumi.Input[str]] = None,
                   prefix: Optional[pulumi.Input[str]] = None):
          if exact is not None:
              pulumi.set(__self__, "exact", exact)
          if prefix is not None:
              pulumi.set(__self__, "prefix", prefix)
  
      @property
      @pulumi.getter
      def exact(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "exact")
  
      @exact.setter
      def exact(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "exact", value)
  
      @property
      @pulumi.getter
      def prefix(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "prefix")
  
      @prefix.setter
      def prefix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "prefix", value)
  
  
  @pulumi.input_type
  class AlbVirtualHostRouteHttpRouteHttpRouteActionArgs:
      def __init__(__self__, *,
                   backend_group_id: pulumi.Input[str],
                   auto_host_rewrite: Optional[pulumi.Input[bool]] = None,
                   host_rewrite: Optional[pulumi.Input[str]] = None,
                   idle_timeout: Optional[pulumi.Input[str]] = None,
                   prefix_rewrite: Optional[pulumi.Input[str]] = None,
                   timeout: Optional[pulumi.Input[str]] = None,
                   upgrade_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          :param pulumi.Input[str] backend_group_id: Backend group to route requests.
          :param pulumi.Input[bool] auto_host_rewrite: If set, will automatically rewrite host.
          :param pulumi.Input[str] host_rewrite: Host rewrite specifier.
          :param pulumi.Input[str] idle_timeout: Specifies the idle timeout (time without any data transfer for the active request) for the
                 route. It is useful for streaming scenarios - one should set idle_timeout to something meaningful and max_timeout
                 to the maximum time the stream is allowed to be alive. If not specified, there is no
                 per-route idle timeout.
          :param pulumi.Input[str] prefix_rewrite: If not empty, matched path prefix will be replaced by this value.
          :param pulumi.Input[str] timeout: Specifies the request timeout (overall time request processing is allowed to take) for the 
                 route. If not set, default is 60 seconds.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] upgrade_types: List of upgrade types. Only specified upgrade types will be allowed. For example, 
                 "websocket".
          """
          pulumi.set(__self__, "backend_group_id", backend_group_id)
          if auto_host_rewrite is not None:
              pulumi.set(__self__, "auto_host_rewrite", auto_host_rewrite)
          if host_rewrite is not None:
              pulumi.set(__self__, "host_rewrite", host_rewrite)
          if idle_timeout is not None:
              pulumi.set(__self__, "idle_timeout", idle_timeout)
          if prefix_rewrite is not None:
              pulumi.set(__self__, "prefix_rewrite", prefix_rewrite)
          if timeout is not None:
              pulumi.set(__self__, "timeout", timeout)
          if upgrade_types is not None:
              pulumi.set(__self__, "upgrade_types", upgrade_types)
  
      @property
      @pulumi.getter(name="backendGroupId")
      def backend_group_id(self) -> pulumi.Input[str]:
          """
          Backend group to route requests.
          """
          return pulumi.get(self, "backend_group_id")
  
      @backend_group_id.setter
      def backend_group_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "backend_group_id", value)
  
      @property
      @pulumi.getter(name="autoHostRewrite")
      def auto_host_rewrite(self) -> Optional[pulumi.Input[bool]]:
          """
          If set, will automatically rewrite host.
          """
          return pulumi.get(self, "auto_host_rewrite")
  
      @auto_host_rewrite.setter
      def auto_host_rewrite(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "auto_host_rewrite", value)
  
      @property
      @pulumi.getter(name="hostRewrite")
      def host_rewrite(self) -> Optional[pulumi.Input[str]]:
          """
          Host rewrite specifier.
          """
          return pulumi.get(self, "host_rewrite")
  
      @host_rewrite.setter
      def host_rewrite(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "host_rewrite", value)
  
      @property
      @pulumi.getter(name="idleTimeout")
      def idle_timeout(self) -> Optional[pulumi.Input[str]]:
          """
          Specifies the idle timeout (time without any data transfer for the active request) for the
          route. It is useful for streaming scenarios - one should set idle_timeout to something meaningful and max_timeout
          to the maximum time the stream is allowed to be alive. If not specified, there is no
          per-route idle timeout.
          """
          return pulumi.get(self, "idle_timeout")
  
      @idle_timeout.setter
      def idle_timeout(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "idle_timeout", value)
  
      @property
      @pulumi.getter(name="prefixRewrite")
      def prefix_rewrite(self) -> Optional[pulumi.Input[str]]:
          """
          If not empty, matched path prefix will be replaced by this value.
          """
          return pulumi.get(self, "prefix_rewrite")
  
      @prefix_rewrite.setter
      def prefix_rewrite(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "prefix_rewrite", value)
  
      @property
      @pulumi.getter
      def timeout(self) -> Optional[pulumi.Input[str]]:
          """
          Specifies the request timeout (overall time request processing is allowed to take) for the 
          route. If not set, default is 60 seconds.
          """
          return pulumi.get(self, "timeout")
  
      @timeout.setter
      def timeout(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "timeout", value)
  
      @property
      @pulumi.getter(name="upgradeTypes")
      def upgrade_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List of upgrade types. Only specified upgrade types will be allowed. For example, 
          "websocket".
          """
          return pulumi.get(self, "upgrade_types")
  
      @upgrade_types.setter
      def upgrade_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "upgrade_types", value)
  
  
  @pulumi.input_type
  class AlbVirtualHostRouteHttpRouteRedirectActionArgs:
      def __init__(__self__, *,
                   remove_query: Optional[pulumi.Input[bool]] = None,
                   replace_host: Optional[pulumi.Input[str]] = None,
                   replace_path: Optional[pulumi.Input[str]] = None,
                   replace_port: Optional[pulumi.Input[int]] = None,
                   replace_prefix: Optional[pulumi.Input[str]] = None,
                   replace_scheme: Optional[pulumi.Input[str]] = None,
                   response_code: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] replace_host: Replaces hostname.
          :param pulumi.Input[str] replace_path: Replace path.
          :param pulumi.Input[int] replace_port: Replaces port.
          :param pulumi.Input[str] replace_prefix: Replace only matched prefix. Example:<br/> match:{ prefix_match: "/some" } <br/> 
                 redirect: { replace_prefix: "/other" } <br/> will redirect "/something" to "/otherthing".
          :param pulumi.Input[str] replace_scheme: Replaces scheme. If the original scheme is `http` or `https`, will also remove the 
                 80 or 443 port, if present.
          :param pulumi.Input[str] response_code: The HTTP status code to use in the redirect response. Supported values are: 
                 moved_permanently, found, see_other, temporary_redirect, permanent_redirect.
          """
          if remove_query is not None:
              pulumi.set(__self__, "remove_query", remove_query)
          if replace_host is not None:
              pulumi.set(__self__, "replace_host", replace_host)
          if replace_path is not None:
              pulumi.set(__self__, "replace_path", replace_path)
          if replace_port is not None:
              pulumi.set(__self__, "replace_port", replace_port)
          if replace_prefix is not None:
              pulumi.set(__self__, "replace_prefix", replace_prefix)
          if replace_scheme is not None:
              pulumi.set(__self__, "replace_scheme", replace_scheme)
          if response_code is not None:
              pulumi.set(__self__, "response_code", response_code)
  
      @property
      @pulumi.getter(name="removeQuery")
      def remove_query(self) -> Optional[pulumi.Input[bool]]:
          return pulumi.get(self, "remove_query")
  
      @remove_query.setter
      def remove_query(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "remove_query", value)
  
      @property
      @pulumi.getter(name="replaceHost")
      def replace_host(self) -> Optional[pulumi.Input[str]]:
          """
          Replaces hostname.
          """
          return pulumi.get(self, "replace_host")
  
      @replace_host.setter
      def replace_host(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "replace_host", value)
  
      @property
      @pulumi.getter(name="replacePath")
      def replace_path(self) -> Optional[pulumi.Input[str]]:
          """
          Replace path.
          """
          return pulumi.get(self, "replace_path")
  
      @replace_path.setter
      def replace_path(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "replace_path", value)
  
      @property
      @pulumi.getter(name="replacePort")
      def replace_port(self) -> Optional[pulumi.Input[int]]:
          """
          Replaces port.
          """
          return pulumi.get(self, "replace_port")
  
      @replace_port.setter
      def replace_port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "replace_port", value)
  
      @property
      @pulumi.getter(name="replacePrefix")
      def replace_prefix(self) -> Optional[pulumi.Input[str]]:
          """
          Replace only matched prefix. Example:<br/> match:{ prefix_match: "/some" } <br/> 
          redirect: { replace_prefix: "/other" } <br/> will redirect "/something" to "/otherthing".
          """
          return pulumi.get(self, "replace_prefix")
  
      @replace_prefix.setter
      def replace_prefix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "replace_prefix", value)
  
      @property
      @pulumi.getter(name="replaceScheme")
      def replace_scheme(self) -> Optional[pulumi.Input[str]]:
          """
          Replaces scheme. If the original scheme is `http` or `https`, will also remove the 
          80 or 443 port, if present.
          """
          return pulumi.get(self, "replace_scheme")
  
      @replace_scheme.setter
      def replace_scheme(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "replace_scheme", value)
  
      @property
      @pulumi.getter(name="responseCode")
      def response_code(self) -> Optional[pulumi.Input[str]]:
          """
          The HTTP status code to use in the redirect response. Supported values are: 
          moved_permanently, found, see_other, temporary_redirect, permanent_redirect.
          """
          return pulumi.get(self, "response_code")
  
      @response_code.setter
      def response_code(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "response_code", value)
  
  
  @pulumi.input_type
  class ComputeDiskDiskPlacementPolicyArgs:
      def __init__(__self__, *,
                   disk_placement_group_id: pulumi.Input[str]):
          """
          :param pulumi.Input[str] disk_placement_group_id: Specifies Disk Placement Group id.
          """
          pulumi.set(__self__, "disk_placement_group_id", disk_placement_group_id)
  
      @property
      @pulumi.getter(name="diskPlacementGroupId")
      def disk_placement_group_id(self) -> pulumi.Input[str]:
          """
          Specifies Disk Placement Group id.
          """
          return pulumi.get(self, "disk_placement_group_id")
  
      @disk_placement_group_id.setter
      def disk_placement_group_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "disk_placement_group_id", value)
  
  
  @pulumi.input_type
  class ComputeInstanceBootDiskArgs:
      def __init__(__self__, *,
                   auto_delete: Optional[pulumi.Input[bool]] = None,
                   device_name: Optional[pulumi.Input[str]] = None,
                   disk_id: Optional[pulumi.Input[str]] = None,
                   initialize_params: Optional[pulumi.Input['ComputeInstanceBootDiskInitializeParamsArgs']] = None,
                   mode: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[bool] auto_delete: Whether the disk is auto-deleted when the instance
                 is deleted. The default value is false.
          :param pulumi.Input[str] device_name: Name that can be used to access an attached disk
                 under `/dev/disk/by-id/`.
          :param pulumi.Input[str] disk_id: ID of the disk that is attached to the instance.
          :param pulumi.Input['ComputeInstanceBootDiskInitializeParamsArgs'] initialize_params: Parameters for a new disk that will be created
                 alongside the new instance. Either `initialize_params` or `disk_id` must be set. The structure is documented below.
          :param pulumi.Input[str] mode: Type of access to the disk resource. By default, a disk is attached in `READ_WRITE` mode.
          """
          if auto_delete is not None:
              pulumi.set(__self__, "auto_delete", auto_delete)
          if device_name is not None:
              pulumi.set(__self__, "device_name", device_name)
          if disk_id is not None:
              pulumi.set(__self__, "disk_id", disk_id)
          if initialize_params is not None:
              pulumi.set(__self__, "initialize_params", initialize_params)
          if mode is not None:
              pulumi.set(__self__, "mode", mode)
  
      @property
      @pulumi.getter(name="autoDelete")
      def auto_delete(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether the disk is auto-deleted when the instance
          is deleted. The default value is false.
          """
          return pulumi.get(self, "auto_delete")
  
      @auto_delete.setter
      def auto_delete(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "auto_delete", value)
  
      @property
      @pulumi.getter(name="deviceName")
      def device_name(self) -> Optional[pulumi.Input[str]]:
          """
          Name that can be used to access an attached disk
          under `/dev/disk/by-id/`.
          """
          return pulumi.get(self, "device_name")
  
      @device_name.setter
      def device_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "device_name", value)
  
      @property
      @pulumi.getter(name="diskId")
      def disk_id(self) -> Optional[pulumi.Input[str]]:
          """
          ID of the disk that is attached to the instance.
          """
          return pulumi.get(self, "disk_id")
  
      @disk_id.setter
      def disk_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "disk_id", value)
  
      @property
      @pulumi.getter(name="initializeParams")
      def initialize_params(self) -> Optional[pulumi.Input['ComputeInstanceBootDiskInitializeParamsArgs']]:
          """
          Parameters for a new disk that will be created
          alongside the new instance. Either `initialize_params` or `disk_id` must be set. The structure is documented below.
          """
          return pulumi.get(self, "initialize_params")
  
      @initialize_params.setter
      def initialize_params(self, value: Optional[pulumi.Input['ComputeInstanceBootDiskInitializeParamsArgs']]):
          pulumi.set(self, "initialize_params", value)
  
      @property
      @pulumi.getter
      def mode(self) -> Optional[pulumi.Input[str]]:
          """
          Type of access to the disk resource. By default, a disk is attached in `READ_WRITE` mode.
          """
          return pulumi.get(self, "mode")
  
      @mode.setter
      def mode(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "mode", value)
  
  
  @pulumi.input_type
  class ComputeInstanceBootDiskInitializeParamsArgs:
      def __init__(__self__, *,
                   description: Optional[pulumi.Input[str]] = None,
                   image_id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   size: Optional[pulumi.Input[int]] = None,
                   snapshot_id: Optional[pulumi.Input[str]] = None,
                   type: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] description: Description of the boot disk.
          :param pulumi.Input[str] image_id: A disk image to initialize this disk from.
          :param pulumi.Input[str] name: Name of the boot disk.
          :param pulumi.Input[int] size: Size of the disk in GB.
          :param pulumi.Input[str] snapshot_id: A snapshot to initialize this disk from.
          :param pulumi.Input[str] type: Disk type.
          """
          if description is not None:
              pulumi.set(__self__, "description", description)
          if image_id is not None:
              pulumi.set(__self__, "image_id", image_id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if size is not None:
              pulumi.set(__self__, "size", size)
          if snapshot_id is not None:
              pulumi.set(__self__, "snapshot_id", snapshot_id)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[pulumi.Input[str]]:
          """
          Description of the boot disk.
          """
          return pulumi.get(self, "description")
  
      @description.setter
      def description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "description", value)
  
      @property
      @pulumi.getter(name="imageId")
      def image_id(self) -> Optional[pulumi.Input[str]]:
          """
          A disk image to initialize this disk from.
          """
          return pulumi.get(self, "image_id")
  
      @image_id.setter
      def image_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "image_id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name of the boot disk.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def size(self) -> Optional[pulumi.Input[int]]:
          """
          Size of the disk in GB.
          """
          return pulumi.get(self, "size")
  
      @size.setter
      def size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "size", value)
  
      @property
      @pulumi.getter(name="snapshotId")
      def snapshot_id(self) -> Optional[pulumi.Input[str]]:
          """
          A snapshot to initialize this disk from.
          """
          return pulumi.get(self, "snapshot_id")
  
      @snapshot_id.setter
      def snapshot_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "snapshot_id", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Disk type.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupAllocationPolicyArgs:
      def __init__(__self__, *,
                   zones: pulumi.Input[Sequence[pulumi.Input[str]]]):
          """
          :param pulumi.Input[Sequence[pulumi.Input[str]]] zones: A list of availability zones.
          """
          pulumi.set(__self__, "zones", zones)
  
      @property
      @pulumi.getter
      def zones(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          """
          A list of availability zones.
          """
          return pulumi.get(self, "zones")
  
      @zones.setter
      def zones(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "zones", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupApplicationLoadBalancerArgs:
      def __init__(__self__, *,
                   max_opening_traffic_duration: Optional[pulumi.Input[int]] = None,
                   status_message: Optional[pulumi.Input[str]] = None,
                   target_group_description: Optional[pulumi.Input[str]] = None,
                   target_group_id: Optional[pulumi.Input[str]] = None,
                   target_group_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   target_group_name: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[int] max_opening_traffic_duration: Timeout for waiting for the VM to be checked by the load balancer. If the timeout is exceeded, the VM will be turned off based on the deployment policy. Specified in seconds.
          :param pulumi.Input[str] status_message: The status message of the instance.
          :param pulumi.Input[str] target_group_description: A description of the target group.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] target_group_labels: A set of key/value label pairs.
          :param pulumi.Input[str] target_group_name: The name of the target group.
          """
          if max_opening_traffic_duration is not None:
              pulumi.set(__self__, "max_opening_traffic_duration", max_opening_traffic_duration)
          if status_message is not None:
              pulumi.set(__self__, "status_message", status_message)
          if target_group_description is not None:
              pulumi.set(__self__, "target_group_description", target_group_description)
          if target_group_id is not None:
              pulumi.set(__self__, "target_group_id", target_group_id)
          if target_group_labels is not None:
              pulumi.set(__self__, "target_group_labels", target_group_labels)
          if target_group_name is not None:
              pulumi.set(__self__, "target_group_name", target_group_name)
  
      @property
      @pulumi.getter(name="maxOpeningTrafficDuration")
      def max_opening_traffic_duration(self) -> Optional[pulumi.Input[int]]:
          """
          Timeout for waiting for the VM to be checked by the load balancer. If the timeout is exceeded, the VM will be turned off based on the deployment policy. Specified in seconds.
          """
          return pulumi.get(self, "max_opening_traffic_duration")
  
      @max_opening_traffic_duration.setter
      def max_opening_traffic_duration(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_opening_traffic_duration", value)
  
      @property
      @pulumi.getter(name="statusMessage")
      def status_message(self) -> Optional[pulumi.Input[str]]:
          """
          The status message of the instance.
          """
          return pulumi.get(self, "status_message")
  
      @status_message.setter
      def status_message(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "status_message", value)
  
      @property
      @pulumi.getter(name="targetGroupDescription")
      def target_group_description(self) -> Optional[pulumi.Input[str]]:
          """
          A description of the target group.
          """
          return pulumi.get(self, "target_group_description")
  
      @target_group_description.setter
      def target_group_description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "target_group_description", value)
  
      @property
      @pulumi.getter(name="targetGroupId")
      def target_group_id(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "target_group_id")
  
      @target_group_id.setter
      def target_group_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "target_group_id", value)
  
      @property
      @pulumi.getter(name="targetGroupLabels")
      def target_group_labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          A set of key/value label pairs.
          """
          return pulumi.get(self, "target_group_labels")
  
      @target_group_labels.setter
      def target_group_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "target_group_labels", value)
  
      @property
      @pulumi.getter(name="targetGroupName")
      def target_group_name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the target group.
          """
          return pulumi.get(self, "target_group_name")
  
      @target_group_name.setter
      def target_group_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "target_group_name", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupDeployPolicyArgs:
      def __init__(__self__, *,
                   max_expansion: pulumi.Input[int],
                   max_unavailable: pulumi.Input[int],
                   max_creating: Optional[pulumi.Input[int]] = None,
                   max_deleting: Optional[pulumi.Input[int]] = None,
                   startup_duration: Optional[pulumi.Input[int]] = None,
                   strategy: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[int] max_expansion: The maximum number of instances that can be temporarily allocated above the group's target size
                 during the update process.
          :param pulumi.Input[int] max_unavailable: The maximum number of running instances that can be taken offline (stopped or deleted) at the same time
                 during the update process.
          :param pulumi.Input[int] max_creating: The maximum number of instances that can be created at the same time.
          :param pulumi.Input[int] max_deleting: The maximum number of instances that can be deleted at the same time.
          :param pulumi.Input[int] startup_duration: The amount of time in seconds to allow for an instance to start.
                 Instance will be considered up and running (and start receiving traffic) only after the startup_duration
                 has elapsed and all health checks are passed.
          :param pulumi.Input[str] strategy: Affects the lifecycle of the instance during deployment. If set to `proactive` (default), Instance Groups
                 can forcefully stop a running instance. If `opportunistic`, Instance Groups does not stop a running instance. Instead,
                 it will wait until the instance stops itself or becomes unhealthy.
          """
          pulumi.set(__self__, "max_expansion", max_expansion)
          pulumi.set(__self__, "max_unavailable", max_unavailable)
          if max_creating is not None:
              pulumi.set(__self__, "max_creating", max_creating)
          if max_deleting is not None:
              pulumi.set(__self__, "max_deleting", max_deleting)
          if startup_duration is not None:
              pulumi.set(__self__, "startup_duration", startup_duration)
          if strategy is not None:
              pulumi.set(__self__, "strategy", strategy)
  
      @property
      @pulumi.getter(name="maxExpansion")
      def max_expansion(self) -> pulumi.Input[int]:
          """
          The maximum number of instances that can be temporarily allocated above the group's target size
          during the update process.
          """
          return pulumi.get(self, "max_expansion")
  
      @max_expansion.setter
      def max_expansion(self, value: pulumi.Input[int]):
          pulumi.set(self, "max_expansion", value)
  
      @property
      @pulumi.getter(name="maxUnavailable")
      def max_unavailable(self) -> pulumi.Input[int]:
          """
          The maximum number of running instances that can be taken offline (stopped or deleted) at the same time
          during the update process.
          """
          return pulumi.get(self, "max_unavailable")
  
      @max_unavailable.setter
      def max_unavailable(self, value: pulumi.Input[int]):
          pulumi.set(self, "max_unavailable", value)
  
      @property
      @pulumi.getter(name="maxCreating")
      def max_creating(self) -> Optional[pulumi.Input[int]]:
          """
          The maximum number of instances that can be created at the same time.
          """
          return pulumi.get(self, "max_creating")
  
      @max_creating.setter
      def max_creating(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_creating", value)
  
      @property
      @pulumi.getter(name="maxDeleting")
      def max_deleting(self) -> Optional[pulumi.Input[int]]:
          """
          The maximum number of instances that can be deleted at the same time.
          """
          return pulumi.get(self, "max_deleting")
  
      @max_deleting.setter
      def max_deleting(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_deleting", value)
  
      @property
      @pulumi.getter(name="startupDuration")
      def startup_duration(self) -> Optional[pulumi.Input[int]]:
          """
          The amount of time in seconds to allow for an instance to start.
          Instance will be considered up and running (and start receiving traffic) only after the startup_duration
          has elapsed and all health checks are passed.
          """
          return pulumi.get(self, "startup_duration")
  
      @startup_duration.setter
      def startup_duration(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "startup_duration", value)
  
      @property
      @pulumi.getter
      def strategy(self) -> Optional[pulumi.Input[str]]:
          """
          Affects the lifecycle of the instance during deployment. If set to `proactive` (default), Instance Groups
          can forcefully stop a running instance. If `opportunistic`, Instance Groups does not stop a running instance. Instead,
          it will wait until the instance stops itself or becomes unhealthy.
          """
          return pulumi.get(self, "strategy")
  
      @strategy.setter
      def strategy(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "strategy", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupHealthCheckArgs:
      def __init__(__self__, *,
                   healthy_threshold: Optional[pulumi.Input[int]] = None,
                   http_options: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupHealthCheckHttpOptionArgs']]]] = None,
                   interval: Optional[pulumi.Input[int]] = None,
                   tcp_options: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupHealthCheckTcpOptionArgs']]]] = None,
                   timeout: Optional[pulumi.Input[int]] = None,
                   unhealthy_threshold: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] healthy_threshold: The number of successful health checks before the managed instance is declared healthy.
          :param pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupHealthCheckHttpOptionArgs']]] http_options: HTTP check options. The structure is documented below.
          :param pulumi.Input[int] interval: The interval to wait between health checks in seconds.
          :param pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupHealthCheckTcpOptionArgs']]] tcp_options: TCP check options. The structure is documented below.
          :param pulumi.Input[int] timeout: The length of time to wait for a response before the health check times out in seconds.
          :param pulumi.Input[int] unhealthy_threshold: The number of failed health checks before the managed instance is declared unhealthy.
          """
          if healthy_threshold is not None:
              pulumi.set(__self__, "healthy_threshold", healthy_threshold)
          if http_options is not None:
              pulumi.set(__self__, "http_options", http_options)
          if interval is not None:
              pulumi.set(__self__, "interval", interval)
          if tcp_options is not None:
              pulumi.set(__self__, "tcp_options", tcp_options)
          if timeout is not None:
              pulumi.set(__self__, "timeout", timeout)
          if unhealthy_threshold is not None:
              pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
  
      @property
      @pulumi.getter(name="healthyThreshold")
      def healthy_threshold(self) -> Optional[pulumi.Input[int]]:
          """
          The number of successful health checks before the managed instance is declared healthy.
          """
          return pulumi.get(self, "healthy_threshold")
  
      @healthy_threshold.setter
      def healthy_threshold(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "healthy_threshold", value)
  
      @property
      @pulumi.getter(name="httpOptions")
      def http_options(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupHealthCheckHttpOptionArgs']]]]:
          """
          HTTP check options. The structure is documented below.
          """
          return pulumi.get(self, "http_options")
  
      @http_options.setter
      def http_options(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupHealthCheckHttpOptionArgs']]]]):
          pulumi.set(self, "http_options", value)
  
      @property
      @pulumi.getter
      def interval(self) -> Optional[pulumi.Input[int]]:
          """
          The interval to wait between health checks in seconds.
          """
          return pulumi.get(self, "interval")
  
      @interval.setter
      def interval(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "interval", value)
  
      @property
      @pulumi.getter(name="tcpOptions")
      def tcp_options(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupHealthCheckTcpOptionArgs']]]]:
          """
          TCP check options. The structure is documented below.
          """
          return pulumi.get(self, "tcp_options")
  
      @tcp_options.setter
      def tcp_options(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupHealthCheckTcpOptionArgs']]]]):
          pulumi.set(self, "tcp_options", value)
  
      @property
      @pulumi.getter
      def timeout(self) -> Optional[pulumi.Input[int]]:
          """
          The length of time to wait for a response before the health check times out in seconds.
          """
          return pulumi.get(self, "timeout")
  
      @timeout.setter
      def timeout(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "timeout", value)
  
      @property
      @pulumi.getter(name="unhealthyThreshold")
      def unhealthy_threshold(self) -> Optional[pulumi.Input[int]]:
          """
          The number of failed health checks before the managed instance is declared unhealthy.
          """
          return pulumi.get(self, "unhealthy_threshold")
  
      @unhealthy_threshold.setter
      def unhealthy_threshold(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "unhealthy_threshold", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupHealthCheckHttpOptionArgs:
      def __init__(__self__, *,
                   path: pulumi.Input[str],
                   port: pulumi.Input[int]):
          """
          :param pulumi.Input[str] path: The URL path used for health check requests.
          :param pulumi.Input[int] port: The port used for TCP health checks.
          """
          pulumi.set(__self__, "path", path)
          pulumi.set(__self__, "port", port)
  
      @property
      @pulumi.getter
      def path(self) -> pulumi.Input[str]:
          """
          The URL path used for health check requests.
          """
          return pulumi.get(self, "path")
  
      @path.setter
      def path(self, value: pulumi.Input[str]):
          pulumi.set(self, "path", value)
  
      @property
      @pulumi.getter
      def port(self) -> pulumi.Input[int]:
          """
          The port used for TCP health checks.
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: pulumi.Input[int]):
          pulumi.set(self, "port", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupHealthCheckTcpOptionArgs:
      def __init__(__self__, *,
                   port: pulumi.Input[int]):
          """
          :param pulumi.Input[int] port: The port used for TCP health checks.
          """
          pulumi.set(__self__, "port", port)
  
      @property
      @pulumi.getter
      def port(self) -> pulumi.Input[int]:
          """
          The port used for TCP health checks.
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: pulumi.Input[int]):
          pulumi.set(self, "port", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupInstanceArgs:
      def __init__(__self__, *,
                   fqdn: Optional[pulumi.Input[str]] = None,
                   instance_id: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceNetworkInterfaceArgs']]]] = None,
                   status: Optional[pulumi.Input[str]] = None,
                   status_changed_at: Optional[pulumi.Input[str]] = None,
                   status_message: Optional[pulumi.Input[str]] = None,
                   zone_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] fqdn: DNS record fqdn (must have dot at the end).
          :param pulumi.Input[str] instance_id: The ID of the instance.
          :param pulumi.Input[str] name: Name template of the instance.  
                 In order to be unique it must contain at least one of instance unique placeholders:
                 {instance.short_id}
                 {instance.index}
                 combination of {instance.zone_id} and {instance.index_in_zone}
                 Example: my-instance-{instance.index}
                 If not set, default is used: {instance_group.id}-{instance.short_id}
                 It may also contain another placeholders, see metadata doc for full list.
          :param pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceNetworkInterfaceArgs']]] network_interfaces: Network specifications for the instance. This can be used multiple times for adding multiple interfaces. The structure is documented below.
          :param pulumi.Input[str] status: The status of the instance.
          :param pulumi.Input[str] status_message: The status message of the instance.
          :param pulumi.Input[str] zone_id: The ID of the availability zone where the instance resides.
          """
          if fqdn is not None:
              pulumi.set(__self__, "fqdn", fqdn)
          if instance_id is not None:
              pulumi.set(__self__, "instance_id", instance_id)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if network_interfaces is not None:
              pulumi.set(__self__, "network_interfaces", network_interfaces)
          if status is not None:
              pulumi.set(__self__, "status", status)
          if status_changed_at is not None:
              pulumi.set(__self__, "status_changed_at", status_changed_at)
          if status_message is not None:
              pulumi.set(__self__, "status_message", status_message)
          if zone_id is not None:
              pulumi.set(__self__, "zone_id", zone_id)
  
      @property
      @pulumi.getter
      def fqdn(self) -> Optional[pulumi.Input[str]]:
          """
          DNS record fqdn (must have dot at the end).
          """
          return pulumi.get(self, "fqdn")
  
      @fqdn.setter
      def fqdn(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "fqdn", value)
  
      @property
      @pulumi.getter(name="instanceId")
      def instance_id(self) -> Optional[pulumi.Input[str]]:
          """
          The ID of the instance.
          """
          return pulumi.get(self, "instance_id")
  
      @instance_id.setter
      def instance_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "instance_id", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name template of the instance.  
          In order to be unique it must contain at least one of instance unique placeholders:
          {instance.short_id}
          {instance.index}
          combination of {instance.zone_id} and {instance.index_in_zone}
          Example: my-instance-{instance.index}
          If not set, default is used: {instance_group.id}-{instance.short_id}
          It may also contain another placeholders, see metadata doc for full list.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="networkInterfaces")
      def network_interfaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceNetworkInterfaceArgs']]]]:
          """
          Network specifications for the instance. This can be used multiple times for adding multiple interfaces. The structure is documented below.
          """
          return pulumi.get(self, "network_interfaces")
  
      @network_interfaces.setter
      def network_interfaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceNetworkInterfaceArgs']]]]):
          pulumi.set(self, "network_interfaces", value)
  
      @property
      @pulumi.getter
      def status(self) -> Optional[pulumi.Input[str]]:
          """
          The status of the instance.
          """
          return pulumi.get(self, "status")
  
      @status.setter
      def status(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "status", value)
  
      @property
      @pulumi.getter(name="statusChangedAt")
      def status_changed_at(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "status_changed_at")
  
      @status_changed_at.setter
      def status_changed_at(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "status_changed_at", value)
  
      @property
      @pulumi.getter(name="statusMessage")
      def status_message(self) -> Optional[pulumi.Input[str]]:
          """
          The status message of the instance.
          """
          return pulumi.get(self, "status_message")
  
      @status_message.setter
      def status_message(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "status_message", value)
  
      @property
      @pulumi.getter(name="zoneId")
      def zone_id(self) -> Optional[pulumi.Input[str]]:
          """
          The ID of the availability zone where the instance resides.
          """
          return pulumi.get(self, "zone_id")
  
      @zone_id.setter
      def zone_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "zone_id", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupInstanceNetworkInterfaceArgs:
      def __init__(__self__, *,
                   index: Optional[pulumi.Input[int]] = None,
                   ip_address: Optional[pulumi.Input[str]] = None,
                   ipv4: Optional[pulumi.Input[bool]] = None,
                   ipv6: Optional[pulumi.Input[bool]] = None,
                   ipv6_address: Optional[pulumi.Input[str]] = None,
                   mac_address: Optional[pulumi.Input[str]] = None,
                   nat: Optional[pulumi.Input[bool]] = None,
                   nat_ip_address: Optional[pulumi.Input[str]] = None,
                   nat_ip_version: Optional[pulumi.Input[str]] = None,
                   subnet_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[int] index: The index of the network interface as generated by the server.
          :param pulumi.Input[str] ip_address: Manual set static IP address.
          :param pulumi.Input[bool] ipv4: True if IPv4 address allocated for the network interface.
          :param pulumi.Input[str] ipv6_address: Manual set static IPv6 address.
          :param pulumi.Input[str] mac_address: The MAC address assigned to the network interface.
          :param pulumi.Input[bool] nat: Flag for using NAT.
          :param pulumi.Input[str] nat_ip_address: A public address that can be used to access the internet over NAT. Use `variables` to set.
          :param pulumi.Input[str] nat_ip_version: The IP version for the public address.
          :param pulumi.Input[str] subnet_id: The ID of the subnet to attach this interface to. The subnet must reside in the same zone where this instance was created.
          """
          if index is not None:
              pulumi.set(__self__, "index", index)
          if ip_address is not None:
              pulumi.set(__self__, "ip_address", ip_address)
          if ipv4 is not None:
              pulumi.set(__self__, "ipv4", ipv4)
          if ipv6 is not None:
              pulumi.set(__self__, "ipv6", ipv6)
          if ipv6_address is not None:
              pulumi.set(__self__, "ipv6_address", ipv6_address)
          if mac_address is not None:
              pulumi.set(__self__, "mac_address", mac_address)
          if nat is not None:
              pulumi.set(__self__, "nat", nat)
          if nat_ip_address is not None:
              pulumi.set(__self__, "nat_ip_address", nat_ip_address)
          if nat_ip_version is not None:
              pulumi.set(__self__, "nat_ip_version", nat_ip_version)
          if subnet_id is not None:
              pulumi.set(__self__, "subnet_id", subnet_id)
  
      @property
      @pulumi.getter
      def index(self) -> Optional[pulumi.Input[int]]:
          """
          The index of the network interface as generated by the server.
          """
          return pulumi.get(self, "index")
  
      @index.setter
      def index(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "index", value)
  
      @property
      @pulumi.getter(name="ipAddress")
      def ip_address(self) -> Optional[pulumi.Input[str]]:
          """
          Manual set static IP address.
          """
          return pulumi.get(self, "ip_address")
  
      @ip_address.setter
      def ip_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "ip_address", value)
  
      @property
      @pulumi.getter
      def ipv4(self) -> Optional[pulumi.Input[bool]]:
          """
          True if IPv4 address allocated for the network interface.
          """
          return pulumi.get(self, "ipv4")
  
      @ipv4.setter
      def ipv4(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "ipv4", value)
  
      @property
      @pulumi.getter
      def ipv6(self) -> Optional[pulumi.Input[bool]]:
          return pulumi.get(self, "ipv6")
  
      @ipv6.setter
      def ipv6(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "ipv6", value)
  
      @property
      @pulumi.getter(name="ipv6Address")
      def ipv6_address(self) -> Optional[pulumi.Input[str]]:
          """
          Manual set static IPv6 address.
          """
          return pulumi.get(self, "ipv6_address")
  
      @ipv6_address.setter
      def ipv6_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "ipv6_address", value)
  
      @property
      @pulumi.getter(name="macAddress")
      def mac_address(self) -> Optional[pulumi.Input[str]]:
          """
          The MAC address assigned to the network interface.
          """
          return pulumi.get(self, "mac_address")
  
      @mac_address.setter
      def mac_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "mac_address", value)
  
      @property
      @pulumi.getter
      def nat(self) -> Optional[pulumi.Input[bool]]:
          """
          Flag for using NAT.
          """
          return pulumi.get(self, "nat")
  
      @nat.setter
      def nat(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "nat", value)
  
      @property
      @pulumi.getter(name="natIpAddress")
      def nat_ip_address(self) -> Optional[pulumi.Input[str]]:
          """
          A public address that can be used to access the internet over NAT. Use `variables` to set.
          """
          return pulumi.get(self, "nat_ip_address")
  
      @nat_ip_address.setter
      def nat_ip_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "nat_ip_address", value)
  
      @property
      @pulumi.getter(name="natIpVersion")
      def nat_ip_version(self) -> Optional[pulumi.Input[str]]:
          """
          The IP version for the public address.
          """
          return pulumi.get(self, "nat_ip_version")
  
      @nat_ip_version.setter
      def nat_ip_version(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "nat_ip_version", value)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> Optional[pulumi.Input[str]]:
          """
          The ID of the subnet to attach this interface to. The subnet must reside in the same zone where this instance was created.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "subnet_id", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupInstanceTemplateArgs:
      def __init__(__self__, *,
                   boot_disk: pulumi.Input['ComputeInstanceGroupInstanceTemplateBootDiskArgs'],
                   network_interfaces: pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkInterfaceArgs']]],
                   resources: pulumi.Input['ComputeInstanceGroupInstanceTemplateResourcesArgs'],
                   description: Optional[pulumi.Input[str]] = None,
                   hostname: Optional[pulumi.Input[str]] = None,
                   labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   network_settings: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkSettingArgs']]]] = None,
                   placement_policy: Optional[pulumi.Input['ComputeInstanceGroupInstanceTemplatePlacementPolicyArgs']] = None,
                   platform_id: Optional[pulumi.Input[str]] = None,
                   scheduling_policy: Optional[pulumi.Input['ComputeInstanceGroupInstanceTemplateSchedulingPolicyArgs']] = None,
                   secondary_disks: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateSecondaryDiskArgs']]]] = None,
                   service_account_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input['ComputeInstanceGroupInstanceTemplateBootDiskArgs'] boot_disk: Boot disk specifications for the instance. The structure is documented below.
          :param pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkInterfaceArgs']]] network_interfaces: Network specifications for the instance. This can be used multiple times for adding multiple interfaces. The structure is documented below.
          :param pulumi.Input['ComputeInstanceGroupInstanceTemplateResourcesArgs'] resources: Compute resource specifications for the instance. The structure is documented below.
          :param pulumi.Input[str] description: A description of the boot disk.
          :param pulumi.Input[str] hostname: Hostname template for the instance.   
                 This field is used to generate the FQDN value of instance.
                 The hostname must be unique within the network and region.
                 If not specified, the hostname will be equal to id of the instance
                 and FQDN will be `<id>.auto.internal`. Otherwise FQDN will be `<hostname>.<region_id>.internal`.
                 In order to be unique it must contain at least on of instance unique placeholders:
                 {instance.short_id}
                 {instance.index}
                 combination of {instance.zone_id} and {instance.index_in_zone}
                 Example: my-instance-{instance.index}
                 If not set, `name` value will be used
                 It may also contain another placeholders, see metadata doc for full list.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: A map of labels of metric.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] metadata: A set of metadata key/value pairs to make available from within the instance.
          :param pulumi.Input[str] name: Name template of the instance.  
                 In order to be unique it must contain at least one of instance unique placeholders:
                 {instance.short_id}
                 {instance.index}
                 combination of {instance.zone_id} and {instance.index_in_zone}
                 Example: my-instance-{instance.index}
                 If not set, default is used: {instance_group.id}-{instance.short_id}
                 It may also contain another placeholders, see metadata doc for full list.
          :param pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkSettingArgs']]] network_settings: Network acceleration type for instance. The structure is documented below.
          :param pulumi.Input['ComputeInstanceGroupInstanceTemplatePlacementPolicyArgs'] placement_policy: The placement policy configuration. The structure is documented below.
          :param pulumi.Input[str] platform_id: The ID of the hardware platform configuration for the instance. The default is 'standard-v1'.
          :param pulumi.Input['ComputeInstanceGroupInstanceTemplateSchedulingPolicyArgs'] scheduling_policy: The scheduling policy configuration. The structure is documented below.
          :param pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateSecondaryDiskArgs']]] secondary_disks: A list of disks to attach to the instance. The structure is documented below.
          :param pulumi.Input[str] service_account_id: The ID of the service account authorized for this instance.
          """
          pulumi.set(__self__, "boot_disk", boot_disk)
          pulumi.set(__self__, "network_interfaces", network_interfaces)
          pulumi.set(__self__, "resources", resources)
          if description is not None:
              pulumi.set(__self__, "description", description)
          if hostname is not None:
              pulumi.set(__self__, "hostname", hostname)
          if labels is not None:
              pulumi.set(__self__, "labels", labels)
          if metadata is not None:
              pulumi.set(__self__, "metadata", metadata)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if network_settings is not None:
              pulumi.set(__self__, "network_settings", network_settings)
          if placement_policy is not None:
              pulumi.set(__self__, "placement_policy", placement_policy)
          if platform_id is not None:
              pulumi.set(__self__, "platform_id", platform_id)
          if scheduling_policy is not None:
              pulumi.set(__self__, "scheduling_policy", scheduling_policy)
          if secondary_disks is not None:
              pulumi.set(__self__, "secondary_disks", secondary_disks)
          if service_account_id is not None:
              pulumi.set(__self__, "service_account_id", service_account_id)
  
      @property
      @pulumi.getter(name="bootDisk")
      def boot_disk(self) -> pulumi.Input['ComputeInstanceGroupInstanceTemplateBootDiskArgs']:
          """
          Boot disk specifications for the instance. The structure is documented below.
          """
          return pulumi.get(self, "boot_disk")
  
      @boot_disk.setter
      def boot_disk(self, value: pulumi.Input['ComputeInstanceGroupInstanceTemplateBootDiskArgs']):
          pulumi.set(self, "boot_disk", value)
  
      @property
      @pulumi.getter(name="networkInterfaces")
      def network_interfaces(self) -> pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkInterfaceArgs']]]:
          """
          Network specifications for the instance. This can be used multiple times for adding multiple interfaces. The structure is documented below.
          """
          return pulumi.get(self, "network_interfaces")
  
      @network_interfaces.setter
      def network_interfaces(self, value: pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkInterfaceArgs']]]):
          pulumi.set(self, "network_interfaces", value)
  
      @property
      @pulumi.getter
      def resources(self) -> pulumi.Input['ComputeInstanceGroupInstanceTemplateResourcesArgs']:
          """
          Compute resource specifications for the instance. The structure is documented below.
          """
          return pulumi.get(self, "resources")
  
      @resources.setter
      def resources(self, value: pulumi.Input['ComputeInstanceGroupInstanceTemplateResourcesArgs']):
          pulumi.set(self, "resources", value)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[pulumi.Input[str]]:
          """
          A description of the boot disk.
          """
          return pulumi.get(self, "description")
  
      @description.setter
      def description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "description", value)
  
      @property
      @pulumi.getter
      def hostname(self) -> Optional[pulumi.Input[str]]:
          """
          Hostname template for the instance.   
          This field is used to generate the FQDN value of instance.
          The hostname must be unique within the network and region.
          If not specified, the hostname will be equal to id of the instance
          and FQDN will be `<id>.auto.internal`. Otherwise FQDN will be `<hostname>.<region_id>.internal`.
          In order to be unique it must contain at least on of instance unique placeholders:
          {instance.short_id}
          {instance.index}
          combination of {instance.zone_id} and {instance.index_in_zone}
          Example: my-instance-{instance.index}
          If not set, `name` value will be used
          It may also contain another placeholders, see metadata doc for full list.
          """
          return pulumi.get(self, "hostname")
  
      @hostname.setter
      def hostname(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "hostname", value)
  
      @property
      @pulumi.getter
      def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          A map of labels of metric.
          """
          return pulumi.get(self, "labels")
  
      @labels.setter
      def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "labels", value)
  
      @property
      @pulumi.getter
      def metadata(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          A set of metadata key/value pairs to make available from within the instance.
          """
          return pulumi.get(self, "metadata")
  
      @metadata.setter
      def metadata(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "metadata", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Name template of the instance.  
          In order to be unique it must contain at least one of instance unique placeholders:
          {instance.short_id}
          {instance.index}
          combination of {instance.zone_id} and {instance.index_in_zone}
          Example: my-instance-{instance.index}
          If not set, default is used: {instance_group.id}-{instance.short_id}
          It may also contain another placeholders, see metadata doc for full list.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="networkSettings")
      def network_settings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkSettingArgs']]]]:
          """
          Network acceleration type for instance. The structure is documented below.
          """
          return pulumi.get(self, "network_settings")
  
      @network_settings.setter
      def network_settings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkSettingArgs']]]]):
          pulumi.set(self, "network_settings", value)
  
      @property
      @pulumi.getter(name="placementPolicy")
      def placement_policy(self) -> Optional[pulumi.Input['ComputeInstanceGroupInstanceTemplatePlacementPolicyArgs']]:
          """
          The placement policy configuration. The structure is documented below.
          """
          return pulumi.get(self, "placement_policy")
  
      @placement_policy.setter
      def placement_policy(self, value: Optional[pulumi.Input['ComputeInstanceGroupInstanceTemplatePlacementPolicyArgs']]):
          pulumi.set(self, "placement_policy", value)
  
      @property
      @pulumi.getter(name="platformId")
      def platform_id(self) -> Optional[pulumi.Input[str]]:
          """
          The ID of the hardware platform configuration for the instance. The default is 'standard-v1'.
          """
          return pulumi.get(self, "platform_id")
  
      @platform_id.setter
      def platform_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "platform_id", value)
  
      @property
      @pulumi.getter(name="schedulingPolicy")
      def scheduling_policy(self) -> Optional[pulumi.Input['ComputeInstanceGroupInstanceTemplateSchedulingPolicyArgs']]:
          """
          The scheduling policy configuration. The structure is documented below.
          """
          return pulumi.get(self, "scheduling_policy")
  
      @scheduling_policy.setter
      def scheduling_policy(self, value: Optional[pulumi.Input['ComputeInstanceGroupInstanceTemplateSchedulingPolicyArgs']]):
          pulumi.set(self, "scheduling_policy", value)
  
      @property
      @pulumi.getter(name="secondaryDisks")
      def secondary_disks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateSecondaryDiskArgs']]]]:
          """
          A list of disks to attach to the instance. The structure is documented below.
          """
          return pulumi.get(self, "secondary_disks")
  
      @secondary_disks.setter
      def secondary_disks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateSecondaryDiskArgs']]]]):
          pulumi.set(self, "secondary_disks", value)
  
      @property
      @pulumi.getter(name="serviceAccountId")
      def service_account_id(self) -> Optional[pulumi.Input[str]]:
          """
          The ID of the service account authorized for this instance.
          """
          return pulumi.get(self, "service_account_id")
  
      @service_account_id.setter
      def service_account_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "service_account_id", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupInstanceTemplateBootDiskArgs:
      def __init__(__self__, *,
                   device_name: Optional[pulumi.Input[str]] = None,
                   disk_id: Optional[pulumi.Input[str]] = None,
                   initialize_params: Optional[pulumi.Input['ComputeInstanceGroupInstanceTemplateBootDiskInitializeParamsArgs']] = None,
                   mode: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] device_name: This value can be used to reference the device under `/dev/disk/by-id/`.
          :param pulumi.Input[str] disk_id: ID of the existing disk. To set use variables.
          :param pulumi.Input['ComputeInstanceGroupInstanceTemplateBootDiskInitializeParamsArgs'] initialize_params: Parameters for creating a disk alongside the instance. The structure is documented below.
          :param pulumi.Input[str] mode: The access mode to the disk resource. By default a disk is attached in `READ_WRITE` mode.
          """
          if device_name is not None:
              pulumi.set(__self__, "device_name", device_name)
          if disk_id is not None:
              pulumi.set(__self__, "disk_id", disk_id)
          if initialize_params is not None:
              pulumi.set(__self__, "initialize_params", initialize_params)
          if mode is not None:
              pulumi.set(__self__, "mode", mode)
  
      @property
      @pulumi.getter(name="deviceName")
      def device_name(self) -> Optional[pulumi.Input[str]]:
          """
          This value can be used to reference the device under `/dev/disk/by-id/`.
          """
          return pulumi.get(self, "device_name")
  
      @device_name.setter
      def device_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "device_name", value)
  
      @property
      @pulumi.getter(name="diskId")
      def disk_id(self) -> Optional[pulumi.Input[str]]:
          """
          ID of the existing disk. To set use variables.
          """
          return pulumi.get(self, "disk_id")
  
      @disk_id.setter
      def disk_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "disk_id", value)
  
      @property
      @pulumi.getter(name="initializeParams")
      def initialize_params(self) -> Optional[pulumi.Input['ComputeInstanceGroupInstanceTemplateBootDiskInitializeParamsArgs']]:
          """
          Parameters for creating a disk alongside the instance. The structure is documented below.
          """
          return pulumi.get(self, "initialize_params")
  
      @initialize_params.setter
      def initialize_params(self, value: Optional[pulumi.Input['ComputeInstanceGroupInstanceTemplateBootDiskInitializeParamsArgs']]):
          pulumi.set(self, "initialize_params", value)
  
      @property
      @pulumi.getter
      def mode(self) -> Optional[pulumi.Input[str]]:
          """
          The access mode to the disk resource. By default a disk is attached in `READ_WRITE` mode.
          """
          return pulumi.get(self, "mode")
  
      @mode.setter
      def mode(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "mode", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupInstanceTemplateBootDiskInitializeParamsArgs:
      def __init__(__self__, *,
                   description: Optional[pulumi.Input[str]] = None,
                   image_id: Optional[pulumi.Input[str]] = None,
                   size: Optional[pulumi.Input[int]] = None,
                   snapshot_id: Optional[pulumi.Input[str]] = None,
                   type: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] description: A description of the boot disk.
          :param pulumi.Input[str] image_id: The disk image to initialize this disk from.
          :param pulumi.Input[int] size: The number of instances in the instance group.
          :param pulumi.Input[str] snapshot_id: The snapshot to initialize this disk from.
          :param pulumi.Input[str] type: Network acceleration type. By default a network is in `STANDARD` mode.
          """
          if description is not None:
              pulumi.set(__self__, "description", description)
          if image_id is not None:
              pulumi.set(__self__, "image_id", image_id)
          if size is not None:
              pulumi.set(__self__, "size", size)
          if snapshot_id is not None:
              pulumi.set(__self__, "snapshot_id", snapshot_id)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[pulumi.Input[str]]:
          """
          A description of the boot disk.
          """
          return pulumi.get(self, "description")
  
      @description.setter
      def description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "description", value)
  
      @property
      @pulumi.getter(name="imageId")
      def image_id(self) -> Optional[pulumi.Input[str]]:
          """
          The disk image to initialize this disk from.
          """
          return pulumi.get(self, "image_id")
  
      @image_id.setter
      def image_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "image_id", value)
  
      @property
      @pulumi.getter
      def size(self) -> Optional[pulumi.Input[int]]:
          """
          The number of instances in the instance group.
          """
          return pulumi.get(self, "size")
  
      @size.setter
      def size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "size", value)
  
      @property
      @pulumi.getter(name="snapshotId")
      def snapshot_id(self) -> Optional[pulumi.Input[str]]:
          """
          The snapshot to initialize this disk from.
          """
          return pulumi.get(self, "snapshot_id")
  
      @snapshot_id.setter
      def snapshot_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "snapshot_id", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Network acceleration type. By default a network is in `STANDARD` mode.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupInstanceTemplateNetworkInterfaceArgs:
      def __init__(__self__, *,
                   dns_records: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkInterfaceDnsRecordArgs']]]] = None,
                   ip_address: Optional[pulumi.Input[str]] = None,
                   ipv4: Optional[pulumi.Input[bool]] = None,
                   ipv6: Optional[pulumi.Input[bool]] = None,
                   ipv6_address: Optional[pulumi.Input[str]] = None,
                   ipv6_dns_records: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkInterfaceIpv6DnsRecordArgs']]]] = None,
                   nat: Optional[pulumi.Input[bool]] = None,
                   nat_dns_records: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkInterfaceNatDnsRecordArgs']]]] = None,
                   nat_ip_address: Optional[pulumi.Input[str]] = None,
                   network_id: Optional[pulumi.Input[str]] = None,
                   security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   subnet_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          :param pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkInterfaceDnsRecordArgs']]] dns_records: List of dns records.  The structure is documented below.
          :param pulumi.Input[str] ip_address: Manual set static IP address.
          :param pulumi.Input[bool] ipv4: True if IPv4 address allocated for the network interface.
          :param pulumi.Input[str] ipv6_address: Manual set static IPv6 address.
          :param pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkInterfaceIpv6DnsRecordArgs']]] ipv6_dns_records: List of ipv6 dns records.  The structure is documented below.
          :param pulumi.Input[bool] nat: Flag for using NAT.
          :param pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkInterfaceNatDnsRecordArgs']]] nat_dns_records: List of nat dns records.  The structure is documented below.
          :param pulumi.Input[str] nat_ip_address: A public address that can be used to access the internet over NAT. Use `variables` to set.
          :param pulumi.Input[str] network_id: The ID of the network.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] security_group_ids: Security group ids for network interface.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] subnet_ids: The ID of the subnets to attach this interface to.
          """
          if dns_records is not None:
              pulumi.set(__self__, "dns_records", dns_records)
          if ip_address is not None:
              pulumi.set(__self__, "ip_address", ip_address)
          if ipv4 is not None:
              pulumi.set(__self__, "ipv4", ipv4)
          if ipv6 is not None:
              pulumi.set(__self__, "ipv6", ipv6)
          if ipv6_address is not None:
              pulumi.set(__self__, "ipv6_address", ipv6_address)
          if ipv6_dns_records is not None:
              pulumi.set(__self__, "ipv6_dns_records", ipv6_dns_records)
          if nat is not None:
              pulumi.set(__self__, "nat", nat)
          if nat_dns_records is not None:
              pulumi.set(__self__, "nat_dns_records", nat_dns_records)
          if nat_ip_address is not None:
              pulumi.set(__self__, "nat_ip_address", nat_ip_address)
          if network_id is not None:
              pulumi.set(__self__, "network_id", network_id)
          if security_group_ids is not None:
              pulumi.set(__self__, "security_group_ids", security_group_ids)
          if subnet_ids is not None:
              pulumi.set(__self__, "subnet_ids", subnet_ids)
  
      @property
      @pulumi.getter(name="dnsRecords")
      def dns_records(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkInterfaceDnsRecordArgs']]]]:
          """
          List of dns records.  The structure is documented below.
          """
          return pulumi.get(self, "dns_records")
  
      @dns_records.setter
      def dns_records(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkInterfaceDnsRecordArgs']]]]):
          pulumi.set(self, "dns_records", value)
  
      @property
      @pulumi.getter(name="ipAddress")
      def ip_address(self) -> Optional[pulumi.Input[str]]:
          """
          Manual set static IP address.
          """
          return pulumi.get(self, "ip_address")
  
      @ip_address.setter
      def ip_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "ip_address", value)
  
      @property
      @pulumi.getter
      def ipv4(self) -> Optional[pulumi.Input[bool]]:
          """
          True if IPv4 address allocated for the network interface.
          """
          return pulumi.get(self, "ipv4")
  
      @ipv4.setter
      def ipv4(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "ipv4", value)
  
      @property
      @pulumi.getter
      def ipv6(self) -> Optional[pulumi.Input[bool]]:
          return pulumi.get(self, "ipv6")
  
      @ipv6.setter
      def ipv6(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "ipv6", value)
  
      @property
      @pulumi.getter(name="ipv6Address")
      def ipv6_address(self) -> Optional[pulumi.Input[str]]:
          """
          Manual set static IPv6 address.
          """
          return pulumi.get(self, "ipv6_address")
  
      @ipv6_address.setter
      def ipv6_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "ipv6_address", value)
  
      @property
      @pulumi.getter(name="ipv6DnsRecords")
      def ipv6_dns_records(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkInterfaceIpv6DnsRecordArgs']]]]:
          """
          List of ipv6 dns records.  The structure is documented below.
          """
          return pulumi.get(self, "ipv6_dns_records")
  
      @ipv6_dns_records.setter
      def ipv6_dns_records(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkInterfaceIpv6DnsRecordArgs']]]]):
          pulumi.set(self, "ipv6_dns_records", value)
  
      @property
      @pulumi.getter
      def nat(self) -> Optional[pulumi.Input[bool]]:
          """
          Flag for using NAT.
          """
          return pulumi.get(self, "nat")
  
      @nat.setter
      def nat(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "nat", value)
  
      @property
      @pulumi.getter(name="natDnsRecords")
      def nat_dns_records(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkInterfaceNatDnsRecordArgs']]]]:
          """
          List of nat dns records.  The structure is documented below.
          """
          return pulumi.get(self, "nat_dns_records")
  
      @nat_dns_records.setter
      def nat_dns_records(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupInstanceTemplateNetworkInterfaceNatDnsRecordArgs']]]]):
          pulumi.set(self, "nat_dns_records", value)
  
      @property
      @pulumi.getter(name="natIpAddress")
      def nat_ip_address(self) -> Optional[pulumi.Input[str]]:
          """
          A public address that can be used to access the internet over NAT. Use `variables` to set.
          """
          return pulumi.get(self, "nat_ip_address")
  
      @nat_ip_address.setter
      def nat_ip_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "nat_ip_address", value)
  
      @property
      @pulumi.getter(name="networkId")
      def network_id(self) -> Optional[pulumi.Input[str]]:
          """
          The ID of the network.
          """
          return pulumi.get(self, "network_id")
  
      @network_id.setter
      def network_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "network_id", value)
  
      @property
      @pulumi.getter(name="securityGroupIds")
      def security_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          Security group ids for network interface.
          """
          return pulumi.get(self, "security_group_ids")
  
      @security_group_ids.setter
      def security_group_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "security_group_ids", value)
  
      @property
      @pulumi.getter(name="subnetIds")
      def subnet_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          The ID of the subnets to attach this interface to.
          """
          return pulumi.get(self, "subnet_ids")
  
      @subnet_ids.setter
      def subnet_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "subnet_ids", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupInstanceTemplateNetworkInterfaceDnsRecordArgs:
      def __init__(__self__, *,
                   fqdn: pulumi.Input[str],
                   dns_zone_id: Optional[pulumi.Input[str]] = None,
                   ptr: Optional[pulumi.Input[bool]] = None,
                   ttl: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] fqdn: DNS record fqdn (must have dot at the end).
          :param pulumi.Input[str] dns_zone_id: DNS zone id (if not set, private zone used).
          :param pulumi.Input[bool] ptr: When set to true, also create PTR DNS record.
          :param pulumi.Input[int] ttl: DNS record TTL.
          """
          pulumi.set(__self__, "fqdn", fqdn)
          if dns_zone_id is not None:
              pulumi.set(__self__, "dns_zone_id", dns_zone_id)
          if ptr is not None:
              pulumi.set(__self__, "ptr", ptr)
          if ttl is not None:
              pulumi.set(__self__, "ttl", ttl)
  
      @property
      @pulumi.getter
      def fqdn(self) -> pulumi.Input[str]:
          """
          DNS record fqdn (must have dot at the end).
          """
          return pulumi.get(self, "fqdn")
  
      @fqdn.setter
      def fqdn(self, value: pulumi.Input[str]):
          pulumi.set(self, "fqdn", value)
  
      @property
      @pulumi.getter(name="dnsZoneId")
      def dns_zone_id(self) -> Optional[pulumi.Input[str]]:
          """
          DNS zone id (if not set, private zone used).
          """
          return pulumi.get(self, "dns_zone_id")
  
      @dns_zone_id.setter
      def dns_zone_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "dns_zone_id", value)
  
      @property
      @pulumi.getter
      def ptr(self) -> Optional[pulumi.Input[bool]]:
          """
          When set to true, also create PTR DNS record.
          """
          return pulumi.get(self, "ptr")
  
      @ptr.setter
      def ptr(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "ptr", value)
  
      @property
      @pulumi.getter
      def ttl(self) -> Optional[pulumi.Input[int]]:
          """
          DNS record TTL.
          """
          return pulumi.get(self, "ttl")
  
      @ttl.setter
      def ttl(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "ttl", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupInstanceTemplateNetworkInterfaceIpv6DnsRecordArgs:
      def __init__(__self__, *,
                   fqdn: pulumi.Input[str],
                   dns_zone_id: Optional[pulumi.Input[str]] = None,
                   ptr: Optional[pulumi.Input[bool]] = None,
                   ttl: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] fqdn: DNS record fqdn (must have dot at the end).
          :param pulumi.Input[str] dns_zone_id: DNS zone id (if not set, private zone used).
          :param pulumi.Input[bool] ptr: When set to true, also create PTR DNS record.
          :param pulumi.Input[int] ttl: DNS record TTL.
          """
          pulumi.set(__self__, "fqdn", fqdn)
          if dns_zone_id is not None:
              pulumi.set(__self__, "dns_zone_id", dns_zone_id)
          if ptr is not None:
              pulumi.set(__self__, "ptr", ptr)
          if ttl is not None:
              pulumi.set(__self__, "ttl", ttl)
  
      @property
      @pulumi.getter
      def fqdn(self) -> pulumi.Input[str]:
          """
          DNS record fqdn (must have dot at the end).
          """
          return pulumi.get(self, "fqdn")
  
      @fqdn.setter
      def fqdn(self, value: pulumi.Input[str]):
          pulumi.set(self, "fqdn", value)
  
      @property
      @pulumi.getter(name="dnsZoneId")
      def dns_zone_id(self) -> Optional[pulumi.Input[str]]:
          """
          DNS zone id (if not set, private zone used).
          """
          return pulumi.get(self, "dns_zone_id")
  
      @dns_zone_id.setter
      def dns_zone_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "dns_zone_id", value)
  
      @property
      @pulumi.getter
      def ptr(self) -> Optional[pulumi.Input[bool]]:
          """
          When set to true, also create PTR DNS record.
          """
          return pulumi.get(self, "ptr")
  
      @ptr.setter
      def ptr(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "ptr", value)
  
      @property
      @pulumi.getter
      def ttl(self) -> Optional[pulumi.Input[int]]:
          """
          DNS record TTL.
          """
          return pulumi.get(self, "ttl")
  
      @ttl.setter
      def ttl(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "ttl", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupInstanceTemplateNetworkInterfaceNatDnsRecordArgs:
      def __init__(__self__, *,
                   fqdn: pulumi.Input[str],
                   dns_zone_id: Optional[pulumi.Input[str]] = None,
                   ptr: Optional[pulumi.Input[bool]] = None,
                   ttl: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] fqdn: DNS record fqdn (must have dot at the end).
          :param pulumi.Input[str] dns_zone_id: DNS zone id (if not set, private zone used).
          :param pulumi.Input[bool] ptr: When set to true, also create PTR DNS record.
          :param pulumi.Input[int] ttl: DNS record TTL.
          """
          pulumi.set(__self__, "fqdn", fqdn)
          if dns_zone_id is not None:
              pulumi.set(__self__, "dns_zone_id", dns_zone_id)
          if ptr is not None:
              pulumi.set(__self__, "ptr", ptr)
          if ttl is not None:
              pulumi.set(__self__, "ttl", ttl)
  
      @property
      @pulumi.getter
      def fqdn(self) -> pulumi.Input[str]:
          """
          DNS record fqdn (must have dot at the end).
          """
          return pulumi.get(self, "fqdn")
  
      @fqdn.setter
      def fqdn(self, value: pulumi.Input[str]):
          pulumi.set(self, "fqdn", value)
  
      @property
      @pulumi.getter(name="dnsZoneId")
      def dns_zone_id(self) -> Optional[pulumi.Input[str]]:
          """
          DNS zone id (if not set, private zone used).
          """
          return pulumi.get(self, "dns_zone_id")
  
      @dns_zone_id.setter
      def dns_zone_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "dns_zone_id", value)
  
      @property
      @pulumi.getter
      def ptr(self) -> Optional[pulumi.Input[bool]]:
          """
          When set to true, also create PTR DNS record.
          """
          return pulumi.get(self, "ptr")
  
      @ptr.setter
      def ptr(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "ptr", value)
  
      @property
      @pulumi.getter
      def ttl(self) -> Optional[pulumi.Input[int]]:
          """
          DNS record TTL.
          """
          return pulumi.get(self, "ttl")
  
      @ttl.setter
      def ttl(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "ttl", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupInstanceTemplateNetworkSettingArgs:
      def __init__(__self__, *,
                   type: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] type: Network acceleration type. By default a network is in `STANDARD` mode.
          """
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Network acceleration type. By default a network is in `STANDARD` mode.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupInstanceTemplatePlacementPolicyArgs:
      def __init__(__self__, *,
                   placement_group_id: pulumi.Input[str]):
          """
          :param pulumi.Input[str] placement_group_id: Specifies the id of the Placement Group to assign to the instances.
          """
          pulumi.set(__self__, "placement_group_id", placement_group_id)
  
      @property
      @pulumi.getter(name="placementGroupId")
      def placement_group_id(self) -> pulumi.Input[str]:
          """
          Specifies the id of the Placement Group to assign to the instances.
          """
          return pulumi.get(self, "placement_group_id")
  
      @placement_group_id.setter
      def placement_group_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "placement_group_id", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupInstanceTemplateResourcesArgs:
      def __init__(__self__, *,
                   cores: pulumi.Input[int],
                   memory: pulumi.Input[float],
                   core_fraction: Optional[pulumi.Input[int]] = None,
                   gpus: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] cores: The number of CPU cores for the instance.
          :param pulumi.Input[float] memory: The memory size in GB.
          :param pulumi.Input[int] core_fraction: If provided, specifies baseline core performance as a percent.
          """
          pulumi.set(__self__, "cores", cores)
          pulumi.set(__self__, "memory", memory)
          if core_fraction is not None:
              pulumi.set(__self__, "core_fraction", core_fraction)
          if gpus is not None:
              pulumi.set(__self__, "gpus", gpus)
  
      @property
      @pulumi.getter
      def cores(self) -> pulumi.Input[int]:
          """
          The number of CPU cores for the instance.
          """
          return pulumi.get(self, "cores")
  
      @cores.setter
      def cores(self, value: pulumi.Input[int]):
          pulumi.set(self, "cores", value)
  
      @property
      @pulumi.getter
      def memory(self) -> pulumi.Input[float]:
          """
          The memory size in GB.
          """
          return pulumi.get(self, "memory")
  
      @memory.setter
      def memory(self, value: pulumi.Input[float]):
          pulumi.set(self, "memory", value)
  
      @property
      @pulumi.getter(name="coreFraction")
      def core_fraction(self) -> Optional[pulumi.Input[int]]:
          """
          If provided, specifies baseline core performance as a percent.
          """
          return pulumi.get(self, "core_fraction")
  
      @core_fraction.setter
      def core_fraction(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "core_fraction", value)
  
      @property
      @pulumi.getter
      def gpus(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "gpus")
  
      @gpus.setter
      def gpus(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "gpus", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupInstanceTemplateSchedulingPolicyArgs:
      def __init__(__self__, *,
                   preemptible: Optional[pulumi.Input[bool]] = None):
          """
          :param pulumi.Input[bool] preemptible: Specifies if the instance is preemptible. Defaults to false.
          """
          if preemptible is not None:
              pulumi.set(__self__, "preemptible", preemptible)
  
      @property
      @pulumi.getter
      def preemptible(self) -> Optional[pulumi.Input[bool]]:
          """
          Specifies if the instance is preemptible. Defaults to false.
          """
          return pulumi.get(self, "preemptible")
  
      @preemptible.setter
      def preemptible(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "preemptible", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupInstanceTemplateSecondaryDiskArgs:
      def __init__(__self__, *,
                   device_name: Optional[pulumi.Input[str]] = None,
                   disk_id: Optional[pulumi.Input[str]] = None,
                   initialize_params: Optional[pulumi.Input['ComputeInstanceGroupInstanceTemplateSecondaryDiskInitializeParamsArgs']] = None,
                   mode: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] device_name: This value can be used to reference the device under `/dev/disk/by-id/`.
          :param pulumi.Input[str] disk_id: ID of the existing disk. To set use variables.
          :param pulumi.Input['ComputeInstanceGroupInstanceTemplateSecondaryDiskInitializeParamsArgs'] initialize_params: Parameters for creating a disk alongside the instance. The structure is documented below.
          :param pulumi.Input[str] mode: The access mode to the disk resource. By default a disk is attached in `READ_WRITE` mode.
          """
          if device_name is not None:
              pulumi.set(__self__, "device_name", device_name)
          if disk_id is not None:
              pulumi.set(__self__, "disk_id", disk_id)
          if initialize_params is not None:
              pulumi.set(__self__, "initialize_params", initialize_params)
          if mode is not None:
              pulumi.set(__self__, "mode", mode)
  
      @property
      @pulumi.getter(name="deviceName")
      def device_name(self) -> Optional[pulumi.Input[str]]:
          """
          This value can be used to reference the device under `/dev/disk/by-id/`.
          """
          return pulumi.get(self, "device_name")
  
      @device_name.setter
      def device_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "device_name", value)
  
      @property
      @pulumi.getter(name="diskId")
      def disk_id(self) -> Optional[pulumi.Input[str]]:
          """
          ID of the existing disk. To set use variables.
          """
          return pulumi.get(self, "disk_id")
  
      @disk_id.setter
      def disk_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "disk_id", value)
  
      @property
      @pulumi.getter(name="initializeParams")
      def initialize_params(self) -> Optional[pulumi.Input['ComputeInstanceGroupInstanceTemplateSecondaryDiskInitializeParamsArgs']]:
          """
          Parameters for creating a disk alongside the instance. The structure is documented below.
          """
          return pulumi.get(self, "initialize_params")
  
      @initialize_params.setter
      def initialize_params(self, value: Optional[pulumi.Input['ComputeInstanceGroupInstanceTemplateSecondaryDiskInitializeParamsArgs']]):
          pulumi.set(self, "initialize_params", value)
  
      @property
      @pulumi.getter
      def mode(self) -> Optional[pulumi.Input[str]]:
          """
          The access mode to the disk resource. By default a disk is attached in `READ_WRITE` mode.
          """
          return pulumi.get(self, "mode")
  
      @mode.setter
      def mode(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "mode", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupInstanceTemplateSecondaryDiskInitializeParamsArgs:
      def __init__(__self__, *,
                   description: Optional[pulumi.Input[str]] = None,
                   image_id: Optional[pulumi.Input[str]] = None,
                   size: Optional[pulumi.Input[int]] = None,
                   snapshot_id: Optional[pulumi.Input[str]] = None,
                   type: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] description: A description of the boot disk.
          :param pulumi.Input[str] image_id: The disk image to initialize this disk from.
          :param pulumi.Input[int] size: The number of instances in the instance group.
          :param pulumi.Input[str] snapshot_id: The snapshot to initialize this disk from.
          :param pulumi.Input[str] type: Network acceleration type. By default a network is in `STANDARD` mode.
          """
          if description is not None:
              pulumi.set(__self__, "description", description)
          if image_id is not None:
              pulumi.set(__self__, "image_id", image_id)
          if size is not None:
              pulumi.set(__self__, "size", size)
          if snapshot_id is not None:
              pulumi.set(__self__, "snapshot_id", snapshot_id)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[pulumi.Input[str]]:
          """
          A description of the boot disk.
          """
          return pulumi.get(self, "description")
  
      @description.setter
      def description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "description", value)
  
      @property
      @pulumi.getter(name="imageId")
      def image_id(self) -> Optional[pulumi.Input[str]]:
          """
          The disk image to initialize this disk from.
          """
          return pulumi.get(self, "image_id")
  
      @image_id.setter
      def image_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "image_id", value)
  
      @property
      @pulumi.getter
      def size(self) -> Optional[pulumi.Input[int]]:
          """
          The number of instances in the instance group.
          """
          return pulumi.get(self, "size")
  
      @size.setter
      def size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "size", value)
  
      @property
      @pulumi.getter(name="snapshotId")
      def snapshot_id(self) -> Optional[pulumi.Input[str]]:
          """
          The snapshot to initialize this disk from.
          """
          return pulumi.get(self, "snapshot_id")
  
      @snapshot_id.setter
      def snapshot_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "snapshot_id", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Network acceleration type. By default a network is in `STANDARD` mode.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupLoadBalancerArgs:
      def __init__(__self__, *,
                   max_opening_traffic_duration: Optional[pulumi.Input[int]] = None,
                   status_message: Optional[pulumi.Input[str]] = None,
                   target_group_description: Optional[pulumi.Input[str]] = None,
                   target_group_id: Optional[pulumi.Input[str]] = None,
                   target_group_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   target_group_name: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[int] max_opening_traffic_duration: Timeout for waiting for the VM to be checked by the load balancer. If the timeout is exceeded, the VM will be turned off based on the deployment policy. Specified in seconds.
          :param pulumi.Input[str] status_message: The status message of the instance.
          :param pulumi.Input[str] target_group_description: A description of the target group.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] target_group_labels: A set of key/value label pairs.
          :param pulumi.Input[str] target_group_name: The name of the target group.
          """
          if max_opening_traffic_duration is not None:
              pulumi.set(__self__, "max_opening_traffic_duration", max_opening_traffic_duration)
          if status_message is not None:
              pulumi.set(__self__, "status_message", status_message)
          if target_group_description is not None:
              pulumi.set(__self__, "target_group_description", target_group_description)
          if target_group_id is not None:
              pulumi.set(__self__, "target_group_id", target_group_id)
          if target_group_labels is not None:
              pulumi.set(__self__, "target_group_labels", target_group_labels)
          if target_group_name is not None:
              pulumi.set(__self__, "target_group_name", target_group_name)
  
      @property
      @pulumi.getter(name="maxOpeningTrafficDuration")
      def max_opening_traffic_duration(self) -> Optional[pulumi.Input[int]]:
          """
          Timeout for waiting for the VM to be checked by the load balancer. If the timeout is exceeded, the VM will be turned off based on the deployment policy. Specified in seconds.
          """
          return pulumi.get(self, "max_opening_traffic_duration")
  
      @max_opening_traffic_duration.setter
      def max_opening_traffic_duration(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_opening_traffic_duration", value)
  
      @property
      @pulumi.getter(name="statusMessage")
      def status_message(self) -> Optional[pulumi.Input[str]]:
          """
          The status message of the instance.
          """
          return pulumi.get(self, "status_message")
  
      @status_message.setter
      def status_message(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "status_message", value)
  
      @property
      @pulumi.getter(name="targetGroupDescription")
      def target_group_description(self) -> Optional[pulumi.Input[str]]:
          """
          A description of the target group.
          """
          return pulumi.get(self, "target_group_description")
  
      @target_group_description.setter
      def target_group_description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "target_group_description", value)
  
      @property
      @pulumi.getter(name="targetGroupId")
      def target_group_id(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "target_group_id")
  
      @target_group_id.setter
      def target_group_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "target_group_id", value)
  
      @property
      @pulumi.getter(name="targetGroupLabels")
      def target_group_labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          A set of key/value label pairs.
          """
          return pulumi.get(self, "target_group_labels")
  
      @target_group_labels.setter
      def target_group_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "target_group_labels", value)
  
      @property
      @pulumi.getter(name="targetGroupName")
      def target_group_name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the target group.
          """
          return pulumi.get(self, "target_group_name")
  
      @target_group_name.setter
      def target_group_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "target_group_name", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupScalePolicyArgs:
      def __init__(__self__, *,
                   auto_scale: Optional[pulumi.Input['ComputeInstanceGroupScalePolicyAutoScaleArgs']] = None,
                   fixed_scale: Optional[pulumi.Input['ComputeInstanceGroupScalePolicyFixedScaleArgs']] = None,
                   test_auto_scale: Optional[pulumi.Input['ComputeInstanceGroupScalePolicyTestAutoScaleArgs']] = None):
          """
          :param pulumi.Input['ComputeInstanceGroupScalePolicyAutoScaleArgs'] auto_scale: The auto scaling policy of the instance group. The structure is documented below.
          :param pulumi.Input['ComputeInstanceGroupScalePolicyFixedScaleArgs'] fixed_scale: The fixed scaling policy of the instance group. The structure is documented below.
          :param pulumi.Input['ComputeInstanceGroupScalePolicyTestAutoScaleArgs'] test_auto_scale: The test auto scaling policy of the instance group. Use it to test how the auto scale works. The structure is documented below.
          """
          if auto_scale is not None:
              pulumi.set(__self__, "auto_scale", auto_scale)
          if fixed_scale is not None:
              pulumi.set(__self__, "fixed_scale", fixed_scale)
          if test_auto_scale is not None:
              pulumi.set(__self__, "test_auto_scale", test_auto_scale)
  
      @property
      @pulumi.getter(name="autoScale")
      def auto_scale(self) -> Optional[pulumi.Input['ComputeInstanceGroupScalePolicyAutoScaleArgs']]:
          """
          The auto scaling policy of the instance group. The structure is documented below.
          """
          return pulumi.get(self, "auto_scale")
  
      @auto_scale.setter
      def auto_scale(self, value: Optional[pulumi.Input['ComputeInstanceGroupScalePolicyAutoScaleArgs']]):
          pulumi.set(self, "auto_scale", value)
  
      @property
      @pulumi.getter(name="fixedScale")
      def fixed_scale(self) -> Optional[pulumi.Input['ComputeInstanceGroupScalePolicyFixedScaleArgs']]:
          """
          The fixed scaling policy of the instance group. The structure is documented below.
          """
          return pulumi.get(self, "fixed_scale")
  
      @fixed_scale.setter
      def fixed_scale(self, value: Optional[pulumi.Input['ComputeInstanceGroupScalePolicyFixedScaleArgs']]):
          pulumi.set(self, "fixed_scale", value)
  
      @property
      @pulumi.getter(name="testAutoScale")
      def test_auto_scale(self) -> Optional[pulumi.Input['ComputeInstanceGroupScalePolicyTestAutoScaleArgs']]:
          """
          The test auto scaling policy of the instance group. Use it to test how the auto scale works. The structure is documented below.
          """
          return pulumi.get(self, "test_auto_scale")
  
      @test_auto_scale.setter
      def test_auto_scale(self, value: Optional[pulumi.Input['ComputeInstanceGroupScalePolicyTestAutoScaleArgs']]):
          pulumi.set(self, "test_auto_scale", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupScalePolicyAutoScaleArgs:
      def __init__(__self__, *,
                   initial_size: pulumi.Input[int],
                   measurement_duration: pulumi.Input[int],
                   cpu_utilization_target: Optional[pulumi.Input[float]] = None,
                   custom_rules: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupScalePolicyAutoScaleCustomRuleArgs']]]] = None,
                   max_size: Optional[pulumi.Input[int]] = None,
                   min_zone_size: Optional[pulumi.Input[int]] = None,
                   stabilization_duration: Optional[pulumi.Input[int]] = None,
                   warmup_duration: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] initial_size: The initial number of instances in the instance group.
          :param pulumi.Input[int] measurement_duration: The amount of time, in seconds, that metrics are averaged for.
                 If the average value at the end of the interval is higher than the `cpu_utilization_target`,
                 the instance group will increase the number of virtual machines in the group.
          :param pulumi.Input[float] cpu_utilization_target: Target CPU load level.
          :param pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupScalePolicyAutoScaleCustomRuleArgs']]] custom_rules: A list of custom rules. The structure is documented below.
          :param pulumi.Input[int] max_size: The maximum number of virtual machines in the group.
          :param pulumi.Input[int] min_zone_size: The minimum number of virtual machines in a single availability zone.
          :param pulumi.Input[int] stabilization_duration: The minimum time interval, in seconds, to monitor the load before
                 an instance group can reduce the number of virtual machines in the group. During this time, the group
                 will not decrease even if the average load falls below the value of `cpu_utilization_target`.
          :param pulumi.Input[int] warmup_duration: The warm-up time of the virtual machine, in seconds. During this time,
                 traffic is fed to the virtual machine, but load metrics are not taken into account.
          """
          pulumi.set(__self__, "initial_size", initial_size)
          pulumi.set(__self__, "measurement_duration", measurement_duration)
          if cpu_utilization_target is not None:
              pulumi.set(__self__, "cpu_utilization_target", cpu_utilization_target)
          if custom_rules is not None:
              pulumi.set(__self__, "custom_rules", custom_rules)
          if max_size is not None:
              pulumi.set(__self__, "max_size", max_size)
          if min_zone_size is not None:
              pulumi.set(__self__, "min_zone_size", min_zone_size)
          if stabilization_duration is not None:
              pulumi.set(__self__, "stabilization_duration", stabilization_duration)
          if warmup_duration is not None:
              pulumi.set(__self__, "warmup_duration", warmup_duration)
  
      @property
      @pulumi.getter(name="initialSize")
      def initial_size(self) -> pulumi.Input[int]:
          """
          The initial number of instances in the instance group.
          """
          return pulumi.get(self, "initial_size")
  
      @initial_size.setter
      def initial_size(self, value: pulumi.Input[int]):
          pulumi.set(self, "initial_size", value)
  
      @property
      @pulumi.getter(name="measurementDuration")
      def measurement_duration(self) -> pulumi.Input[int]:
          """
          The amount of time, in seconds, that metrics are averaged for.
          If the average value at the end of the interval is higher than the `cpu_utilization_target`,
          the instance group will increase the number of virtual machines in the group.
          """
          return pulumi.get(self, "measurement_duration")
  
      @measurement_duration.setter
      def measurement_duration(self, value: pulumi.Input[int]):
          pulumi.set(self, "measurement_duration", value)
  
      @property
      @pulumi.getter(name="cpuUtilizationTarget")
      def cpu_utilization_target(self) -> Optional[pulumi.Input[float]]:
          """
          Target CPU load level.
          """
          return pulumi.get(self, "cpu_utilization_target")
  
      @cpu_utilization_target.setter
      def cpu_utilization_target(self, value: Optional[pulumi.Input[float]]):
          pulumi.set(self, "cpu_utilization_target", value)
  
      @property
      @pulumi.getter(name="customRules")
      def custom_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupScalePolicyAutoScaleCustomRuleArgs']]]]:
          """
          A list of custom rules. The structure is documented below.
          """
          return pulumi.get(self, "custom_rules")
  
      @custom_rules.setter
      def custom_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupScalePolicyAutoScaleCustomRuleArgs']]]]):
          pulumi.set(self, "custom_rules", value)
  
      @property
      @pulumi.getter(name="maxSize")
      def max_size(self) -> Optional[pulumi.Input[int]]:
          """
          The maximum number of virtual machines in the group.
          """
          return pulumi.get(self, "max_size")
  
      @max_size.setter
      def max_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_size", value)
  
      @property
      @pulumi.getter(name="minZoneSize")
      def min_zone_size(self) -> Optional[pulumi.Input[int]]:
          """
          The minimum number of virtual machines in a single availability zone.
          """
          return pulumi.get(self, "min_zone_size")
  
      @min_zone_size.setter
      def min_zone_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "min_zone_size", value)
  
      @property
      @pulumi.getter(name="stabilizationDuration")
      def stabilization_duration(self) -> Optional[pulumi.Input[int]]:
          """
          The minimum time interval, in seconds, to monitor the load before
          an instance group can reduce the number of virtual machines in the group. During this time, the group
          will not decrease even if the average load falls below the value of `cpu_utilization_target`.
          """
          return pulumi.get(self, "stabilization_duration")
  
      @stabilization_duration.setter
      def stabilization_duration(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "stabilization_duration", value)
  
      @property
      @pulumi.getter(name="warmupDuration")
      def warmup_duration(self) -> Optional[pulumi.Input[int]]:
          """
          The warm-up time of the virtual machine, in seconds. During this time,
          traffic is fed to the virtual machine, but load metrics are not taken into account.
          """
          return pulumi.get(self, "warmup_duration")
  
      @warmup_duration.setter
      def warmup_duration(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "warmup_duration", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupScalePolicyAutoScaleCustomRuleArgs:
      def __init__(__self__, *,
                   metric_name: pulumi.Input[str],
                   metric_type: pulumi.Input[str],
                   rule_type: pulumi.Input[str],
                   target: pulumi.Input[float],
                   folder_id: Optional[pulumi.Input[str]] = None,
                   labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   service: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] metric_name: The name of metric.
          :param pulumi.Input[str] metric_type: Metric type, `GAUGE` or `COUNTER`.
          :param pulumi.Input[str] rule_type: Rule type: `UTILIZATION` - This type means that the metric applies to one instance.
                 First, Instance Groups calculates the average metric value for each instance,
                 then averages the values for instances in one availability zone.
                 This type of metric must have the `instance_id` label. `WORKLOAD` - This type means that the metric applies to instances in one availability zone.
                 This type of metric must have the `zone_id` label.
          :param pulumi.Input[float] target: Target metric value level.
          :param pulumi.Input[str] folder_id: Folder ID of custom metric in Yandex Monitoring that should be used for scaling.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: A map of labels of metric.
          :param pulumi.Input[str] service: Service of custom metric in Yandex Monitoring that should be used for scaling.
          """
          pulumi.set(__self__, "metric_name", metric_name)
          pulumi.set(__self__, "metric_type", metric_type)
          pulumi.set(__self__, "rule_type", rule_type)
          pulumi.set(__self__, "target", target)
          if folder_id is not None:
              pulumi.set(__self__, "folder_id", folder_id)
          if labels is not None:
              pulumi.set(__self__, "labels", labels)
          if service is not None:
              pulumi.set(__self__, "service", service)
  
      @property
      @pulumi.getter(name="metricName")
      def metric_name(self) -> pulumi.Input[str]:
          """
          The name of metric.
          """
          return pulumi.get(self, "metric_name")
  
      @metric_name.setter
      def metric_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "metric_name", value)
  
      @property
      @pulumi.getter(name="metricType")
      def metric_type(self) -> pulumi.Input[str]:
          """
          Metric type, `GAUGE` or `COUNTER`.
          """
          return pulumi.get(self, "metric_type")
  
      @metric_type.setter
      def metric_type(self, value: pulumi.Input[str]):
          pulumi.set(self, "metric_type", value)
  
      @property
      @pulumi.getter(name="ruleType")
      def rule_type(self) -> pulumi.Input[str]:
          """
          Rule type: `UTILIZATION` - This type means that the metric applies to one instance.
          First, Instance Groups calculates the average metric value for each instance,
          then averages the values for instances in one availability zone.
          This type of metric must have the `instance_id` label. `WORKLOAD` - This type means that the metric applies to instances in one availability zone.
          This type of metric must have the `zone_id` label.
          """
          return pulumi.get(self, "rule_type")
  
      @rule_type.setter
      def rule_type(self, value: pulumi.Input[str]):
          pulumi.set(self, "rule_type", value)
  
      @property
      @pulumi.getter
      def target(self) -> pulumi.Input[float]:
          """
          Target metric value level.
          """
          return pulumi.get(self, "target")
  
      @target.setter
      def target(self, value: pulumi.Input[float]):
          pulumi.set(self, "target", value)
  
      @property
      @pulumi.getter(name="folderId")
      def folder_id(self) -> Optional[pulumi.Input[str]]:
          """
          Folder ID of custom metric in Yandex Monitoring that should be used for scaling.
          """
          return pulumi.get(self, "folder_id")
  
      @folder_id.setter
      def folder_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "folder_id", value)
  
      @property
      @pulumi.getter
      def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          A map of labels of metric.
          """
          return pulumi.get(self, "labels")
  
      @labels.setter
      def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "labels", value)
  
      @property
      @pulumi.getter
      def service(self) -> Optional[pulumi.Input[str]]:
          """
          Service of custom metric in Yandex Monitoring that should be used for scaling.
          """
          return pulumi.get(self, "service")
  
      @service.setter
      def service(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "service", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupScalePolicyFixedScaleArgs:
      def __init__(__self__, *,
                   size: pulumi.Input[int]):
          """
          :param pulumi.Input[int] size: The number of instances in the instance group.
          """
          pulumi.set(__self__, "size", size)
  
      @property
      @pulumi.getter
      def size(self) -> pulumi.Input[int]:
          """
          The number of instances in the instance group.
          """
          return pulumi.get(self, "size")
  
      @size.setter
      def size(self, value: pulumi.Input[int]):
          pulumi.set(self, "size", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupScalePolicyTestAutoScaleArgs:
      def __init__(__self__, *,
                   initial_size: pulumi.Input[int],
                   measurement_duration: pulumi.Input[int],
                   cpu_utilization_target: Optional[pulumi.Input[float]] = None,
                   custom_rules: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupScalePolicyTestAutoScaleCustomRuleArgs']]]] = None,
                   max_size: Optional[pulumi.Input[int]] = None,
                   min_zone_size: Optional[pulumi.Input[int]] = None,
                   stabilization_duration: Optional[pulumi.Input[int]] = None,
                   warmup_duration: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] initial_size: The initial number of instances in the instance group.
          :param pulumi.Input[int] measurement_duration: The amount of time, in seconds, that metrics are averaged for.
                 If the average value at the end of the interval is higher than the `cpu_utilization_target`,
                 the instance group will increase the number of virtual machines in the group.
          :param pulumi.Input[float] cpu_utilization_target: Target CPU load level.
          :param pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupScalePolicyTestAutoScaleCustomRuleArgs']]] custom_rules: A list of custom rules. The structure is documented below.
          :param pulumi.Input[int] max_size: The maximum number of virtual machines in the group.
          :param pulumi.Input[int] min_zone_size: The minimum number of virtual machines in a single availability zone.
          :param pulumi.Input[int] stabilization_duration: The minimum time interval, in seconds, to monitor the load before
                 an instance group can reduce the number of virtual machines in the group. During this time, the group
                 will not decrease even if the average load falls below the value of `cpu_utilization_target`.
          :param pulumi.Input[int] warmup_duration: The warm-up time of the virtual machine, in seconds. During this time,
                 traffic is fed to the virtual machine, but load metrics are not taken into account.
          """
          pulumi.set(__self__, "initial_size", initial_size)
          pulumi.set(__self__, "measurement_duration", measurement_duration)
          if cpu_utilization_target is not None:
              pulumi.set(__self__, "cpu_utilization_target", cpu_utilization_target)
          if custom_rules is not None:
              pulumi.set(__self__, "custom_rules", custom_rules)
          if max_size is not None:
              pulumi.set(__self__, "max_size", max_size)
          if min_zone_size is not None:
              pulumi.set(__self__, "min_zone_size", min_zone_size)
          if stabilization_duration is not None:
              pulumi.set(__self__, "stabilization_duration", stabilization_duration)
          if warmup_duration is not None:
              pulumi.set(__self__, "warmup_duration", warmup_duration)
  
      @property
      @pulumi.getter(name="initialSize")
      def initial_size(self) -> pulumi.Input[int]:
          """
          The initial number of instances in the instance group.
          """
          return pulumi.get(self, "initial_size")
  
      @initial_size.setter
      def initial_size(self, value: pulumi.Input[int]):
          pulumi.set(self, "initial_size", value)
  
      @property
      @pulumi.getter(name="measurementDuration")
      def measurement_duration(self) -> pulumi.Input[int]:
          """
          The amount of time, in seconds, that metrics are averaged for.
          If the average value at the end of the interval is higher than the `cpu_utilization_target`,
          the instance group will increase the number of virtual machines in the group.
          """
          return pulumi.get(self, "measurement_duration")
  
      @measurement_duration.setter
      def measurement_duration(self, value: pulumi.Input[int]):
          pulumi.set(self, "measurement_duration", value)
  
      @property
      @pulumi.getter(name="cpuUtilizationTarget")
      def cpu_utilization_target(self) -> Optional[pulumi.Input[float]]:
          """
          Target CPU load level.
          """
          return pulumi.get(self, "cpu_utilization_target")
  
      @cpu_utilization_target.setter
      def cpu_utilization_target(self, value: Optional[pulumi.Input[float]]):
          pulumi.set(self, "cpu_utilization_target", value)
  
      @property
      @pulumi.getter(name="customRules")
      def custom_rules(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupScalePolicyTestAutoScaleCustomRuleArgs']]]]:
          """
          A list of custom rules. The structure is documented below.
          """
          return pulumi.get(self, "custom_rules")
  
      @custom_rules.setter
      def custom_rules(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceGroupScalePolicyTestAutoScaleCustomRuleArgs']]]]):
          pulumi.set(self, "custom_rules", value)
  
      @property
      @pulumi.getter(name="maxSize")
      def max_size(self) -> Optional[pulumi.Input[int]]:
          """
          The maximum number of virtual machines in the group.
          """
          return pulumi.get(self, "max_size")
  
      @max_size.setter
      def max_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_size", value)
  
      @property
      @pulumi.getter(name="minZoneSize")
      def min_zone_size(self) -> Optional[pulumi.Input[int]]:
          """
          The minimum number of virtual machines in a single availability zone.
          """
          return pulumi.get(self, "min_zone_size")
  
      @min_zone_size.setter
      def min_zone_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "min_zone_size", value)
  
      @property
      @pulumi.getter(name="stabilizationDuration")
      def stabilization_duration(self) -> Optional[pulumi.Input[int]]:
          """
          The minimum time interval, in seconds, to monitor the load before
          an instance group can reduce the number of virtual machines in the group. During this time, the group
          will not decrease even if the average load falls below the value of `cpu_utilization_target`.
          """
          return pulumi.get(self, "stabilization_duration")
  
      @stabilization_duration.setter
      def stabilization_duration(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "stabilization_duration", value)
  
      @property
      @pulumi.getter(name="warmupDuration")
      def warmup_duration(self) -> Optional[pulumi.Input[int]]:
          """
          The warm-up time of the virtual machine, in seconds. During this time,
          traffic is fed to the virtual machine, but load metrics are not taken into account.
          """
          return pulumi.get(self, "warmup_duration")
  
      @warmup_duration.setter
      def warmup_duration(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "warmup_duration", value)
  
  
  @pulumi.input_type
  class ComputeInstanceGroupScalePolicyTestAutoScaleCustomRuleArgs:
      def __init__(__self__, *,
                   metric_name: pulumi.Input[str],
                   metric_type: pulumi.Input[str],
                   rule_type: pulumi.Input[str],
                   target: pulumi.Input[float],
                   folder_id: Optional[pulumi.Input[str]] = None,
                   labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   service: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] metric_name: The name of metric.
          :param pulumi.Input[str] metric_type: Metric type, `GAUGE` or `COUNTER`.
          :param pulumi.Input[str] rule_type: Rule type: `UTILIZATION` - This type means that the metric applies to one instance.
                 First, Instance Groups calculates the average metric value for each instance,
                 then averages the values for instances in one availability zone.
                 This type of metric must have the `instance_id` label. `WORKLOAD` - This type means that the metric applies to instances in one availability zone.
                 This type of metric must have the `zone_id` label.
          :param pulumi.Input[float] target: Target metric value level.
          :param pulumi.Input[str] folder_id: Folder ID of custom metric in Yandex Monitoring that should be used for scaling.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: A map of labels of metric.
          :param pulumi.Input[str] service: Service of custom metric in Yandex Monitoring that should be used for scaling.
          """
          pulumi.set(__self__, "metric_name", metric_name)
          pulumi.set(__self__, "metric_type", metric_type)
          pulumi.set(__self__, "rule_type", rule_type)
          pulumi.set(__self__, "target", target)
          if folder_id is not None:
              pulumi.set(__self__, "folder_id", folder_id)
          if labels is not None:
              pulumi.set(__self__, "labels", labels)
          if service is not None:
              pulumi.set(__self__, "service", service)
  
      @property
      @pulumi.getter(name="metricName")
      def metric_name(self) -> pulumi.Input[str]:
          """
          The name of metric.
          """
          return pulumi.get(self, "metric_name")
  
      @metric_name.setter
      def metric_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "metric_name", value)
  
      @property
      @pulumi.getter(name="metricType")
      def metric_type(self) -> pulumi.Input[str]:
          """
          Metric type, `GAUGE` or `COUNTER`.
          """
          return pulumi.get(self, "metric_type")
  
      @metric_type.setter
      def metric_type(self, value: pulumi.Input[str]):
          pulumi.set(self, "metric_type", value)
  
      @property
      @pulumi.getter(name="ruleType")
      def rule_type(self) -> pulumi.Input[str]:
          """
          Rule type: `UTILIZATION` - This type means that the metric applies to one instance.
          First, Instance Groups calculates the average metric value for each instance,
          then averages the values for instances in one availability zone.
          This type of metric must have the `instance_id` label. `WORKLOAD` - This type means that the metric applies to instances in one availability zone.
          This type of metric must have the `zone_id` label.
          """
          return pulumi.get(self, "rule_type")
  
      @rule_type.setter
      def rule_type(self, value: pulumi.Input[str]):
          pulumi.set(self, "rule_type", value)
  
      @property
      @pulumi.getter
      def target(self) -> pulumi.Input[float]:
          """
          Target metric value level.
          """
          return pulumi.get(self, "target")
  
      @target.setter
      def target(self, value: pulumi.Input[float]):
          pulumi.set(self, "target", value)
  
      @property
      @pulumi.getter(name="folderId")
      def folder_id(self) -> Optional[pulumi.Input[str]]:
          """
          Folder ID of custom metric in Yandex Monitoring that should be used for scaling.
          """
          return pulumi.get(self, "folder_id")
  
      @folder_id.setter
      def folder_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "folder_id", value)
  
      @property
      @pulumi.getter
      def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          A map of labels of metric.
          """
          return pulumi.get(self, "labels")
  
      @labels.setter
      def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "labels", value)
  
      @property
      @pulumi.getter
      def service(self) -> Optional[pulumi.Input[str]]:
          """
          Service of custom metric in Yandex Monitoring that should be used for scaling.
          """
          return pulumi.get(self, "service")
  
      @service.setter
      def service(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "service", value)
  
  
  @pulumi.input_type
  class ComputeInstanceNetworkInterfaceArgs:
      def __init__(__self__, *,
                   subnet_id: pulumi.Input[str],
                   dns_records: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceNetworkInterfaceDnsRecordArgs']]]] = None,
                   index: Optional[pulumi.Input[int]] = None,
                   ip_address: Optional[pulumi.Input[str]] = None,
                   ipv4: Optional[pulumi.Input[bool]] = None,
                   ipv6: Optional[pulumi.Input[bool]] = None,
                   ipv6_address: Optional[pulumi.Input[str]] = None,
                   ipv6_dns_records: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceNetworkInterfaceIpv6DnsRecordArgs']]]] = None,
                   mac_address: Optional[pulumi.Input[str]] = None,
                   nat: Optional[pulumi.Input[bool]] = None,
                   nat_dns_records: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceNetworkInterfaceNatDnsRecordArgs']]]] = None,
                   nat_ip_address: Optional[pulumi.Input[str]] = None,
                   nat_ip_version: Optional[pulumi.Input[str]] = None,
                   security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          :param pulumi.Input[str] subnet_id: ID of the subnet to attach this
                 interface to. The subnet must exist in the same zone where this instance will be
                 created.
          :param pulumi.Input[Sequence[pulumi.Input['ComputeInstanceNetworkInterfaceDnsRecordArgs']]] dns_records: List of configurations for creating ipv4 DNS records. The structure is documented below.
          :param pulumi.Input[str] ip_address: The private IP address to assign to the instance. If
                 empty, the address will be automatically assigned from the specified subnet.
          :param pulumi.Input[bool] ipv4: Allocate an IPv4 address for the interface. The default value is `true`.
          :param pulumi.Input[bool] ipv6: If true, allocate an IPv6 address for the interface.
                 The address will be automatically assigned from the specified subnet.
          :param pulumi.Input[str] ipv6_address: The private IPv6 address to assign to the instance.
          :param pulumi.Input[Sequence[pulumi.Input['ComputeInstanceNetworkInterfaceIpv6DnsRecordArgs']]] ipv6_dns_records: List of configurations for creating ipv6 DNS records. The structure is documented below.
          :param pulumi.Input[bool] nat: Provide a public address, for instance, to access the internet over NAT.
          :param pulumi.Input[Sequence[pulumi.Input['ComputeInstanceNetworkInterfaceNatDnsRecordArgs']]] nat_dns_records: List of configurations for creating ipv4 NAT DNS records. The structure is documented below.
          :param pulumi.Input[str] nat_ip_address: Provide a public address, for instance, to access the internet over NAT. Address should be already reserved in web UI.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] security_group_ids: Security group ids for network interface.
          """
          pulumi.set(__self__, "subnet_id", subnet_id)
          if dns_records is not None:
              pulumi.set(__self__, "dns_records", dns_records)
          if index is not None:
              pulumi.set(__self__, "index", index)
          if ip_address is not None:
              pulumi.set(__self__, "ip_address", ip_address)
          if ipv4 is not None:
              pulumi.set(__self__, "ipv4", ipv4)
          if ipv6 is not None:
              pulumi.set(__self__, "ipv6", ipv6)
          if ipv6_address is not None:
              pulumi.set(__self__, "ipv6_address", ipv6_address)
          if ipv6_dns_records is not None:
              pulumi.set(__self__, "ipv6_dns_records", ipv6_dns_records)
          if mac_address is not None:
              pulumi.set(__self__, "mac_address", mac_address)
          if nat is not None:
              pulumi.set(__self__, "nat", nat)
          if nat_dns_records is not None:
              pulumi.set(__self__, "nat_dns_records", nat_dns_records)
          if nat_ip_address is not None:
              pulumi.set(__self__, "nat_ip_address", nat_ip_address)
          if nat_ip_version is not None:
              pulumi.set(__self__, "nat_ip_version", nat_ip_version)
          if security_group_ids is not None:
              pulumi.set(__self__, "security_group_ids", security_group_ids)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> pulumi.Input[str]:
          """
          ID of the subnet to attach this
          interface to. The subnet must exist in the same zone where this instance will be
          created.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "subnet_id", value)
  
      @property
      @pulumi.getter(name="dnsRecords")
      def dns_records(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceNetworkInterfaceDnsRecordArgs']]]]:
          """
          List of configurations for creating ipv4 DNS records. The structure is documented below.
          """
          return pulumi.get(self, "dns_records")
  
      @dns_records.setter
      def dns_records(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceNetworkInterfaceDnsRecordArgs']]]]):
          pulumi.set(self, "dns_records", value)
  
      @property
      @pulumi.getter
      def index(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "index")
  
      @index.setter
      def index(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "index", value)
  
      @property
      @pulumi.getter(name="ipAddress")
      def ip_address(self) -> Optional[pulumi.Input[str]]:
          """
          The private IP address to assign to the instance. If
          empty, the address will be automatically assigned from the specified subnet.
          """
          return pulumi.get(self, "ip_address")
  
      @ip_address.setter
      def ip_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "ip_address", value)
  
      @property
      @pulumi.getter
      def ipv4(self) -> Optional[pulumi.Input[bool]]:
          """
          Allocate an IPv4 address for the interface. The default value is `true`.
          """
          return pulumi.get(self, "ipv4")
  
      @ipv4.setter
      def ipv4(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "ipv4", value)
  
      @property
      @pulumi.getter
      def ipv6(self) -> Optional[pulumi.Input[bool]]:
          """
          If true, allocate an IPv6 address for the interface.
          The address will be automatically assigned from the specified subnet.
          """
          return pulumi.get(self, "ipv6")
  
      @ipv6.setter
      def ipv6(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "ipv6", value)
  
      @property
      @pulumi.getter(name="ipv6Address")
      def ipv6_address(self) -> Optional[pulumi.Input[str]]:
          """
          The private IPv6 address to assign to the instance.
          """
          return pulumi.get(self, "ipv6_address")
  
      @ipv6_address.setter
      def ipv6_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "ipv6_address", value)
  
      @property
      @pulumi.getter(name="ipv6DnsRecords")
      def ipv6_dns_records(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceNetworkInterfaceIpv6DnsRecordArgs']]]]:
          """
          List of configurations for creating ipv6 DNS records. The structure is documented below.
          """
          return pulumi.get(self, "ipv6_dns_records")
  
      @ipv6_dns_records.setter
      def ipv6_dns_records(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceNetworkInterfaceIpv6DnsRecordArgs']]]]):
          pulumi.set(self, "ipv6_dns_records", value)
  
      @property
      @pulumi.getter(name="macAddress")
      def mac_address(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "mac_address")
  
      @mac_address.setter
      def mac_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "mac_address", value)
  
      @property
      @pulumi.getter
      def nat(self) -> Optional[pulumi.Input[bool]]:
          """
          Provide a public address, for instance, to access the internet over NAT.
          """
          return pulumi.get(self, "nat")
  
      @nat.setter
      def nat(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "nat", value)
  
      @property
      @pulumi.getter(name="natDnsRecords")
      def nat_dns_records(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceNetworkInterfaceNatDnsRecordArgs']]]]:
          """
          List of configurations for creating ipv4 NAT DNS records. The structure is documented below.
          """
          return pulumi.get(self, "nat_dns_records")
  
      @nat_dns_records.setter
      def nat_dns_records(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ComputeInstanceNetworkInterfaceNatDnsRecordArgs']]]]):
          pulumi.set(self, "nat_dns_records", value)
  
      @property
      @pulumi.getter(name="natIpAddress")
      def nat_ip_address(self) -> Optional[pulumi.Input[str]]:
          """
          Provide a public address, for instance, to access the internet over NAT. Address should be already reserved in web UI.
          """
          return pulumi.get(self, "nat_ip_address")
  
      @nat_ip_address.setter
      def nat_ip_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "nat_ip_address", value)
  
      @property
      @pulumi.getter(name="natIpVersion")
      def nat_ip_version(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "nat_ip_version")
  
      @nat_ip_version.setter
      def nat_ip_version(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "nat_ip_version", value)
  
      @property
      @pulumi.getter(name="securityGroupIds")
      def security_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          Security group ids for network interface.
          """
          return pulumi.get(self, "security_group_ids")
  
      @security_group_ids.setter
      def security_group_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "security_group_ids", value)
  
  
  @pulumi.input_type
  class ComputeInstanceNetworkInterfaceDnsRecordArgs:
      def __init__(__self__, *,
                   fqdn: pulumi.Input[str],
                   dns_zone_id: Optional[pulumi.Input[str]] = None,
                   ptr: Optional[pulumi.Input[bool]] = None,
                   ttl: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] fqdn: DNS record FQDN (must have a dot at the end).
          :param pulumi.Input[str] dns_zone_id: DNS zone ID (if not set, private zone used).
          :param pulumi.Input[bool] ptr: When set to true, also create a PTR DNS record.
          :param pulumi.Input[int] ttl: DNS record TTL. in seconds
          """
          pulumi.set(__self__, "fqdn", fqdn)
          if dns_zone_id is not None:
              pulumi.set(__self__, "dns_zone_id", dns_zone_id)
          if ptr is not None:
              pulumi.set(__self__, "ptr", ptr)
          if ttl is not None:
              pulumi.set(__self__, "ttl", ttl)
  
      @property
      @pulumi.getter
      def fqdn(self) -> pulumi.Input[str]:
          """
          DNS record FQDN (must have a dot at the end).
          """
          return pulumi.get(self, "fqdn")
  
      @fqdn.setter
      def fqdn(self, value: pulumi.Input[str]):
          pulumi.set(self, "fqdn", value)
  
      @property
      @pulumi.getter(name="dnsZoneId")
      def dns_zone_id(self) -> Optional[pulumi.Input[str]]:
          """
          DNS zone ID (if not set, private zone used).
          """
          return pulumi.get(self, "dns_zone_id")
  
      @dns_zone_id.setter
      def dns_zone_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "dns_zone_id", value)
  
      @property
      @pulumi.getter
      def ptr(self) -> Optional[pulumi.Input[bool]]:
          """
          When set to true, also create a PTR DNS record.
          """
          return pulumi.get(self, "ptr")
  
      @ptr.setter
      def ptr(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "ptr", value)
  
      @property
      @pulumi.getter
      def ttl(self) -> Optional[pulumi.Input[int]]:
          """
          DNS record TTL. in seconds
          """
          return pulumi.get(self, "ttl")
  
      @ttl.setter
      def ttl(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "ttl", value)
  
  
  @pulumi.input_type
  class ComputeInstanceNetworkInterfaceIpv6DnsRecordArgs:
      def __init__(__self__, *,
                   fqdn: pulumi.Input[str],
                   dns_zone_id: Optional[pulumi.Input[str]] = None,
                   ptr: Optional[pulumi.Input[bool]] = None,
                   ttl: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] fqdn: DNS record FQDN (must have a dot at the end).
          :param pulumi.Input[str] dns_zone_id: DNS zone ID (if not set, private zone used).
          :param pulumi.Input[bool] ptr: When set to true, also create a PTR DNS record.
          :param pulumi.Input[int] ttl: DNS record TTL. in seconds
          """
          pulumi.set(__self__, "fqdn", fqdn)
          if dns_zone_id is not None:
              pulumi.set(__self__, "dns_zone_id", dns_zone_id)
          if ptr is not None:
              pulumi.set(__self__, "ptr", ptr)
          if ttl is not None:
              pulumi.set(__self__, "ttl", ttl)
  
      @property
      @pulumi.getter
      def fqdn(self) -> pulumi.Input[str]:
          """
          DNS record FQDN (must have a dot at the end).
          """
          return pulumi.get(self, "fqdn")
  
      @fqdn.setter
      def fqdn(self, value: pulumi.Input[str]):
          pulumi.set(self, "fqdn", value)
  
      @property
      @pulumi.getter(name="dnsZoneId")
      def dns_zone_id(self) -> Optional[pulumi.Input[str]]:
          """
          DNS zone ID (if not set, private zone used).
          """
          return pulumi.get(self, "dns_zone_id")
  
      @dns_zone_id.setter
      def dns_zone_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "dns_zone_id", value)
  
      @property
      @pulumi.getter
      def ptr(self) -> Optional[pulumi.Input[bool]]:
          """
          When set to true, also create a PTR DNS record.
          """
          return pulumi.get(self, "ptr")
  
      @ptr.setter
      def ptr(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "ptr", value)
  
      @property
      @pulumi.getter
      def ttl(self) -> Optional[pulumi.Input[int]]:
          """
          DNS record TTL. in seconds
          """
          return pulumi.get(self, "ttl")
  
      @ttl.setter
      def ttl(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "ttl", value)
  
  
  @pulumi.input_type
  class ComputeInstanceNetworkInterfaceNatDnsRecordArgs:
      def __init__(__self__, *,
                   fqdn: pulumi.Input[str],
                   dns_zone_id: Optional[pulumi.Input[str]] = None,
                   ptr: Optional[pulumi.Input[bool]] = None,
                   ttl: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] fqdn: DNS record FQDN (must have a dot at the end).
          :param pulumi.Input[str] dns_zone_id: DNS zone ID (if not set, private zone used).
          :param pulumi.Input[bool] ptr: When set to true, also create a PTR DNS record.
          :param pulumi.Input[int] ttl: DNS record TTL. in seconds
          """
          pulumi.set(__self__, "fqdn", fqdn)
          if dns_zone_id is not None:
              pulumi.set(__self__, "dns_zone_id", dns_zone_id)
          if ptr is not None:
              pulumi.set(__self__, "ptr", ptr)
          if ttl is not None:
              pulumi.set(__self__, "ttl", ttl)
  
      @property
      @pulumi.getter
      def fqdn(self) -> pulumi.Input[str]:
          """
          DNS record FQDN (must have a dot at the end).
          """
          return pulumi.get(self, "fqdn")
  
      @fqdn.setter
      def fqdn(self, value: pulumi.Input[str]):
          pulumi.set(self, "fqdn", value)
  
      @property
      @pulumi.getter(name="dnsZoneId")
      def dns_zone_id(self) -> Optional[pulumi.Input[str]]:
          """
          DNS zone ID (if not set, private zone used).
          """
          return pulumi.get(self, "dns_zone_id")
  
      @dns_zone_id.setter
      def dns_zone_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "dns_zone_id", value)
  
      @property
      @pulumi.getter
      def ptr(self) -> Optional[pulumi.Input[bool]]:
          """
          When set to true, also create a PTR DNS record.
          """
          return pulumi.get(self, "ptr")
  
      @ptr.setter
      def ptr(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "ptr", value)
  
      @property
      @pulumi.getter
      def ttl(self) -> Optional[pulumi.Input[int]]:
          """
          DNS record TTL. in seconds
          """
          return pulumi.get(self, "ttl")
  
      @ttl.setter
      def ttl(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "ttl", value)
  
  
  @pulumi.input_type
  class ComputeInstancePlacementPolicyArgs:
      def __init__(__self__, *,
                   placement_group_id: pulumi.Input[str]):
          """
          :param pulumi.Input[str] placement_group_id: Specifies the id of the Placement Group to assign to the instance.
          """
          pulumi.set(__self__, "placement_group_id", placement_group_id)
  
      @property
      @pulumi.getter(name="placementGroupId")
      def placement_group_id(self) -> pulumi.Input[str]:
          """
          Specifies the id of the Placement Group to assign to the instance.
          """
          return pulumi.get(self, "placement_group_id")
  
      @placement_group_id.setter
      def placement_group_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "placement_group_id", value)
  
  
  @pulumi.input_type
  class ComputeInstanceResourcesArgs:
      def __init__(__self__, *,
                   cores: pulumi.Input[int],
                   memory: pulumi.Input[float],
                   core_fraction: Optional[pulumi.Input[int]] = None,
                   gpus: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] cores: CPU cores for the instance.
          :param pulumi.Input[float] memory: Memory size in GB.
          :param pulumi.Input[int] core_fraction: If provided, specifies baseline performance for a core as a percent.
          """
          pulumi.set(__self__, "cores", cores)
          pulumi.set(__self__, "memory", memory)
          if core_fraction is not None:
              pulumi.set(__self__, "core_fraction", core_fraction)
          if gpus is not None:
              pulumi.set(__self__, "gpus", gpus)
  
      @property
      @pulumi.getter
      def cores(self) -> pulumi.Input[int]:
          """
          CPU cores for the instance.
          """
          return pulumi.get(self, "cores")
  
      @cores.setter
      def cores(self, value: pulumi.Input[int]):
          pulumi.set(self, "cores", value)
  
      @property
      @pulumi.getter
      def memory(self) -> pulumi.Input[float]:
          """
          Memory size in GB.
          """
          return pulumi.get(self, "memory")
  
      @memory.setter
      def memory(self, value: pulumi.Input[float]):
          pulumi.set(self, "memory", value)
  
      @property
      @pulumi.getter(name="coreFraction")
      def core_fraction(self) -> Optional[pulumi.Input[int]]:
          """
          If provided, specifies baseline performance for a core as a percent.
          """
          return pulumi.get(self, "core_fraction")
  
      @core_fraction.setter
      def core_fraction(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "core_fraction", value)
  
      @property
      @pulumi.getter
      def gpus(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "gpus")
  
      @gpus.setter
      def gpus(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "gpus", value)
  
  
  @pulumi.input_type
  class ComputeInstanceSchedulingPolicyArgs:
      def __init__(__self__, *,
                   preemptible: Optional[pulumi.Input[bool]] = None):
          """
          :param pulumi.Input[bool] preemptible: Specifies if the instance is preemptible. Defaults to false.
          """
          if preemptible is not None:
              pulumi.set(__self__, "preemptible", preemptible)
  
      @property
      @pulumi.getter
      def preemptible(self) -> Optional[pulumi.Input[bool]]:
          """
          Specifies if the instance is preemptible. Defaults to false.
          """
          return pulumi.get(self, "preemptible")
  
      @preemptible.setter
      def preemptible(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "preemptible", value)
  
  
  @pulumi.input_type
  class ComputeInstanceSecondaryDiskArgs:
      def __init__(__self__, *,
                   disk_id: pulumi.Input[str],
                   auto_delete: Optional[pulumi.Input[bool]] = None,
                   device_name: Optional[pulumi.Input[str]] = None,
                   mode: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] disk_id: ID of the disk that is attached to the instance.
          :param pulumi.Input[bool] auto_delete: Whether the disk is auto-deleted when the instance
                 is deleted. The default value is false.
          :param pulumi.Input[str] device_name: Name that can be used to access an attached disk
                 under `/dev/disk/by-id/`.
          :param pulumi.Input[str] mode: Type of access to the disk resource. By default, a disk is attached in `READ_WRITE` mode.
          """
          pulumi.set(__self__, "disk_id", disk_id)
          if auto_delete is not None:
              pulumi.set(__self__, "auto_delete", auto_delete)
          if device_name is not None:
              pulumi.set(__self__, "device_name", device_name)
          if mode is not None:
              pulumi.set(__self__, "mode", mode)
  
      @property
      @pulumi.getter(name="diskId")
      def disk_id(self) -> pulumi.Input[str]:
          """
          ID of the disk that is attached to the instance.
          """
          return pulumi.get(self, "disk_id")
  
      @disk_id.setter
      def disk_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "disk_id", value)
  
      @property
      @pulumi.getter(name="autoDelete")
      def auto_delete(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether the disk is auto-deleted when the instance
          is deleted. The default value is false.
          """
          return pulumi.get(self, "auto_delete")
  
      @auto_delete.setter
      def auto_delete(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "auto_delete", value)
  
      @property
      @pulumi.getter(name="deviceName")
      def device_name(self) -> Optional[pulumi.Input[str]]:
          """
          Name that can be used to access an attached disk
          under `/dev/disk/by-id/`.
          """
          return pulumi.get(self, "device_name")
  
      @device_name.setter
      def device_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "device_name", value)
  
      @property
      @pulumi.getter
      def mode(self) -> Optional[pulumi.Input[str]]:
          """
          Type of access to the disk resource. By default, a disk is attached in `READ_WRITE` mode.
          """
          return pulumi.get(self, "mode")
  
      @mode.setter
      def mode(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "mode", value)
  
  
  @pulumi.input_type
  class DataprocClusterClusterConfigArgs:
      def __init__(__self__, *,
                   subcluster_specs: pulumi.Input[Sequence[pulumi.Input['DataprocClusterClusterConfigSubclusterSpecArgs']]],
                   hadoop: Optional[pulumi.Input['DataprocClusterClusterConfigHadoopArgs']] = None,
                   version_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[Sequence[pulumi.Input['DataprocClusterClusterConfigSubclusterSpecArgs']]] subcluster_specs: Configuration of the Data Proc subcluster. The structure is documented below.
          :param pulumi.Input['DataprocClusterClusterConfigHadoopArgs'] hadoop: Data Proc specific options. The structure is documented below.
          :param pulumi.Input[str] version_id: Version of Data Proc image.
          """
          pulumi.set(__self__, "subcluster_specs", subcluster_specs)
          if hadoop is not None:
              pulumi.set(__self__, "hadoop", hadoop)
          if version_id is not None:
              pulumi.set(__self__, "version_id", version_id)
  
      @property
      @pulumi.getter(name="subclusterSpecs")
      def subcluster_specs(self) -> pulumi.Input[Sequence[pulumi.Input['DataprocClusterClusterConfigSubclusterSpecArgs']]]:
          """
          Configuration of the Data Proc subcluster. The structure is documented below.
          """
          return pulumi.get(self, "subcluster_specs")
  
      @subcluster_specs.setter
      def subcluster_specs(self, value: pulumi.Input[Sequence[pulumi.Input['DataprocClusterClusterConfigSubclusterSpecArgs']]]):
          pulumi.set(self, "subcluster_specs", value)
  
      @property
      @pulumi.getter
      def hadoop(self) -> Optional[pulumi.Input['DataprocClusterClusterConfigHadoopArgs']]:
          """
          Data Proc specific options. The structure is documented below.
          """
          return pulumi.get(self, "hadoop")
  
      @hadoop.setter
      def hadoop(self, value: Optional[pulumi.Input['DataprocClusterClusterConfigHadoopArgs']]):
          pulumi.set(self, "hadoop", value)
  
      @property
      @pulumi.getter(name="versionId")
      def version_id(self) -> Optional[pulumi.Input[str]]:
          """
          Version of Data Proc image.
          """
          return pulumi.get(self, "version_id")
  
      @version_id.setter
      def version_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "version_id", value)
  
  
  @pulumi.input_type
  class DataprocClusterClusterConfigHadoopArgs:
      def __init__(__self__, *,
                   properties: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   services: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   ssh_public_keys: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] properties: A set of key/value pairs that are used to configure cluster services.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] services: List of services to run on Data Proc cluster.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] ssh_public_keys: List of SSH public keys to put to the hosts of the cluster. For information on how to connect to the cluster, see [the official documentation](https://cloud.yandex.com/docs/data-proc/operations/connect).
          """
          if properties is not None:
              pulumi.set(__self__, "properties", properties)
          if services is not None:
              pulumi.set(__self__, "services", services)
          if ssh_public_keys is not None:
              pulumi.set(__self__, "ssh_public_keys", ssh_public_keys)
  
      @property
      @pulumi.getter
      def properties(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          A set of key/value pairs that are used to configure cluster services.
          """
          return pulumi.get(self, "properties")
  
      @properties.setter
      def properties(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "properties", value)
  
      @property
      @pulumi.getter
      def services(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List of services to run on Data Proc cluster.
          """
          return pulumi.get(self, "services")
  
      @services.setter
      def services(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "services", value)
  
      @property
      @pulumi.getter(name="sshPublicKeys")
      def ssh_public_keys(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List of SSH public keys to put to the hosts of the cluster. For information on how to connect to the cluster, see [the official documentation](https://cloud.yandex.com/docs/data-proc/operations/connect).
          """
          return pulumi.get(self, "ssh_public_keys")
  
      @ssh_public_keys.setter
      def ssh_public_keys(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "ssh_public_keys", value)
  
  
  @pulumi.input_type
  class DataprocClusterClusterConfigSubclusterSpecArgs:
      def __init__(__self__, *,
                   hosts_count: pulumi.Input[int],
                   name: pulumi.Input[str],
                   resources: pulumi.Input['DataprocClusterClusterConfigSubclusterSpecResourcesArgs'],
                   role: pulumi.Input[str],
                   subnet_id: pulumi.Input[str],
                   autoscaling_config: Optional[pulumi.Input['DataprocClusterClusterConfigSubclusterSpecAutoscalingConfigArgs']] = None,
                   id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[int] hosts_count: Number of hosts within Data Proc subcluster.
          :param pulumi.Input[str] name: Name of the Data Proc subcluster.
          :param pulumi.Input['DataprocClusterClusterConfigSubclusterSpecResourcesArgs'] resources: Resources allocated to each host of the Data Proc subcluster. The structure is documented below.
          :param pulumi.Input[str] role: Role of the subcluster in the Data Proc cluster.
          :param pulumi.Input[str] subnet_id: The ID of the subnet, to which hosts of the subcluster belong. Subnets of all the subclusters must belong to the same VPC network.
          :param pulumi.Input['DataprocClusterClusterConfigSubclusterSpecAutoscalingConfigArgs'] autoscaling_config: Autoscaling configuration for compute subclusters.
          :param pulumi.Input[str] id: (Computed) ID of a new Data Proc cluster.
          """
          pulumi.set(__self__, "hosts_count", hosts_count)
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "resources", resources)
          pulumi.set(__self__, "role", role)
          pulumi.set(__self__, "subnet_id", subnet_id)
          if autoscaling_config is not None:
              pulumi.set(__self__, "autoscaling_config", autoscaling_config)
          if id is not None:
              pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter(name="hostsCount")
      def hosts_count(self) -> pulumi.Input[int]:
          """
          Number of hosts within Data Proc subcluster.
          """
          return pulumi.get(self, "hosts_count")
  
      @hosts_count.setter
      def hosts_count(self, value: pulumi.Input[int]):
          pulumi.set(self, "hosts_count", value)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          Name of the Data Proc subcluster.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def resources(self) -> pulumi.Input['DataprocClusterClusterConfigSubclusterSpecResourcesArgs']:
          """
          Resources allocated to each host of the Data Proc subcluster. The structure is documented below.
          """
          return pulumi.get(self, "resources")
  
      @resources.setter
      def resources(self, value: pulumi.Input['DataprocClusterClusterConfigSubclusterSpecResourcesArgs']):
          pulumi.set(self, "resources", value)
  
      @property
      @pulumi.getter
      def role(self) -> pulumi.Input[str]:
          """
          Role of the subcluster in the Data Proc cluster.
          """
          return pulumi.get(self, "role")
  
      @role.setter
      def role(self, value: pulumi.Input[str]):
          pulumi.set(self, "role", value)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> pulumi.Input[str]:
          """
          The ID of the subnet, to which hosts of the subcluster belong. Subnets of all the subclusters must belong to the same VPC network.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "subnet_id", value)
  
      @property
      @pulumi.getter(name="autoscalingConfig")
      def autoscaling_config(self) -> Optional[pulumi.Input['DataprocClusterClusterConfigSubclusterSpecAutoscalingConfigArgs']]:
          """
          Autoscaling configuration for compute subclusters.
          """
          return pulumi.get(self, "autoscaling_config")
  
      @autoscaling_config.setter
      def autoscaling_config(self, value: Optional[pulumi.Input['DataprocClusterClusterConfigSubclusterSpecAutoscalingConfigArgs']]):
          pulumi.set(self, "autoscaling_config", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          (Computed) ID of a new Data Proc cluster.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
  
  @pulumi.input_type
  class DataprocClusterClusterConfigSubclusterSpecAutoscalingConfigArgs:
      def __init__(__self__, *,
                   max_hosts_count: pulumi.Input[int],
                   cpu_utilization_target: Optional[pulumi.Input[float]] = None,
                   decommission_timeout: Optional[pulumi.Input[int]] = None,
                   measurement_duration: Optional[pulumi.Input[int]] = None,
                   preemptible: Optional[pulumi.Input[bool]] = None,
                   stabilization_duration: Optional[pulumi.Input[int]] = None,
                   warmup_duration: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] max_hosts_count: Maximum number of nodes in autoscaling subclusters.
          :param pulumi.Input[float] cpu_utilization_target: Defines an autoscaling rule based on the average CPU utilization of the instance group. If not set default autoscaling metric will be used.
          :param pulumi.Input[int] decommission_timeout: Timeout to gracefully decommission nodes during downscaling. In seconds.
          :param pulumi.Input[int] measurement_duration: Time in seconds allotted for averaging metrics.
          :param pulumi.Input[bool] preemptible: Bool flag -- whether to use preemptible compute instances. Preemptible instances are stopped at least once every 24 hours, and can be stopped at any time if their resources are needed by Compute. For more information, see [Preemptible Virtual Machines](https://cloud.yandex.com/docs/compute/concepts/preemptible-vm).
          :param pulumi.Input[int] stabilization_duration: Minimum amount of time in seconds allotted for monitoring before Instance Groups can reduce the number of instances in the group. During this time, the group size doesn't decrease, even if the new metric values indicate that it should.
          :param pulumi.Input[int] warmup_duration: The warmup time of the instance in seconds. During this time, traffic is sent to the instance, but instance metrics are not collected.
          """
          pulumi.set(__self__, "max_hosts_count", max_hosts_count)
          if cpu_utilization_target is not None:
              pulumi.set(__self__, "cpu_utilization_target", cpu_utilization_target)
          if decommission_timeout is not None:
              pulumi.set(__self__, "decommission_timeout", decommission_timeout)
          if measurement_duration is not None:
              pulumi.set(__self__, "measurement_duration", measurement_duration)
          if preemptible is not None:
              pulumi.set(__self__, "preemptible", preemptible)
          if stabilization_duration is not None:
              pulumi.set(__self__, "stabilization_duration", stabilization_duration)
          if warmup_duration is not None:
              pulumi.set(__self__, "warmup_duration", warmup_duration)
  
      @property
      @pulumi.getter(name="maxHostsCount")
      def max_hosts_count(self) -> pulumi.Input[int]:
          """
          Maximum number of nodes in autoscaling subclusters.
          """
          return pulumi.get(self, "max_hosts_count")
  
      @max_hosts_count.setter
      def max_hosts_count(self, value: pulumi.Input[int]):
          pulumi.set(self, "max_hosts_count", value)
  
      @property
      @pulumi.getter(name="cpuUtilizationTarget")
      def cpu_utilization_target(self) -> Optional[pulumi.Input[float]]:
          """
          Defines an autoscaling rule based on the average CPU utilization of the instance group. If not set default autoscaling metric will be used.
          """
          return pulumi.get(self, "cpu_utilization_target")
  
      @cpu_utilization_target.setter
      def cpu_utilization_target(self, value: Optional[pulumi.Input[float]]):
          pulumi.set(self, "cpu_utilization_target", value)
  
      @property
      @pulumi.getter(name="decommissionTimeout")
      def decommission_timeout(self) -> Optional[pulumi.Input[int]]:
          """
          Timeout to gracefully decommission nodes during downscaling. In seconds.
          """
          return pulumi.get(self, "decommission_timeout")
  
      @decommission_timeout.setter
      def decommission_timeout(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "decommission_timeout", value)
  
      @property
      @pulumi.getter(name="measurementDuration")
      def measurement_duration(self) -> Optional[pulumi.Input[int]]:
          """
          Time in seconds allotted for averaging metrics.
          """
          return pulumi.get(self, "measurement_duration")
  
      @measurement_duration.setter
      def measurement_duration(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "measurement_duration", value)
  
      @property
      @pulumi.getter
      def preemptible(self) -> Optional[pulumi.Input[bool]]:
          """
          Bool flag -- whether to use preemptible compute instances. Preemptible instances are stopped at least once every 24 hours, and can be stopped at any time if their resources are needed by Compute. For more information, see [Preemptible Virtual Machines](https://cloud.yandex.com/docs/compute/concepts/preemptible-vm).
          """
          return pulumi.get(self, "preemptible")
  
      @preemptible.setter
      def preemptible(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "preemptible", value)
  
      @property
      @pulumi.getter(name="stabilizationDuration")
      def stabilization_duration(self) -> Optional[pulumi.Input[int]]:
          """
          Minimum amount of time in seconds allotted for monitoring before Instance Groups can reduce the number of instances in the group. During this time, the group size doesn't decrease, even if the new metric values indicate that it should.
          """
          return pulumi.get(self, "stabilization_duration")
  
      @stabilization_duration.setter
      def stabilization_duration(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "stabilization_duration", value)
  
      @property
      @pulumi.getter(name="warmupDuration")
      def warmup_duration(self) -> Optional[pulumi.Input[int]]:
          """
          The warmup time of the instance in seconds. During this time, traffic is sent to the instance, but instance metrics are not collected.
          """
          return pulumi.get(self, "warmup_duration")
  
      @warmup_duration.setter
      def warmup_duration(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "warmup_duration", value)
  
  
  @pulumi.input_type
  class DataprocClusterClusterConfigSubclusterSpecResourcesArgs:
      def __init__(__self__, *,
                   disk_size: pulumi.Input[int],
                   resource_preset_id: pulumi.Input[str],
                   disk_type_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[int] disk_size: Volume of the storage available to a host, in gigabytes.
          :param pulumi.Input[str] resource_preset_id: The ID of the preset for computational resources available to a host. All available presets are listed in the [documentation](https://cloud.yandex.com/docs/data-proc/concepts/instance-types).
          :param pulumi.Input[str] disk_type_id: Type of the storage of a host. One of `network-hdd` (default) or `network-ssd`.
          """
          pulumi.set(__self__, "disk_size", disk_size)
          pulumi.set(__self__, "resource_preset_id", resource_preset_id)
          if disk_type_id is not None:
              pulumi.set(__self__, "disk_type_id", disk_type_id)
  
      @property
      @pulumi.getter(name="diskSize")
      def disk_size(self) -> pulumi.Input[int]:
          """
          Volume of the storage available to a host, in gigabytes.
          """
          return pulumi.get(self, "disk_size")
  
      @disk_size.setter
      def disk_size(self, value: pulumi.Input[int]):
          pulumi.set(self, "disk_size", value)
  
      @property
      @pulumi.getter(name="resourcePresetId")
      def resource_preset_id(self) -> pulumi.Input[str]:
          """
          The ID of the preset for computational resources available to a host. All available presets are listed in the [documentation](https://cloud.yandex.com/docs/data-proc/concepts/instance-types).
          """
          return pulumi.get(self, "resource_preset_id")
  
      @resource_preset_id.setter
      def resource_preset_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "resource_preset_id", value)
  
      @property
      @pulumi.getter(name="diskTypeId")
      def disk_type_id(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the storage of a host. One of `network-hdd` (default) or `network-ssd`.
          """
          return pulumi.get(self, "disk_type_id")
  
      @disk_type_id.setter
      def disk_type_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "disk_type_id", value)
  
  
  @pulumi.input_type
  class FunctionContentArgs:
      def __init__(__self__, *,
                   zip_filename: pulumi.Input[str]):
          pulumi.set(__self__, "zip_filename", zip_filename)
  
      @property
      @pulumi.getter(name="zipFilename")
      def zip_filename(self) -> pulumi.Input[str]:
          return pulumi.get(self, "zip_filename")
  
      @zip_filename.setter
      def zip_filename(self, value: pulumi.Input[str]):
          pulumi.set(self, "zip_filename", value)
  
  
  @pulumi.input_type
  class FunctionPackageArgs:
      def __init__(__self__, *,
                   bucket_name: pulumi.Input[str],
                   object_name: pulumi.Input[str],
                   sha256: Optional[pulumi.Input[str]] = None):
          pulumi.set(__self__, "bucket_name", bucket_name)
          pulumi.set(__self__, "object_name", object_name)
          if sha256 is not None:
              pulumi.set(__self__, "sha256", sha256)
  
      @property
      @pulumi.getter(name="bucketName")
      def bucket_name(self) -> pulumi.Input[str]:
          return pulumi.get(self, "bucket_name")
  
      @bucket_name.setter
      def bucket_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "bucket_name", value)
  
      @property
      @pulumi.getter(name="objectName")
      def object_name(self) -> pulumi.Input[str]:
          return pulumi.get(self, "object_name")
  
      @object_name.setter
      def object_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "object_name", value)
  
      @property
      @pulumi.getter
      def sha256(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "sha256")
  
      @sha256.setter
      def sha256(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "sha256", value)
  
  
  @pulumi.input_type
  class FunctionScalingPolicyPolicyArgs:
      def __init__(__self__, *,
                   tag: pulumi.Input[str],
                   zone_instances_limit: Optional[pulumi.Input[int]] = None,
                   zone_requests_limit: Optional[pulumi.Input[int]] = None):
          pulumi.set(__self__, "tag", tag)
          if zone_instances_limit is not None:
              pulumi.set(__self__, "zone_instances_limit", zone_instances_limit)
          if zone_requests_limit is not None:
              pulumi.set(__self__, "zone_requests_limit", zone_requests_limit)
  
      @property
      @pulumi.getter
      def tag(self) -> pulumi.Input[str]:
          return pulumi.get(self, "tag")
  
      @tag.setter
      def tag(self, value: pulumi.Input[str]):
          pulumi.set(self, "tag", value)
  
      @property
      @pulumi.getter(name="zoneInstancesLimit")
      def zone_instances_limit(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "zone_instances_limit")
  
      @zone_instances_limit.setter
      def zone_instances_limit(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "zone_instances_limit", value)
  
      @property
      @pulumi.getter(name="zoneRequestsLimit")
      def zone_requests_limit(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "zone_requests_limit")
  
      @zone_requests_limit.setter
      def zone_requests_limit(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "zone_requests_limit", value)
  
  
  @pulumi.input_type
  class FunctionTriggerDlqArgs:
      def __init__(__self__, *,
                   queue_id: pulumi.Input[str],
                   service_account_id: pulumi.Input[str]):
          pulumi.set(__self__, "queue_id", queue_id)
          pulumi.set(__self__, "service_account_id", service_account_id)
  
      @property
      @pulumi.getter(name="queueId")
      def queue_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "queue_id")
  
      @queue_id.setter
      def queue_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "queue_id", value)
  
      @property
      @pulumi.getter(name="serviceAccountId")
      def service_account_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "service_account_id")
  
      @service_account_id.setter
      def service_account_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "service_account_id", value)
  
  
  @pulumi.input_type
  class FunctionTriggerFunctionArgs:
      def __init__(__self__, *,
                   id: pulumi.Input[str],
                   retry_attempts: Optional[pulumi.Input[str]] = None,
                   retry_interval: Optional[pulumi.Input[str]] = None,
                   service_account_id: Optional[pulumi.Input[str]] = None,
                   tag: Optional[pulumi.Input[str]] = None):
          pulumi.set(__self__, "id", id)
          if retry_attempts is not None:
              pulumi.set(__self__, "retry_attempts", retry_attempts)
          if retry_interval is not None:
              pulumi.set(__self__, "retry_interval", retry_interval)
          if service_account_id is not None:
              pulumi.set(__self__, "service_account_id", service_account_id)
          if tag is not None:
              pulumi.set(__self__, "tag", tag)
  
      @property
      @pulumi.getter
      def id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: pulumi.Input[str]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="retryAttempts")
      def retry_attempts(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "retry_attempts")
  
      @retry_attempts.setter
      def retry_attempts(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "retry_attempts", value)
  
      @property
      @pulumi.getter(name="retryInterval")
      def retry_interval(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "retry_interval")
  
      @retry_interval.setter
      def retry_interval(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "retry_interval", value)
  
      @property
      @pulumi.getter(name="serviceAccountId")
      def service_account_id(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "service_account_id")
  
      @service_account_id.setter
      def service_account_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "service_account_id", value)
  
      @property
      @pulumi.getter
      def tag(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "tag")
  
      @tag.setter
      def tag(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "tag", value)
  
  
  @pulumi.input_type
  class FunctionTriggerIotArgs:
      def __init__(__self__, *,
                   registry_id: pulumi.Input[str],
                   device_id: Optional[pulumi.Input[str]] = None,
                   topic: Optional[pulumi.Input[str]] = None):
          pulumi.set(__self__, "registry_id", registry_id)
          if device_id is not None:
              pulumi.set(__self__, "device_id", device_id)
          if topic is not None:
              pulumi.set(__self__, "topic", topic)
  
      @property
      @pulumi.getter(name="registryId")
      def registry_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "registry_id")
  
      @registry_id.setter
      def registry_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "registry_id", value)
  
      @property
      @pulumi.getter(name="deviceId")
      def device_id(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "device_id")
  
      @device_id.setter
      def device_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "device_id", value)
  
      @property
      @pulumi.getter
      def topic(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "topic")
  
      @topic.setter
      def topic(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "topic", value)
  
  
  @pulumi.input_type
  class FunctionTriggerLogGroupArgs:
      def __init__(__self__, *,
                   batch_cutoff: pulumi.Input[str],
                   log_group_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
                   batch_size: Optional[pulumi.Input[str]] = None):
          pulumi.set(__self__, "batch_cutoff", batch_cutoff)
          pulumi.set(__self__, "log_group_ids", log_group_ids)
          if batch_size is not None:
              pulumi.set(__self__, "batch_size", batch_size)
  
      @property
      @pulumi.getter(name="batchCutoff")
      def batch_cutoff(self) -> pulumi.Input[str]:
          return pulumi.get(self, "batch_cutoff")
  
      @batch_cutoff.setter
      def batch_cutoff(self, value: pulumi.Input[str]):
          pulumi.set(self, "batch_cutoff", value)
  
      @property
      @pulumi.getter(name="logGroupIds")
      def log_group_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          return pulumi.get(self, "log_group_ids")
  
      @log_group_ids.setter
      def log_group_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "log_group_ids", value)
  
      @property
      @pulumi.getter(name="batchSize")
      def batch_size(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "batch_size")
  
      @batch_size.setter
      def batch_size(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "batch_size", value)
  
  
  @pulumi.input_type
  class FunctionTriggerLoggingArgs:
      def __init__(__self__, *,
                   batch_cutoff: pulumi.Input[str],
                   group_id: pulumi.Input[str],
                   levels: pulumi.Input[Sequence[pulumi.Input[str]]],
                   resource_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
                   resource_types: pulumi.Input[Sequence[pulumi.Input[str]]],
                   batch_size: Optional[pulumi.Input[str]] = None):
          pulumi.set(__self__, "batch_cutoff", batch_cutoff)
          pulumi.set(__self__, "group_id", group_id)
          pulumi.set(__self__, "levels", levels)
          pulumi.set(__self__, "resource_ids", resource_ids)
          pulumi.set(__self__, "resource_types", resource_types)
          if batch_size is not None:
              pulumi.set(__self__, "batch_size", batch_size)
  
      @property
      @pulumi.getter(name="batchCutoff")
      def batch_cutoff(self) -> pulumi.Input[str]:
          return pulumi.get(self, "batch_cutoff")
  
      @batch_cutoff.setter
      def batch_cutoff(self, value: pulumi.Input[str]):
          pulumi.set(self, "batch_cutoff", value)
  
      @property
      @pulumi.getter(name="groupId")
      def group_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "group_id")
  
      @group_id.setter
      def group_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "group_id", value)
  
      @property
      @pulumi.getter
      def levels(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          return pulumi.get(self, "levels")
  
      @levels.setter
      def levels(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "levels", value)
  
      @property
      @pulumi.getter(name="resourceIds")
      def resource_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          return pulumi.get(self, "resource_ids")
  
      @resource_ids.setter
      def resource_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "resource_ids", value)
  
      @property
      @pulumi.getter(name="resourceTypes")
      def resource_types(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          return pulumi.get(self, "resource_types")
  
      @resource_types.setter
      def resource_types(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "resource_types", value)
  
      @property
      @pulumi.getter(name="batchSize")
      def batch_size(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "batch_size")
  
      @batch_size.setter
      def batch_size(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "batch_size", value)
  
  
  @pulumi.input_type
  class FunctionTriggerMessageQueueArgs:
      def __init__(__self__, *,
                   batch_cutoff: pulumi.Input[str],
                   queue_id: pulumi.Input[str],
                   service_account_id: pulumi.Input[str],
                   batch_size: Optional[pulumi.Input[str]] = None,
                   visibility_timeout: Optional[pulumi.Input[str]] = None):
          pulumi.set(__self__, "batch_cutoff", batch_cutoff)
          pulumi.set(__self__, "queue_id", queue_id)
          pulumi.set(__self__, "service_account_id", service_account_id)
          if batch_size is not None:
              pulumi.set(__self__, "batch_size", batch_size)
          if visibility_timeout is not None:
              pulumi.set(__self__, "visibility_timeout", visibility_timeout)
  
      @property
      @pulumi.getter(name="batchCutoff")
      def batch_cutoff(self) -> pulumi.Input[str]:
          return pulumi.get(self, "batch_cutoff")
  
      @batch_cutoff.setter
      def batch_cutoff(self, value: pulumi.Input[str]):
          pulumi.set(self, "batch_cutoff", value)
  
      @property
      @pulumi.getter(name="queueId")
      def queue_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "queue_id")
  
      @queue_id.setter
      def queue_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "queue_id", value)
  
      @property
      @pulumi.getter(name="serviceAccountId")
      def service_account_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "service_account_id")
  
      @service_account_id.setter
      def service_account_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "service_account_id", value)
  
      @property
      @pulumi.getter(name="batchSize")
      def batch_size(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "batch_size")
  
      @batch_size.setter
      def batch_size(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "batch_size", value)
  
      @property
      @pulumi.getter(name="visibilityTimeout")
      def visibility_timeout(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "visibility_timeout")
  
      @visibility_timeout.setter
      def visibility_timeout(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "visibility_timeout", value)
  
  
  @pulumi.input_type
  class FunctionTriggerObjectStorageArgs:
      def __init__(__self__, *,
                   bucket_id: pulumi.Input[str],
                   create: Optional[pulumi.Input[bool]] = None,
                   delete: Optional[pulumi.Input[bool]] = None,
                   prefix: Optional[pulumi.Input[str]] = None,
                   suffix: Optional[pulumi.Input[str]] = None,
                   update: Optional[pulumi.Input[bool]] = None):
          pulumi.set(__self__, "bucket_id", bucket_id)
          if create is not None:
              pulumi.set(__self__, "create", create)
          if delete is not None:
              pulumi.set(__self__, "delete", delete)
          if prefix is not None:
              pulumi.set(__self__, "prefix", prefix)
          if suffix is not None:
              pulumi.set(__self__, "suffix", suffix)
          if update is not None:
              pulumi.set(__self__, "update", update)
  
      @property
      @pulumi.getter(name="bucketId")
      def bucket_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "bucket_id")
  
      @bucket_id.setter
      def bucket_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "bucket_id", value)
  
      @property
      @pulumi.getter
      def create(self) -> Optional[pulumi.Input[bool]]:
          return pulumi.get(self, "create")
  
      @create.setter
      def create(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "create", value)
  
      @property
      @pulumi.getter
      def delete(self) -> Optional[pulumi.Input[bool]]:
          return pulumi.get(self, "delete")
  
      @delete.setter
      def delete(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "delete", value)
  
      @property
      @pulumi.getter
      def prefix(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "prefix")
  
      @prefix.setter
      def prefix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "prefix", value)
  
      @property
      @pulumi.getter
      def suffix(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "suffix")
  
      @suffix.setter
      def suffix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "suffix", value)
  
      @property
      @pulumi.getter
      def update(self) -> Optional[pulumi.Input[bool]]:
          return pulumi.get(self, "update")
  
      @update.setter
      def update(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "update", value)
  
  
  @pulumi.input_type
  class FunctionTriggerTimerArgs:
      def __init__(__self__, *,
                   cron_expression: pulumi.Input[str]):
          pulumi.set(__self__, "cron_expression", cron_expression)
  
      @property
      @pulumi.getter(name="cronExpression")
      def cron_expression(self) -> pulumi.Input[str]:
          return pulumi.get(self, "cron_expression")
  
      @cron_expression.setter
      def cron_expression(self, value: pulumi.Input[str]):
          pulumi.set(self, "cron_expression", value)
  
  
  @pulumi.input_type
  class KubernetesClusterKmsProviderArgs:
      def __init__(__self__, *,
                   key_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] key_id: KMS key ID.
          """
          if key_id is not None:
              pulumi.set(__self__, "key_id", key_id)
  
      @property
      @pulumi.getter(name="keyId")
      def key_id(self) -> Optional[pulumi.Input[str]]:
          """
          KMS key ID.
          """
          return pulumi.get(self, "key_id")
  
      @key_id.setter
      def key_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "key_id", value)
  
  
  @pulumi.input_type
  class KubernetesClusterMasterArgs:
      def __init__(__self__, *,
                   cluster_ca_certificate: Optional[pulumi.Input[str]] = None,
                   external_v4_address: Optional[pulumi.Input[str]] = None,
                   external_v4_endpoint: Optional[pulumi.Input[str]] = None,
                   internal_v4_address: Optional[pulumi.Input[str]] = None,
                   internal_v4_endpoint: Optional[pulumi.Input[str]] = None,
                   maintenance_policy: Optional[pulumi.Input['KubernetesClusterMasterMaintenancePolicyArgs']] = None,
                   public_ip: Optional[pulumi.Input[bool]] = None,
                   regional: Optional[pulumi.Input['KubernetesClusterMasterRegionalArgs']] = None,
                   security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   version: Optional[pulumi.Input[str]] = None,
                   version_info: Optional[pulumi.Input['KubernetesClusterMasterVersionInfoArgs']] = None,
                   zonal: Optional[pulumi.Input['KubernetesClusterMasterZonalArgs']] = None):
          """
          :param pulumi.Input[str] cluster_ca_certificate: (Computed) PEM-encoded public certificate that is the root of trust for the Kubernetes cluster.
          :param pulumi.Input[str] external_v4_address: (Computed) An IPv4 external network address that is assigned to the master.
          :param pulumi.Input[str] external_v4_endpoint: (Computed) External endpoint that can be used to access Kubernetes cluster API from the internet (outside of the cloud).
          :param pulumi.Input[str] internal_v4_address: (Computed) An IPv4 internal network address that is assigned to the master.
          :param pulumi.Input[str] internal_v4_endpoint: (Computed) Internal endpoint that can be used to connect to the master from cloud networks.
          :param pulumi.Input['KubernetesClusterMasterMaintenancePolicyArgs'] maintenance_policy: (Optional) (Computed) Maintenance policy for Kubernetes master.
                 If policy is omitted, automatic revision upgrades of the kubernetes master are enabled and could happen at any time.
                 Revision upgrades are performed only within the same minor version, e.g. 1.13.
                 Minor version upgrades (e.g. 1.13->1.14) should be performed manually. The structure is documented below.
          :param pulumi.Input[bool] public_ip: (Optional) (Computed) Boolean flag. When `true`, Kubernetes master will have visible ipv4 address.
          :param pulumi.Input['KubernetesClusterMasterRegionalArgs'] regional: (Optional) Initialize parameters for Regional Master (highly available master). The structure is documented below.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] security_group_ids: (Optional) List of security group IDs to which the Kubernetes cluster belongs.
          :param pulumi.Input[str] version: (Optional) (Computed) Version of Kubernetes that will be used for master.
          :param pulumi.Input['KubernetesClusterMasterVersionInfoArgs'] version_info: (Computed) Information about cluster version. The structure is documented below.
          :param pulumi.Input['KubernetesClusterMasterZonalArgs'] zonal: (Optional) Initialize parameters for Zonal Master (single node master). The structure is documented below.
          """
          if cluster_ca_certificate is not None:
              pulumi.set(__self__, "cluster_ca_certificate", cluster_ca_certificate)
          if external_v4_address is not None:
              pulumi.set(__self__, "external_v4_address", external_v4_address)
          if external_v4_endpoint is not None:
              pulumi.set(__self__, "external_v4_endpoint", external_v4_endpoint)
          if internal_v4_address is not None:
              pulumi.set(__self__, "internal_v4_address", internal_v4_address)
          if internal_v4_endpoint is not None:
              pulumi.set(__self__, "internal_v4_endpoint", internal_v4_endpoint)
          if maintenance_policy is not None:
              pulumi.set(__self__, "maintenance_policy", maintenance_policy)
          if public_ip is not None:
              pulumi.set(__self__, "public_ip", public_ip)
          if regional is not None:
              pulumi.set(__self__, "regional", regional)
          if security_group_ids is not None:
              pulumi.set(__self__, "security_group_ids", security_group_ids)
          if version is not None:
              pulumi.set(__self__, "version", version)
          if version_info is not None:
              pulumi.set(__self__, "version_info", version_info)
          if zonal is not None:
              pulumi.set(__self__, "zonal", zonal)
  
      @property
      @pulumi.getter(name="clusterCaCertificate")
      def cluster_ca_certificate(self) -> Optional[pulumi.Input[str]]:
          """
          (Computed) PEM-encoded public certificate that is the root of trust for the Kubernetes cluster.
          """
          return pulumi.get(self, "cluster_ca_certificate")
  
      @cluster_ca_certificate.setter
      def cluster_ca_certificate(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "cluster_ca_certificate", value)
  
      @property
      @pulumi.getter(name="externalV4Address")
      def external_v4_address(self) -> Optional[pulumi.Input[str]]:
          """
          (Computed) An IPv4 external network address that is assigned to the master.
          """
          return pulumi.get(self, "external_v4_address")
  
      @external_v4_address.setter
      def external_v4_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "external_v4_address", value)
  
      @property
      @pulumi.getter(name="externalV4Endpoint")
      def external_v4_endpoint(self) -> Optional[pulumi.Input[str]]:
          """
          (Computed) External endpoint that can be used to access Kubernetes cluster API from the internet (outside of the cloud).
          """
          return pulumi.get(self, "external_v4_endpoint")
  
      @external_v4_endpoint.setter
      def external_v4_endpoint(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "external_v4_endpoint", value)
  
      @property
      @pulumi.getter(name="internalV4Address")
      def internal_v4_address(self) -> Optional[pulumi.Input[str]]:
          """
          (Computed) An IPv4 internal network address that is assigned to the master.
          """
          return pulumi.get(self, "internal_v4_address")
  
      @internal_v4_address.setter
      def internal_v4_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "internal_v4_address", value)
  
      @property
      @pulumi.getter(name="internalV4Endpoint")
      def internal_v4_endpoint(self) -> Optional[pulumi.Input[str]]:
          """
          (Computed) Internal endpoint that can be used to connect to the master from cloud networks.
          """
          return pulumi.get(self, "internal_v4_endpoint")
  
      @internal_v4_endpoint.setter
      def internal_v4_endpoint(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "internal_v4_endpoint", value)
  
      @property
      @pulumi.getter(name="maintenancePolicy")
      def maintenance_policy(self) -> Optional[pulumi.Input['KubernetesClusterMasterMaintenancePolicyArgs']]:
          """
          (Optional) (Computed) Maintenance policy for Kubernetes master.
          If policy is omitted, automatic revision upgrades of the kubernetes master are enabled and could happen at any time.
          Revision upgrades are performed only within the same minor version, e.g. 1.13.
          Minor version upgrades (e.g. 1.13->1.14) should be performed manually. The structure is documented below.
          """
          return pulumi.get(self, "maintenance_policy")
  
      @maintenance_policy.setter
      def maintenance_policy(self, value: Optional[pulumi.Input['KubernetesClusterMasterMaintenancePolicyArgs']]):
          pulumi.set(self, "maintenance_policy", value)
  
      @property
      @pulumi.getter(name="publicIp")
      def public_ip(self) -> Optional[pulumi.Input[bool]]:
          """
          (Optional) (Computed) Boolean flag. When `true`, Kubernetes master will have visible ipv4 address.
          """
          return pulumi.get(self, "public_ip")
  
      @public_ip.setter
      def public_ip(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "public_ip", value)
  
      @property
      @pulumi.getter
      def regional(self) -> Optional[pulumi.Input['KubernetesClusterMasterRegionalArgs']]:
          """
          (Optional) Initialize parameters for Regional Master (highly available master). The structure is documented below.
          """
          return pulumi.get(self, "regional")
  
      @regional.setter
      def regional(self, value: Optional[pulumi.Input['KubernetesClusterMasterRegionalArgs']]):
          pulumi.set(self, "regional", value)
  
      @property
      @pulumi.getter(name="securityGroupIds")
      def security_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          (Optional) List of security group IDs to which the Kubernetes cluster belongs.
          """
          return pulumi.get(self, "security_group_ids")
  
      @security_group_ids.setter
      def security_group_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "security_group_ids", value)
  
      @property
      @pulumi.getter
      def version(self) -> Optional[pulumi.Input[str]]:
          """
          (Optional) (Computed) Version of Kubernetes that will be used for master.
          """
          return pulumi.get(self, "version")
  
      @version.setter
      def version(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "version", value)
  
      @property
      @pulumi.getter(name="versionInfo")
      def version_info(self) -> Optional[pulumi.Input['KubernetesClusterMasterVersionInfoArgs']]:
          """
          (Computed) Information about cluster version. The structure is documented below.
          """
          return pulumi.get(self, "version_info")
  
      @version_info.setter
      def version_info(self, value: Optional[pulumi.Input['KubernetesClusterMasterVersionInfoArgs']]):
          pulumi.set(self, "version_info", value)
  
      @property
      @pulumi.getter
      def zonal(self) -> Optional[pulumi.Input['KubernetesClusterMasterZonalArgs']]:
          """
          (Optional) Initialize parameters for Zonal Master (single node master). The structure is documented below.
          """
          return pulumi.get(self, "zonal")
  
      @zonal.setter
      def zonal(self, value: Optional[pulumi.Input['KubernetesClusterMasterZonalArgs']]):
          pulumi.set(self, "zonal", value)
  
  
  @pulumi.input_type
  class KubernetesClusterMasterMaintenancePolicyArgs:
      def __init__(__self__, *,
                   auto_upgrade: pulumi.Input[bool],
                   maintenance_windows: Optional[pulumi.Input[Sequence[pulumi.Input['KubernetesClusterMasterMaintenancePolicyMaintenanceWindowArgs']]]] = None):
          """
          :param pulumi.Input[bool] auto_upgrade: (Required) Boolean flag that specifies if master can be upgraded automatically. When omitted, default value is TRUE.
          :param pulumi.Input[Sequence[pulumi.Input['KubernetesClusterMasterMaintenancePolicyMaintenanceWindowArgs']]] maintenance_windows: (Optional) (Computed) This structure specifies maintenance window, when update for master is allowed. When omitted, it defaults to any time.
                 To specify time of day interval, for all days, one element should be provided, with two fields set, `start_time` and `duration`.
                 Please see `zonal_cluster_resource_name` config example.
          """
          pulumi.set(__self__, "auto_upgrade", auto_upgrade)
          if maintenance_windows is not None:
              pulumi.set(__self__, "maintenance_windows", maintenance_windows)
  
      @property
      @pulumi.getter(name="autoUpgrade")
      def auto_upgrade(self) -> pulumi.Input[bool]:
          """
          (Required) Boolean flag that specifies if master can be upgraded automatically. When omitted, default value is TRUE.
          """
          return pulumi.get(self, "auto_upgrade")
  
      @auto_upgrade.setter
      def auto_upgrade(self, value: pulumi.Input[bool]):
          pulumi.set(self, "auto_upgrade", value)
  
      @property
      @pulumi.getter(name="maintenanceWindows")
      def maintenance_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KubernetesClusterMasterMaintenancePolicyMaintenanceWindowArgs']]]]:
          """
          (Optional) (Computed) This structure specifies maintenance window, when update for master is allowed. When omitted, it defaults to any time.
          To specify time of day interval, for all days, one element should be provided, with two fields set, `start_time` and `duration`.
          Please see `zonal_cluster_resource_name` config example.
          """
          return pulumi.get(self, "maintenance_windows")
  
      @maintenance_windows.setter
      def maintenance_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['KubernetesClusterMasterMaintenancePolicyMaintenanceWindowArgs']]]]):
          pulumi.set(self, "maintenance_windows", value)
  
  
  @pulumi.input_type
  class KubernetesClusterMasterMaintenancePolicyMaintenanceWindowArgs:
      def __init__(__self__, *,
                   duration: pulumi.Input[str],
                   start_time: pulumi.Input[str],
                   day: Optional[pulumi.Input[str]] = None):
          pulumi.set(__self__, "duration", duration)
          pulumi.set(__self__, "start_time", start_time)
          if day is not None:
              pulumi.set(__self__, "day", day)
  
      @property
      @pulumi.getter
      def duration(self) -> pulumi.Input[str]:
          return pulumi.get(self, "duration")
  
      @duration.setter
      def duration(self, value: pulumi.Input[str]):
          pulumi.set(self, "duration", value)
  
      @property
      @pulumi.getter(name="startTime")
      def start_time(self) -> pulumi.Input[str]:
          return pulumi.get(self, "start_time")
  
      @start_time.setter
      def start_time(self, value: pulumi.Input[str]):
          pulumi.set(self, "start_time", value)
  
      @property
      @pulumi.getter
      def day(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "day")
  
      @day.setter
      def day(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "day", value)
  
  
  @pulumi.input_type
  class KubernetesClusterMasterRegionalArgs:
      def __init__(__self__, *,
                   region: pulumi.Input[str],
                   locations: Optional[pulumi.Input[Sequence[pulumi.Input['KubernetesClusterMasterRegionalLocationArgs']]]] = None):
          """
          :param pulumi.Input[str] region: (Required) Name of availability region (e.g. "ru-central1"), where master instances will be allocated.
          :param pulumi.Input[Sequence[pulumi.Input['KubernetesClusterMasterRegionalLocationArgs']]] locations: Array of locations, where master instances will be allocated. The structure is documented below.
          """
          pulumi.set(__self__, "region", region)
          if locations is not None:
              pulumi.set(__self__, "locations", locations)
  
      @property
      @pulumi.getter
      def region(self) -> pulumi.Input[str]:
          """
          (Required) Name of availability region (e.g. "ru-central1"), where master instances will be allocated.
          """
          return pulumi.get(self, "region")
  
      @region.setter
      def region(self, value: pulumi.Input[str]):
          pulumi.set(self, "region", value)
  
      @property
      @pulumi.getter
      def locations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KubernetesClusterMasterRegionalLocationArgs']]]]:
          """
          Array of locations, where master instances will be allocated. The structure is documented below.
          """
          return pulumi.get(self, "locations")
  
      @locations.setter
      def locations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['KubernetesClusterMasterRegionalLocationArgs']]]]):
          pulumi.set(self, "locations", value)
  
  
  @pulumi.input_type
  class KubernetesClusterMasterRegionalLocationArgs:
      def __init__(__self__, *,
                   subnet_id: Optional[pulumi.Input[str]] = None,
                   zone: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] subnet_id: (Optional) ID of the subnet.
          :param pulumi.Input[str] zone: (Optional) ID of the availability zone.
          """
          if subnet_id is not None:
              pulumi.set(__self__, "subnet_id", subnet_id)
          if zone is not None:
              pulumi.set(__self__, "zone", zone)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> Optional[pulumi.Input[str]]:
          """
          (Optional) ID of the subnet.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "subnet_id", value)
  
      @property
      @pulumi.getter
      def zone(self) -> Optional[pulumi.Input[str]]:
          """
          (Optional) ID of the availability zone.
          """
          return pulumi.get(self, "zone")
  
      @zone.setter
      def zone(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "zone", value)
  
  
  @pulumi.input_type
  class KubernetesClusterMasterVersionInfoArgs:
      def __init__(__self__, *,
                   current_version: Optional[pulumi.Input[str]] = None,
                   new_revision_available: Optional[pulumi.Input[bool]] = None,
                   new_revision_summary: Optional[pulumi.Input[str]] = None,
                   version_deprecated: Optional[pulumi.Input[bool]] = None):
          """
          :param pulumi.Input[str] current_version: Current Kubernetes version, major.minor (e.g. 1.15).
          :param pulumi.Input[bool] new_revision_available: Boolean flag.
                 Newer revisions may include Kubernetes patches (e.g 1.15.1 > 1.15.2) as well
                 as some internal component updates - new features or bug fixes in yandex-specific
                 components either on the master or nodes.
          :param pulumi.Input[str] new_revision_summary: Human readable description of the changes to be applied
                 when updating to the latest revision. Empty if new_revision_available is false.
          :param pulumi.Input[bool] version_deprecated: Boolean flag. The current version is on the deprecation schedule,
                 component (master or node group) should be upgraded.
          """
          if current_version is not None:
              pulumi.set(__self__, "current_version", current_version)
          if new_revision_available is not None:
              pulumi.set(__self__, "new_revision_available", new_revision_available)
          if new_revision_summary is not None:
              pulumi.set(__self__, "new_revision_summary", new_revision_summary)
          if version_deprecated is not None:
              pulumi.set(__self__, "version_deprecated", version_deprecated)
  
      @property
      @pulumi.getter(name="currentVersion")
      def current_version(self) -> Optional[pulumi.Input[str]]:
          """
          Current Kubernetes version, major.minor (e.g. 1.15).
          """
          return pulumi.get(self, "current_version")
  
      @current_version.setter
      def current_version(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "current_version", value)
  
      @property
      @pulumi.getter(name="newRevisionAvailable")
      def new_revision_available(self) -> Optional[pulumi.Input[bool]]:
          """
          Boolean flag.
          Newer revisions may include Kubernetes patches (e.g 1.15.1 > 1.15.2) as well
          as some internal component updates - new features or bug fixes in yandex-specific
          components either on the master or nodes.
          """
          return pulumi.get(self, "new_revision_available")
  
      @new_revision_available.setter
      def new_revision_available(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "new_revision_available", value)
  
      @property
      @pulumi.getter(name="newRevisionSummary")
      def new_revision_summary(self) -> Optional[pulumi.Input[str]]:
          """
          Human readable description of the changes to be applied
          when updating to the latest revision. Empty if new_revision_available is false.
          """
          return pulumi.get(self, "new_revision_summary")
  
      @new_revision_summary.setter
      def new_revision_summary(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "new_revision_summary", value)
  
      @property
      @pulumi.getter(name="versionDeprecated")
      def version_deprecated(self) -> Optional[pulumi.Input[bool]]:
          """
          Boolean flag. The current version is on the deprecation schedule,
          component (master or node group) should be upgraded.
          """
          return pulumi.get(self, "version_deprecated")
  
      @version_deprecated.setter
      def version_deprecated(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "version_deprecated", value)
  
  
  @pulumi.input_type
  class KubernetesClusterMasterZonalArgs:
      def __init__(__self__, *,
                   subnet_id: Optional[pulumi.Input[str]] = None,
                   zone: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] subnet_id: (Optional) ID of the subnet.
          :param pulumi.Input[str] zone: (Optional) ID of the availability zone.
          """
          if subnet_id is not None:
              pulumi.set(__self__, "subnet_id", subnet_id)
          if zone is not None:
              pulumi.set(__self__, "zone", zone)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> Optional[pulumi.Input[str]]:
          """
          (Optional) ID of the subnet.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "subnet_id", value)
  
      @property
      @pulumi.getter
      def zone(self) -> Optional[pulumi.Input[str]]:
          """
          (Optional) ID of the availability zone.
          """
          return pulumi.get(self, "zone")
  
      @zone.setter
      def zone(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "zone", value)
  
  
  @pulumi.input_type
  class KubernetesClusterNetworkImplementationArgs:
      def __init__(__self__, *,
                   cilium: Optional[pulumi.Input['KubernetesClusterNetworkImplementationCiliumArgs']] = None):
          """
          :param pulumi.Input['KubernetesClusterNetworkImplementationCiliumArgs'] cilium: (Optional) Cilium network implementation configuration. No options exist.
          """
          if cilium is not None:
              pulumi.set(__self__, "cilium", cilium)
  
      @property
      @pulumi.getter
      def cilium(self) -> Optional[pulumi.Input['KubernetesClusterNetworkImplementationCiliumArgs']]:
          """
          (Optional) Cilium network implementation configuration. No options exist.
          """
          return pulumi.get(self, "cilium")
  
      @cilium.setter
      def cilium(self, value: Optional[pulumi.Input['KubernetesClusterNetworkImplementationCiliumArgs']]):
          pulumi.set(self, "cilium", value)
  
  
  @pulumi.input_type
  class KubernetesClusterNetworkImplementationCiliumArgs:
      def __init__(__self__):
          pass
  
  
  @pulumi.input_type
  class KubernetesNodeGroupAllocationPolicyArgs:
      def __init__(__self__, *,
                   locations: Optional[pulumi.Input[Sequence[pulumi.Input['KubernetesNodeGroupAllocationPolicyLocationArgs']]]] = None):
          """
          :param pulumi.Input[Sequence[pulumi.Input['KubernetesNodeGroupAllocationPolicyLocationArgs']]] locations: Repeated field, that specify subnets (zones), that will be used by node group compute instances. The structure is documented below.
          """
          if locations is not None:
              pulumi.set(__self__, "locations", locations)
  
      @property
      @pulumi.getter
      def locations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KubernetesNodeGroupAllocationPolicyLocationArgs']]]]:
          """
          Repeated field, that specify subnets (zones), that will be used by node group compute instances. The structure is documented below.
          """
          return pulumi.get(self, "locations")
  
      @locations.setter
      def locations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['KubernetesNodeGroupAllocationPolicyLocationArgs']]]]):
          pulumi.set(self, "locations", value)
  
  
  @pulumi.input_type
  class KubernetesNodeGroupAllocationPolicyLocationArgs:
      def __init__(__self__, *,
                   subnet_id: Optional[pulumi.Input[str]] = None,
                   zone: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] subnet_id: ID of the subnet, that will be used by one compute instance in node group.
          :param pulumi.Input[str] zone: ID of the availability zone where for one compute instance in node group.
          """
          if subnet_id is not None:
              warnings.warn("""The 'subnet_id' field has been deprecated. Please use 'subnet_ids under network_interface' instead.""", DeprecationWarning)
              pulumi.log.warn("""subnet_id is deprecated: The 'subnet_id' field has been deprecated. Please use 'subnet_ids under network_interface' instead.""")
          if subnet_id is not None:
              pulumi.set(__self__, "subnet_id", subnet_id)
          if zone is not None:
              pulumi.set(__self__, "zone", zone)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> Optional[pulumi.Input[str]]:
          """
          ID of the subnet, that will be used by one compute instance in node group.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "subnet_id", value)
  
      @property
      @pulumi.getter
      def zone(self) -> Optional[pulumi.Input[str]]:
          """
          ID of the availability zone where for one compute instance in node group.
          """
          return pulumi.get(self, "zone")
  
      @zone.setter
      def zone(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "zone", value)
  
  
  @pulumi.input_type
  class KubernetesNodeGroupDeployPolicyArgs:
      def __init__(__self__, *,
                   max_expansion: pulumi.Input[int],
                   max_unavailable: pulumi.Input[int]):
          """
          :param pulumi.Input[int] max_expansion: The maximum number of instances that can be temporarily allocated above the group's target size during the update.
          :param pulumi.Input[int] max_unavailable: The maximum number of running instances that can be taken offline during update.
          """
          pulumi.set(__self__, "max_expansion", max_expansion)
          pulumi.set(__self__, "max_unavailable", max_unavailable)
  
      @property
      @pulumi.getter(name="maxExpansion")
      def max_expansion(self) -> pulumi.Input[int]:
          """
          The maximum number of instances that can be temporarily allocated above the group's target size during the update.
          """
          return pulumi.get(self, "max_expansion")
  
      @max_expansion.setter
      def max_expansion(self, value: pulumi.Input[int]):
          pulumi.set(self, "max_expansion", value)
  
      @property
      @pulumi.getter(name="maxUnavailable")
      def max_unavailable(self) -> pulumi.Input[int]:
          """
          The maximum number of running instances that can be taken offline during update.
          """
          return pulumi.get(self, "max_unavailable")
  
      @max_unavailable.setter
      def max_unavailable(self, value: pulumi.Input[int]):
          pulumi.set(self, "max_unavailable", value)
  
  
  @pulumi.input_type
  class KubernetesNodeGroupInstanceTemplateArgs:
      def __init__(__self__, *,
                   boot_disk: Optional[pulumi.Input['KubernetesNodeGroupInstanceTemplateBootDiskArgs']] = None,
                   metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   nat: Optional[pulumi.Input[bool]] = None,
                   network_acceleration_type: Optional[pulumi.Input[str]] = None,
                   network_interfaces: Optional[pulumi.Input[Sequence[pulumi.Input['KubernetesNodeGroupInstanceTemplateNetworkInterfaceArgs']]]] = None,
                   placement_policy: Optional[pulumi.Input['KubernetesNodeGroupInstanceTemplatePlacementPolicyArgs']] = None,
                   platform_id: Optional[pulumi.Input[str]] = None,
                   resources: Optional[pulumi.Input['KubernetesNodeGroupInstanceTemplateResourcesArgs']] = None,
                   scheduling_policy: Optional[pulumi.Input['KubernetesNodeGroupInstanceTemplateSchedulingPolicyArgs']] = None):
          """
          :param pulumi.Input['KubernetesNodeGroupInstanceTemplateBootDiskArgs'] boot_disk: The specifications for boot disks that will be attached to the instance. The structure is documented below.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] metadata: The set of metadata `key:value` pairs assigned to this instance template. This includes custom metadata and predefined keys.
                 * `resources.0.memory` - The memory size allocated to the instance.
                 * `resources.0.cores` - Number of CPU cores allocated to the instance.
                 * `resources.0.core_fraction` - Baseline core performance as a percent.
                 * `resources.0.gpus` - Number of GPU cores allocated to the instance.
          :param pulumi.Input[bool] nat: A public address that can be used to access the internet over NAT.
          :param pulumi.Input[str] network_acceleration_type: Type of network acceleration. Values: `standard`, `software_accelerated`.
          :param pulumi.Input[Sequence[pulumi.Input['KubernetesNodeGroupInstanceTemplateNetworkInterfaceArgs']]] network_interfaces: An array with the network interfaces that will be attached to the instance. The structure is documented below.
          :param pulumi.Input['KubernetesNodeGroupInstanceTemplatePlacementPolicyArgs'] placement_policy: The placement policy configuration. The structure is documented below.
          :param pulumi.Input[str] platform_id: The ID of the hardware platform configuration for the node group compute instances.
          :param pulumi.Input['KubernetesNodeGroupInstanceTemplateSchedulingPolicyArgs'] scheduling_policy: The scheduling policy for the instances in node group. The structure is documented below.
          """
          if boot_disk is not None:
              pulumi.set(__self__, "boot_disk", boot_disk)
          if metadata is not None:
              pulumi.set(__self__, "metadata", metadata)
          if nat is not None:
              warnings.warn("""The 'nat' field has been deprecated. Please use 'nat under network_interface' instead.""", DeprecationWarning)
              pulumi.log.warn("""nat is deprecated: The 'nat' field has been deprecated. Please use 'nat under network_interface' instead.""")
          if nat is not None:
              pulumi.set(__self__, "nat", nat)
          if network_acceleration_type is not None:
              pulumi.set(__self__, "network_acceleration_type", network_acceleration_type)
          if network_interfaces is not None:
              pulumi.set(__self__, "network_interfaces", network_interfaces)
          if placement_policy is not None:
              pulumi.set(__self__, "placement_policy", placement_policy)
          if platform_id is not None:
              pulumi.set(__self__, "platform_id", platform_id)
          if resources is not None:
              pulumi.set(__self__, "resources", resources)
          if scheduling_policy is not None:
              pulumi.set(__self__, "scheduling_policy", scheduling_policy)
  
      @property
      @pulumi.getter(name="bootDisk")
      def boot_disk(self) -> Optional[pulumi.Input['KubernetesNodeGroupInstanceTemplateBootDiskArgs']]:
          """
          The specifications for boot disks that will be attached to the instance. The structure is documented below.
          """
          return pulumi.get(self, "boot_disk")
  
      @boot_disk.setter
      def boot_disk(self, value: Optional[pulumi.Input['KubernetesNodeGroupInstanceTemplateBootDiskArgs']]):
          pulumi.set(self, "boot_disk", value)
  
      @property
      @pulumi.getter
      def metadata(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          The set of metadata `key:value` pairs assigned to this instance template. This includes custom metadata and predefined keys.
          * `resources.0.memory` - The memory size allocated to the instance.
          * `resources.0.cores` - Number of CPU cores allocated to the instance.
          * `resources.0.core_fraction` - Baseline core performance as a percent.
          * `resources.0.gpus` - Number of GPU cores allocated to the instance.
          """
          return pulumi.get(self, "metadata")
  
      @metadata.setter
      def metadata(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "metadata", value)
  
      @property
      @pulumi.getter
      def nat(self) -> Optional[pulumi.Input[bool]]:
          """
          A public address that can be used to access the internet over NAT.
          """
          return pulumi.get(self, "nat")
  
      @nat.setter
      def nat(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "nat", value)
  
      @property
      @pulumi.getter(name="networkAccelerationType")
      def network_acceleration_type(self) -> Optional[pulumi.Input[str]]:
          """
          Type of network acceleration. Values: `standard`, `software_accelerated`.
          """
          return pulumi.get(self, "network_acceleration_type")
  
      @network_acceleration_type.setter
      def network_acceleration_type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "network_acceleration_type", value)
  
      @property
      @pulumi.getter(name="networkInterfaces")
      def network_interfaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KubernetesNodeGroupInstanceTemplateNetworkInterfaceArgs']]]]:
          """
          An array with the network interfaces that will be attached to the instance. The structure is documented below.
          """
          return pulumi.get(self, "network_interfaces")
  
      @network_interfaces.setter
      def network_interfaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['KubernetesNodeGroupInstanceTemplateNetworkInterfaceArgs']]]]):
          pulumi.set(self, "network_interfaces", value)
  
      @property
      @pulumi.getter(name="placementPolicy")
      def placement_policy(self) -> Optional[pulumi.Input['KubernetesNodeGroupInstanceTemplatePlacementPolicyArgs']]:
          """
          The placement policy configuration. The structure is documented below.
          """
          return pulumi.get(self, "placement_policy")
  
      @placement_policy.setter
      def placement_policy(self, value: Optional[pulumi.Input['KubernetesNodeGroupInstanceTemplatePlacementPolicyArgs']]):
          pulumi.set(self, "placement_policy", value)
  
      @property
      @pulumi.getter(name="platformId")
      def platform_id(self) -> Optional[pulumi.Input[str]]:
          """
          The ID of the hardware platform configuration for the node group compute instances.
          """
          return pulumi.get(self, "platform_id")
  
      @platform_id.setter
      def platform_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "platform_id", value)
  
      @property
      @pulumi.getter
      def resources(self) -> Optional[pulumi.Input['KubernetesNodeGroupInstanceTemplateResourcesArgs']]:
          return pulumi.get(self, "resources")
  
      @resources.setter
      def resources(self, value: Optional[pulumi.Input['KubernetesNodeGroupInstanceTemplateResourcesArgs']]):
          pulumi.set(self, "resources", value)
  
      @property
      @pulumi.getter(name="schedulingPolicy")
      def scheduling_policy(self) -> Optional[pulumi.Input['KubernetesNodeGroupInstanceTemplateSchedulingPolicyArgs']]:
          """
          The scheduling policy for the instances in node group. The structure is documented below.
          """
          return pulumi.get(self, "scheduling_policy")
  
      @scheduling_policy.setter
      def scheduling_policy(self, value: Optional[pulumi.Input['KubernetesNodeGroupInstanceTemplateSchedulingPolicyArgs']]):
          pulumi.set(self, "scheduling_policy", value)
  
  
  @pulumi.input_type
  class KubernetesNodeGroupInstanceTemplateBootDiskArgs:
      def __init__(__self__, *,
                   size: Optional[pulumi.Input[int]] = None,
                   type: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[int] size: The number of instances in the node group.
          :param pulumi.Input[str] type: The disk type.
          """
          if size is not None:
              pulumi.set(__self__, "size", size)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter
      def size(self) -> Optional[pulumi.Input[int]]:
          """
          The number of instances in the node group.
          """
          return pulumi.get(self, "size")
  
      @size.setter
      def size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "size", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          The disk type.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class KubernetesNodeGroupInstanceTemplateNetworkInterfaceArgs:
      def __init__(__self__, *,
                   subnet_ids: pulumi.Input[Sequence[pulumi.Input[str]]],
                   ipv4: Optional[pulumi.Input[bool]] = None,
                   ipv6: Optional[pulumi.Input[bool]] = None,
                   nat: Optional[pulumi.Input[bool]] = None,
                   security_group_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          :param pulumi.Input[Sequence[pulumi.Input[str]]] subnet_ids: The IDs of the subnets.
          :param pulumi.Input[bool] ipv4: Allocate an IPv4 address for the interface. The default value is `true`.
          :param pulumi.Input[bool] ipv6: If true, allocate an IPv6 address for the interface. The address will be automatically assigned from the specified subnet.
          :param pulumi.Input[bool] nat: A public address that can be used to access the internet over NAT.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] security_group_ids: Security group ids for network interface.
          """
          pulumi.set(__self__, "subnet_ids", subnet_ids)
          if ipv4 is not None:
              pulumi.set(__self__, "ipv4", ipv4)
          if ipv6 is not None:
              pulumi.set(__self__, "ipv6", ipv6)
          if nat is not None:
              pulumi.set(__self__, "nat", nat)
          if security_group_ids is not None:
              pulumi.set(__self__, "security_group_ids", security_group_ids)
  
      @property
      @pulumi.getter(name="subnetIds")
      def subnet_ids(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          """
          The IDs of the subnets.
          """
          return pulumi.get(self, "subnet_ids")
  
      @subnet_ids.setter
      def subnet_ids(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "subnet_ids", value)
  
      @property
      @pulumi.getter
      def ipv4(self) -> Optional[pulumi.Input[bool]]:
          """
          Allocate an IPv4 address for the interface. The default value is `true`.
          """
          return pulumi.get(self, "ipv4")
  
      @ipv4.setter
      def ipv4(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "ipv4", value)
  
      @property
      @pulumi.getter
      def ipv6(self) -> Optional[pulumi.Input[bool]]:
          """
          If true, allocate an IPv6 address for the interface. The address will be automatically assigned from the specified subnet.
          """
          return pulumi.get(self, "ipv6")
  
      @ipv6.setter
      def ipv6(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "ipv6", value)
  
      @property
      @pulumi.getter
      def nat(self) -> Optional[pulumi.Input[bool]]:
          """
          A public address that can be used to access the internet over NAT.
          """
          return pulumi.get(self, "nat")
  
      @nat.setter
      def nat(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "nat", value)
  
      @property
      @pulumi.getter(name="securityGroupIds")
      def security_group_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          Security group ids for network interface.
          """
          return pulumi.get(self, "security_group_ids")
  
      @security_group_ids.setter
      def security_group_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "security_group_ids", value)
  
  
  @pulumi.input_type
  class KubernetesNodeGroupInstanceTemplatePlacementPolicyArgs:
      def __init__(__self__, *,
                   placement_group_id: pulumi.Input[str]):
          """
          :param pulumi.Input[str] placement_group_id: Specifies the id of the Placement Group to assign to the instances.
          """
          pulumi.set(__self__, "placement_group_id", placement_group_id)
  
      @property
      @pulumi.getter(name="placementGroupId")
      def placement_group_id(self) -> pulumi.Input[str]:
          """
          Specifies the id of the Placement Group to assign to the instances.
          """
          return pulumi.get(self, "placement_group_id")
  
      @placement_group_id.setter
      def placement_group_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "placement_group_id", value)
  
  
  @pulumi.input_type
  class KubernetesNodeGroupInstanceTemplateResourcesArgs:
      def __init__(__self__, *,
                   core_fraction: Optional[pulumi.Input[int]] = None,
                   cores: Optional[pulumi.Input[int]] = None,
                   gpus: Optional[pulumi.Input[int]] = None,
                   memory: Optional[pulumi.Input[float]] = None):
          if core_fraction is not None:
              pulumi.set(__self__, "core_fraction", core_fraction)
          if cores is not None:
              pulumi.set(__self__, "cores", cores)
          if gpus is not None:
              pulumi.set(__self__, "gpus", gpus)
          if memory is not None:
              pulumi.set(__self__, "memory", memory)
  
      @property
      @pulumi.getter(name="coreFraction")
      def core_fraction(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "core_fraction")
  
      @core_fraction.setter
      def core_fraction(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "core_fraction", value)
  
      @property
      @pulumi.getter
      def cores(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "cores")
  
      @cores.setter
      def cores(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "cores", value)
  
      @property
      @pulumi.getter
      def gpus(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "gpus")
  
      @gpus.setter
      def gpus(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "gpus", value)
  
      @property
      @pulumi.getter
      def memory(self) -> Optional[pulumi.Input[float]]:
          return pulumi.get(self, "memory")
  
      @memory.setter
      def memory(self, value: Optional[pulumi.Input[float]]):
          pulumi.set(self, "memory", value)
  
  
  @pulumi.input_type
  class KubernetesNodeGroupInstanceTemplateSchedulingPolicyArgs:
      def __init__(__self__, *,
                   preemptible: Optional[pulumi.Input[bool]] = None):
          """
          :param pulumi.Input[bool] preemptible: Specifies if the instance is preemptible. Defaults to false.
                 ---
          """
          if preemptible is not None:
              pulumi.set(__self__, "preemptible", preemptible)
  
      @property
      @pulumi.getter
      def preemptible(self) -> Optional[pulumi.Input[bool]]:
          """
          Specifies if the instance is preemptible. Defaults to false.
          ---
          """
          return pulumi.get(self, "preemptible")
  
      @preemptible.setter
      def preemptible(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "preemptible", value)
  
  
  @pulumi.input_type
  class KubernetesNodeGroupMaintenancePolicyArgs:
      def __init__(__self__, *,
                   auto_repair: pulumi.Input[bool],
                   auto_upgrade: pulumi.Input[bool],
                   maintenance_windows: Optional[pulumi.Input[Sequence[pulumi.Input['KubernetesNodeGroupMaintenancePolicyMaintenanceWindowArgs']]]] = None):
          """
          :param pulumi.Input[bool] auto_repair: Boolean flag that specifies if node group can be repaired automatically. When omitted, default value is TRUE.
          :param pulumi.Input[bool] auto_upgrade: Boolean flag that specifies if node group can be upgraded automatically. When omitted, default value is TRUE.
          :param pulumi.Input[Sequence[pulumi.Input['KubernetesNodeGroupMaintenancePolicyMaintenanceWindowArgs']]] maintenance_windows: (Computed) Set of day intervals, when maintenance is allowed for this node group. When omitted, it defaults to any time.
          """
          pulumi.set(__self__, "auto_repair", auto_repair)
          pulumi.set(__self__, "auto_upgrade", auto_upgrade)
          if maintenance_windows is not None:
              pulumi.set(__self__, "maintenance_windows", maintenance_windows)
  
      @property
      @pulumi.getter(name="autoRepair")
      def auto_repair(self) -> pulumi.Input[bool]:
          """
          Boolean flag that specifies if node group can be repaired automatically. When omitted, default value is TRUE.
          """
          return pulumi.get(self, "auto_repair")
  
      @auto_repair.setter
      def auto_repair(self, value: pulumi.Input[bool]):
          pulumi.set(self, "auto_repair", value)
  
      @property
      @pulumi.getter(name="autoUpgrade")
      def auto_upgrade(self) -> pulumi.Input[bool]:
          """
          Boolean flag that specifies if node group can be upgraded automatically. When omitted, default value is TRUE.
          """
          return pulumi.get(self, "auto_upgrade")
  
      @auto_upgrade.setter
      def auto_upgrade(self, value: pulumi.Input[bool]):
          pulumi.set(self, "auto_upgrade", value)
  
      @property
      @pulumi.getter(name="maintenanceWindows")
      def maintenance_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KubernetesNodeGroupMaintenancePolicyMaintenanceWindowArgs']]]]:
          """
          (Computed) Set of day intervals, when maintenance is allowed for this node group. When omitted, it defaults to any time.
          """
          return pulumi.get(self, "maintenance_windows")
  
      @maintenance_windows.setter
      def maintenance_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['KubernetesNodeGroupMaintenancePolicyMaintenanceWindowArgs']]]]):
          pulumi.set(self, "maintenance_windows", value)
  
  
  @pulumi.input_type
  class KubernetesNodeGroupMaintenancePolicyMaintenanceWindowArgs:
      def __init__(__self__, *,
                   duration: pulumi.Input[str],
                   start_time: pulumi.Input[str],
                   day: Optional[pulumi.Input[str]] = None):
          pulumi.set(__self__, "duration", duration)
          pulumi.set(__self__, "start_time", start_time)
          if day is not None:
              pulumi.set(__self__, "day", day)
  
      @property
      @pulumi.getter
      def duration(self) -> pulumi.Input[str]:
          return pulumi.get(self, "duration")
  
      @duration.setter
      def duration(self, value: pulumi.Input[str]):
          pulumi.set(self, "duration", value)
  
      @property
      @pulumi.getter(name="startTime")
      def start_time(self) -> pulumi.Input[str]:
          return pulumi.get(self, "start_time")
  
      @start_time.setter
      def start_time(self, value: pulumi.Input[str]):
          pulumi.set(self, "start_time", value)
  
      @property
      @pulumi.getter
      def day(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "day")
  
      @day.setter
      def day(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "day", value)
  
  
  @pulumi.input_type
  class KubernetesNodeGroupScalePolicyArgs:
      def __init__(__self__, *,
                   auto_scale: Optional[pulumi.Input['KubernetesNodeGroupScalePolicyAutoScaleArgs']] = None,
                   fixed_scale: Optional[pulumi.Input['KubernetesNodeGroupScalePolicyFixedScaleArgs']] = None):
          """
          :param pulumi.Input['KubernetesNodeGroupScalePolicyAutoScaleArgs'] auto_scale: Scale policy for an autoscaled node group. The structure is documented below.
          :param pulumi.Input['KubernetesNodeGroupScalePolicyFixedScaleArgs'] fixed_scale: Scale policy for a fixed scale node group. The structure is documented below.
          """
          if auto_scale is not None:
              pulumi.set(__self__, "auto_scale", auto_scale)
          if fixed_scale is not None:
              pulumi.set(__self__, "fixed_scale", fixed_scale)
  
      @property
      @pulumi.getter(name="autoScale")
      def auto_scale(self) -> Optional[pulumi.Input['KubernetesNodeGroupScalePolicyAutoScaleArgs']]:
          """
          Scale policy for an autoscaled node group. The structure is documented below.
          """
          return pulumi.get(self, "auto_scale")
  
      @auto_scale.setter
      def auto_scale(self, value: Optional[pulumi.Input['KubernetesNodeGroupScalePolicyAutoScaleArgs']]):
          pulumi.set(self, "auto_scale", value)
  
      @property
      @pulumi.getter(name="fixedScale")
      def fixed_scale(self) -> Optional[pulumi.Input['KubernetesNodeGroupScalePolicyFixedScaleArgs']]:
          """
          Scale policy for a fixed scale node group. The structure is documented below.
          """
          return pulumi.get(self, "fixed_scale")
  
      @fixed_scale.setter
      def fixed_scale(self, value: Optional[pulumi.Input['KubernetesNodeGroupScalePolicyFixedScaleArgs']]):
          pulumi.set(self, "fixed_scale", value)
  
  
  @pulumi.input_type
  class KubernetesNodeGroupScalePolicyAutoScaleArgs:
      def __init__(__self__, *,
                   initial: pulumi.Input[int],
                   max: pulumi.Input[int],
                   min: pulumi.Input[int]):
          """
          :param pulumi.Input[int] initial: Initial number of instances in the node group.
          :param pulumi.Input[int] max: Maximum number of instances in the node group.
          :param pulumi.Input[int] min: Minimum number of instances in the node group.
          """
          pulumi.set(__self__, "initial", initial)
          pulumi.set(__self__, "max", max)
          pulumi.set(__self__, "min", min)
  
      @property
      @pulumi.getter
      def initial(self) -> pulumi.Input[int]:
          """
          Initial number of instances in the node group.
          """
          return pulumi.get(self, "initial")
  
      @initial.setter
      def initial(self, value: pulumi.Input[int]):
          pulumi.set(self, "initial", value)
  
      @property
      @pulumi.getter
      def max(self) -> pulumi.Input[int]:
          """
          Maximum number of instances in the node group.
          """
          return pulumi.get(self, "max")
  
      @max.setter
      def max(self, value: pulumi.Input[int]):
          pulumi.set(self, "max", value)
  
      @property
      @pulumi.getter
      def min(self) -> pulumi.Input[int]:
          """
          Minimum number of instances in the node group.
          """
          return pulumi.get(self, "min")
  
      @min.setter
      def min(self, value: pulumi.Input[int]):
          pulumi.set(self, "min", value)
  
  
  @pulumi.input_type
  class KubernetesNodeGroupScalePolicyFixedScaleArgs:
      def __init__(__self__, *,
                   size: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] size: The number of instances in the node group.
          """
          if size is not None:
              pulumi.set(__self__, "size", size)
  
      @property
      @pulumi.getter
      def size(self) -> Optional[pulumi.Input[int]]:
          """
          The number of instances in the node group.
          """
          return pulumi.get(self, "size")
  
      @size.setter
      def size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "size", value)
  
  
  @pulumi.input_type
  class KubernetesNodeGroupVersionInfoArgs:
      def __init__(__self__, *,
                   current_version: Optional[pulumi.Input[str]] = None,
                   new_revision_available: Optional[pulumi.Input[bool]] = None,
                   new_revision_summary: Optional[pulumi.Input[str]] = None,
                   version_deprecated: Optional[pulumi.Input[bool]] = None):
          """
          :param pulumi.Input[str] current_version: Current Kubernetes version, major.minor (e.g. 1.15).
          :param pulumi.Input[bool] new_revision_available: True/false flag.
                 Newer revisions may include Kubernetes patches (e.g 1.15.1 > 1.15.2) as well
                 as some internal component updates - new features or bug fixes in yandex-specific
                 components either on the master or nodes.
          :param pulumi.Input[str] new_revision_summary: Human readable description of the changes to be applied
                 when updating to the latest revision. Empty if new_revision_available is false.
          :param pulumi.Input[bool] version_deprecated: True/false flag. The current version is on the deprecation schedule,
                 component (master or node group) should be upgraded.
          """
          if current_version is not None:
              pulumi.set(__self__, "current_version", current_version)
          if new_revision_available is not None:
              pulumi.set(__self__, "new_revision_available", new_revision_available)
          if new_revision_summary is not None:
              pulumi.set(__self__, "new_revision_summary", new_revision_summary)
          if version_deprecated is not None:
              pulumi.set(__self__, "version_deprecated", version_deprecated)
  
      @property
      @pulumi.getter(name="currentVersion")
      def current_version(self) -> Optional[pulumi.Input[str]]:
          """
          Current Kubernetes version, major.minor (e.g. 1.15).
          """
          return pulumi.get(self, "current_version")
  
      @current_version.setter
      def current_version(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "current_version", value)
  
      @property
      @pulumi.getter(name="newRevisionAvailable")
      def new_revision_available(self) -> Optional[pulumi.Input[bool]]:
          """
          True/false flag.
          Newer revisions may include Kubernetes patches (e.g 1.15.1 > 1.15.2) as well
          as some internal component updates - new features or bug fixes in yandex-specific
          components either on the master or nodes.
          """
          return pulumi.get(self, "new_revision_available")
  
      @new_revision_available.setter
      def new_revision_available(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "new_revision_available", value)
  
      @property
      @pulumi.getter(name="newRevisionSummary")
      def new_revision_summary(self) -> Optional[pulumi.Input[str]]:
          """
          Human readable description of the changes to be applied
          when updating to the latest revision. Empty if new_revision_available is false.
          """
          return pulumi.get(self, "new_revision_summary")
  
      @new_revision_summary.setter
      def new_revision_summary(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "new_revision_summary", value)
  
      @property
      @pulumi.getter(name="versionDeprecated")
      def version_deprecated(self) -> Optional[pulumi.Input[bool]]:
          """
          True/false flag. The current version is on the deprecation schedule,
          component (master or node group) should be upgraded.
          """
          return pulumi.get(self, "version_deprecated")
  
      @version_deprecated.setter
      def version_deprecated(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "version_deprecated", value)
  
  
  @pulumi.input_type
  class LbNetworkLoadBalancerAttachedTargetGroupArgs:
      def __init__(__self__, *,
                   healthchecks: pulumi.Input[Sequence[pulumi.Input['LbNetworkLoadBalancerAttachedTargetGroupHealthcheckArgs']]],
                   target_group_id: pulumi.Input[str]):
          """
          :param pulumi.Input[Sequence[pulumi.Input['LbNetworkLoadBalancerAttachedTargetGroupHealthcheckArgs']]] healthchecks: A HealthCheck resource. The structure is documented below.
          :param pulumi.Input[str] target_group_id: ID of the target group.
          """
          pulumi.set(__self__, "healthchecks", healthchecks)
          pulumi.set(__self__, "target_group_id", target_group_id)
  
      @property
      @pulumi.getter
      def healthchecks(self) -> pulumi.Input[Sequence[pulumi.Input['LbNetworkLoadBalancerAttachedTargetGroupHealthcheckArgs']]]:
          """
          A HealthCheck resource. The structure is documented below.
          """
          return pulumi.get(self, "healthchecks")
  
      @healthchecks.setter
      def healthchecks(self, value: pulumi.Input[Sequence[pulumi.Input['LbNetworkLoadBalancerAttachedTargetGroupHealthcheckArgs']]]):
          pulumi.set(self, "healthchecks", value)
  
      @property
      @pulumi.getter(name="targetGroupId")
      def target_group_id(self) -> pulumi.Input[str]:
          """
          ID of the target group.
          """
          return pulumi.get(self, "target_group_id")
  
      @target_group_id.setter
      def target_group_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "target_group_id", value)
  
  
  @pulumi.input_type
  class LbNetworkLoadBalancerAttachedTargetGroupHealthcheckArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   healthy_threshold: Optional[pulumi.Input[int]] = None,
                   http_options: Optional[pulumi.Input['LbNetworkLoadBalancerAttachedTargetGroupHealthcheckHttpOptionsArgs']] = None,
                   interval: Optional[pulumi.Input[int]] = None,
                   tcp_options: Optional[pulumi.Input['LbNetworkLoadBalancerAttachedTargetGroupHealthcheckTcpOptionsArgs']] = None,
                   timeout: Optional[pulumi.Input[int]] = None,
                   unhealthy_threshold: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] name: Name of the listener. The name must be unique for each listener on a single load balancer.
          :param pulumi.Input[int] healthy_threshold: Number of successful health checks required in order to set the `HEALTHY` status for the target.
          :param pulumi.Input['LbNetworkLoadBalancerAttachedTargetGroupHealthcheckHttpOptionsArgs'] http_options: Options for HTTP health check. The structure is documented below.
          :param pulumi.Input[int] interval: The interval between health checks. The default is 2 seconds.
          :param pulumi.Input['LbNetworkLoadBalancerAttachedTargetGroupHealthcheckTcpOptionsArgs'] tcp_options: Options for TCP health check. The structure is documented below.
          :param pulumi.Input[int] timeout: Timeout for a target to return a response for the health check. The default is 1 second.
          :param pulumi.Input[int] unhealthy_threshold: Number of failed health checks before changing the status to `UNHEALTHY`. The default is 2.
          """
          pulumi.set(__self__, "name", name)
          if healthy_threshold is not None:
              pulumi.set(__self__, "healthy_threshold", healthy_threshold)
          if http_options is not None:
              pulumi.set(__self__, "http_options", http_options)
          if interval is not None:
              pulumi.set(__self__, "interval", interval)
          if tcp_options is not None:
              pulumi.set(__self__, "tcp_options", tcp_options)
          if timeout is not None:
              pulumi.set(__self__, "timeout", timeout)
          if unhealthy_threshold is not None:
              pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          Name of the listener. The name must be unique for each listener on a single load balancer.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="healthyThreshold")
      def healthy_threshold(self) -> Optional[pulumi.Input[int]]:
          """
          Number of successful health checks required in order to set the `HEALTHY` status for the target.
          """
          return pulumi.get(self, "healthy_threshold")
  
      @healthy_threshold.setter
      def healthy_threshold(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "healthy_threshold", value)
  
      @property
      @pulumi.getter(name="httpOptions")
      def http_options(self) -> Optional[pulumi.Input['LbNetworkLoadBalancerAttachedTargetGroupHealthcheckHttpOptionsArgs']]:
          """
          Options for HTTP health check. The structure is documented below.
          """
          return pulumi.get(self, "http_options")
  
      @http_options.setter
      def http_options(self, value: Optional[pulumi.Input['LbNetworkLoadBalancerAttachedTargetGroupHealthcheckHttpOptionsArgs']]):
          pulumi.set(self, "http_options", value)
  
      @property
      @pulumi.getter
      def interval(self) -> Optional[pulumi.Input[int]]:
          """
          The interval between health checks. The default is 2 seconds.
          """
          return pulumi.get(self, "interval")
  
      @interval.setter
      def interval(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "interval", value)
  
      @property
      @pulumi.getter(name="tcpOptions")
      def tcp_options(self) -> Optional[pulumi.Input['LbNetworkLoadBalancerAttachedTargetGroupHealthcheckTcpOptionsArgs']]:
          """
          Options for TCP health check. The structure is documented below.
          """
          return pulumi.get(self, "tcp_options")
  
      @tcp_options.setter
      def tcp_options(self, value: Optional[pulumi.Input['LbNetworkLoadBalancerAttachedTargetGroupHealthcheckTcpOptionsArgs']]):
          pulumi.set(self, "tcp_options", value)
  
      @property
      @pulumi.getter
      def timeout(self) -> Optional[pulumi.Input[int]]:
          """
          Timeout for a target to return a response for the health check. The default is 1 second.
          """
          return pulumi.get(self, "timeout")
  
      @timeout.setter
      def timeout(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "timeout", value)
  
      @property
      @pulumi.getter(name="unhealthyThreshold")
      def unhealthy_threshold(self) -> Optional[pulumi.Input[int]]:
          """
          Number of failed health checks before changing the status to `UNHEALTHY`. The default is 2.
          """
          return pulumi.get(self, "unhealthy_threshold")
  
      @unhealthy_threshold.setter
      def unhealthy_threshold(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "unhealthy_threshold", value)
  
  
  @pulumi.input_type
  class LbNetworkLoadBalancerAttachedTargetGroupHealthcheckHttpOptionsArgs:
      def __init__(__self__, *,
                   port: pulumi.Input[int],
                   path: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[int] port: Port for incoming traffic.
          :param pulumi.Input[str] path: URL path to set for health checking requests for every target in the target group. For example `/ping`. The default path is `/`.
          """
          pulumi.set(__self__, "port", port)
          if path is not None:
              pulumi.set(__self__, "path", path)
  
      @property
      @pulumi.getter
      def port(self) -> pulumi.Input[int]:
          """
          Port for incoming traffic.
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: pulumi.Input[int]):
          pulumi.set(self, "port", value)
  
      @property
      @pulumi.getter
      def path(self) -> Optional[pulumi.Input[str]]:
          """
          URL path to set for health checking requests for every target in the target group. For example `/ping`. The default path is `/`.
          """
          return pulumi.get(self, "path")
  
      @path.setter
      def path(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "path", value)
  
  
  @pulumi.input_type
  class LbNetworkLoadBalancerAttachedTargetGroupHealthcheckTcpOptionsArgs:
      def __init__(__self__, *,
                   port: pulumi.Input[int]):
          """
          :param pulumi.Input[int] port: Port for incoming traffic.
          """
          pulumi.set(__self__, "port", port)
  
      @property
      @pulumi.getter
      def port(self) -> pulumi.Input[int]:
          """
          Port for incoming traffic.
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: pulumi.Input[int]):
          pulumi.set(self, "port", value)
  
  
  @pulumi.input_type
  class LbNetworkLoadBalancerListenerArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   port: pulumi.Input[int],
                   external_address_spec: Optional[pulumi.Input['LbNetworkLoadBalancerListenerExternalAddressSpecArgs']] = None,
                   internal_address_spec: Optional[pulumi.Input['LbNetworkLoadBalancerListenerInternalAddressSpecArgs']] = None,
                   protocol: Optional[pulumi.Input[str]] = None,
                   target_port: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] name: Name of the listener. The name must be unique for each listener on a single load balancer.
          :param pulumi.Input[int] port: Port for incoming traffic.
          :param pulumi.Input['LbNetworkLoadBalancerListenerExternalAddressSpecArgs'] external_address_spec: External IP address specification. The structure is documented below.
          :param pulumi.Input['LbNetworkLoadBalancerListenerInternalAddressSpecArgs'] internal_address_spec: Internal IP address specification. The structure is documented below.
          :param pulumi.Input[str] protocol: Protocol for incoming traffic. TCP or UDP and the default is TCP.
          :param pulumi.Input[int] target_port: Port of a target. The default is the same as listener's port.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "port", port)
          if external_address_spec is not None:
              pulumi.set(__self__, "external_address_spec", external_address_spec)
          if internal_address_spec is not None:
              pulumi.set(__self__, "internal_address_spec", internal_address_spec)
          if protocol is not None:
              pulumi.set(__self__, "protocol", protocol)
          if target_port is not None:
              pulumi.set(__self__, "target_port", target_port)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          Name of the listener. The name must be unique for each listener on a single load balancer.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def port(self) -> pulumi.Input[int]:
          """
          Port for incoming traffic.
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: pulumi.Input[int]):
          pulumi.set(self, "port", value)
  
      @property
      @pulumi.getter(name="externalAddressSpec")
      def external_address_spec(self) -> Optional[pulumi.Input['LbNetworkLoadBalancerListenerExternalAddressSpecArgs']]:
          """
          External IP address specification. The structure is documented below.
          """
          return pulumi.get(self, "external_address_spec")
  
      @external_address_spec.setter
      def external_address_spec(self, value: Optional[pulumi.Input['LbNetworkLoadBalancerListenerExternalAddressSpecArgs']]):
          pulumi.set(self, "external_address_spec", value)
  
      @property
      @pulumi.getter(name="internalAddressSpec")
      def internal_address_spec(self) -> Optional[pulumi.Input['LbNetworkLoadBalancerListenerInternalAddressSpecArgs']]:
          """
          Internal IP address specification. The structure is documented below.
          """
          return pulumi.get(self, "internal_address_spec")
  
      @internal_address_spec.setter
      def internal_address_spec(self, value: Optional[pulumi.Input['LbNetworkLoadBalancerListenerInternalAddressSpecArgs']]):
          pulumi.set(self, "internal_address_spec", value)
  
      @property
      @pulumi.getter
      def protocol(self) -> Optional[pulumi.Input[str]]:
          """
          Protocol for incoming traffic. TCP or UDP and the default is TCP.
          """
          return pulumi.get(self, "protocol")
  
      @protocol.setter
      def protocol(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "protocol", value)
  
      @property
      @pulumi.getter(name="targetPort")
      def target_port(self) -> Optional[pulumi.Input[int]]:
          """
          Port of a target. The default is the same as listener's port.
          """
          return pulumi.get(self, "target_port")
  
      @target_port.setter
      def target_port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "target_port", value)
  
  
  @pulumi.input_type
  class LbNetworkLoadBalancerListenerExternalAddressSpecArgs:
      def __init__(__self__, *,
                   address: Optional[pulumi.Input[str]] = None,
                   ip_version: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] address: Internal IP address for a listener. Must belong to the subnet that is referenced in subnet_id. IP address will be allocated if it wasn't been set.
          :param pulumi.Input[str] ip_version: IP version of the internal addresses that the load balancer works with. Must be one of ipv4 or ipv6. The default is ipv4.
          """
          if address is not None:
              pulumi.set(__self__, "address", address)
          if ip_version is not None:
              pulumi.set(__self__, "ip_version", ip_version)
  
      @property
      @pulumi.getter
      def address(self) -> Optional[pulumi.Input[str]]:
          """
          Internal IP address for a listener. Must belong to the subnet that is referenced in subnet_id. IP address will be allocated if it wasn't been set.
          """
          return pulumi.get(self, "address")
  
      @address.setter
      def address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "address", value)
  
      @property
      @pulumi.getter(name="ipVersion")
      def ip_version(self) -> Optional[pulumi.Input[str]]:
          """
          IP version of the internal addresses that the load balancer works with. Must be one of ipv4 or ipv6. The default is ipv4.
          """
          return pulumi.get(self, "ip_version")
  
      @ip_version.setter
      def ip_version(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "ip_version", value)
  
  
  @pulumi.input_type
  class LbNetworkLoadBalancerListenerInternalAddressSpecArgs:
      def __init__(__self__, *,
                   subnet_id: pulumi.Input[str],
                   address: Optional[pulumi.Input[str]] = None,
                   ip_version: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] subnet_id: ID of the subnet to which the internal IP address belongs.
          :param pulumi.Input[str] address: Internal IP address for a listener. Must belong to the subnet that is referenced in subnet_id. IP address will be allocated if it wasn't been set.
          :param pulumi.Input[str] ip_version: IP version of the internal addresses that the load balancer works with. Must be one of ipv4 or ipv6. The default is ipv4.
          """
          pulumi.set(__self__, "subnet_id", subnet_id)
          if address is not None:
              pulumi.set(__self__, "address", address)
          if ip_version is not None:
              pulumi.set(__self__, "ip_version", ip_version)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> pulumi.Input[str]:
          """
          ID of the subnet to which the internal IP address belongs.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "subnet_id", value)
  
      @property
      @pulumi.getter
      def address(self) -> Optional[pulumi.Input[str]]:
          """
          Internal IP address for a listener. Must belong to the subnet that is referenced in subnet_id. IP address will be allocated if it wasn't been set.
          """
          return pulumi.get(self, "address")
  
      @address.setter
      def address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "address", value)
  
      @property
      @pulumi.getter(name="ipVersion")
      def ip_version(self) -> Optional[pulumi.Input[str]]:
          """
          IP version of the internal addresses that the load balancer works with. Must be one of ipv4 or ipv6. The default is ipv4.
          """
          return pulumi.get(self, "ip_version")
  
      @ip_version.setter
      def ip_version(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "ip_version", value)
  
  
  @pulumi.input_type
  class LbTargetGroupTargetArgs:
      def __init__(__self__, *,
                   address: pulumi.Input[str],
                   subnet_id: pulumi.Input[str]):
          """
          :param pulumi.Input[str] address: IP address of the target.
          :param pulumi.Input[str] subnet_id: ID of the subnet that targets are connected to. 
                 All targets in the target group must be connected to the same subnet within a single availability zone.
          """
          pulumi.set(__self__, "address", address)
          pulumi.set(__self__, "subnet_id", subnet_id)
  
      @property
      @pulumi.getter
      def address(self) -> pulumi.Input[str]:
          """
          IP address of the target.
          """
          return pulumi.get(self, "address")
  
      @address.setter
      def address(self, value: pulumi.Input[str]):
          pulumi.set(self, "address", value)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> pulumi.Input[str]:
          """
          ID of the subnet that targets are connected to. 
          All targets in the target group must be connected to the same subnet within a single availability zone.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "subnet_id", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterAccessArgs:
      def __init__(__self__, *,
                   data_lens: Optional[pulumi.Input[bool]] = None,
                   metrika: Optional[pulumi.Input[bool]] = None,
                   serverless: Optional[pulumi.Input[bool]] = None,
                   web_sql: Optional[pulumi.Input[bool]] = None):
          """
          :param pulumi.Input[bool] data_lens: Allow access for DataLens. Can be either `true` or `false`.
          :param pulumi.Input[bool] metrika: Allow access for Yandex.Metrika. Can be either `true` or `false`.
          :param pulumi.Input[bool] serverless: Allow access for Serverless. Can be either `true` or `false`.
          :param pulumi.Input[bool] web_sql: Allow access for Web SQL. Can be either `true` or `false`.
          """
          if data_lens is not None:
              pulumi.set(__self__, "data_lens", data_lens)
          if metrika is not None:
              pulumi.set(__self__, "metrika", metrika)
          if serverless is not None:
              pulumi.set(__self__, "serverless", serverless)
          if web_sql is not None:
              pulumi.set(__self__, "web_sql", web_sql)
  
      @property
      @pulumi.getter(name="dataLens")
      def data_lens(self) -> Optional[pulumi.Input[bool]]:
          """
          Allow access for DataLens. Can be either `true` or `false`.
          """
          return pulumi.get(self, "data_lens")
  
      @data_lens.setter
      def data_lens(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "data_lens", value)
  
      @property
      @pulumi.getter
      def metrika(self) -> Optional[pulumi.Input[bool]]:
          """
          Allow access for Yandex.Metrika. Can be either `true` or `false`.
          """
          return pulumi.get(self, "metrika")
  
      @metrika.setter
      def metrika(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "metrika", value)
  
      @property
      @pulumi.getter
      def serverless(self) -> Optional[pulumi.Input[bool]]:
          """
          Allow access for Serverless. Can be either `true` or `false`.
          """
          return pulumi.get(self, "serverless")
  
      @serverless.setter
      def serverless(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "serverless", value)
  
      @property
      @pulumi.getter(name="webSql")
      def web_sql(self) -> Optional[pulumi.Input[bool]]:
          """
          Allow access for Web SQL. Can be either `true` or `false`.
          """
          return pulumi.get(self, "web_sql")
  
      @web_sql.setter
      def web_sql(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "web_sql", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterBackupWindowStartArgs:
      def __init__(__self__, *,
                   hours: Optional[pulumi.Input[int]] = None,
                   minutes: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] hours: The hour at which backup will be started.
          :param pulumi.Input[int] minutes: The minute at which backup will be started.
          """
          if hours is not None:
              pulumi.set(__self__, "hours", hours)
          if minutes is not None:
              pulumi.set(__self__, "minutes", minutes)
  
      @property
      @pulumi.getter
      def hours(self) -> Optional[pulumi.Input[int]]:
          """
          The hour at which backup will be started.
          """
          return pulumi.get(self, "hours")
  
      @hours.setter
      def hours(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "hours", value)
  
      @property
      @pulumi.getter
      def minutes(self) -> Optional[pulumi.Input[int]]:
          """
          The minute at which backup will be started.
          """
          return pulumi.get(self, "minutes")
  
      @minutes.setter
      def minutes(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "minutes", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterClickhouseArgs:
      def __init__(__self__, *,
                   resources: pulumi.Input['MdbClickhouseClusterClickhouseResourcesArgs'],
                   config: Optional[pulumi.Input['MdbClickhouseClusterClickhouseConfigArgs']] = None):
          """
          :param pulumi.Input['MdbClickhouseClusterClickhouseResourcesArgs'] resources: Resources allocated to hosts of the ZooKeeper subcluster. The structure is documented below.
          :param pulumi.Input['MdbClickhouseClusterClickhouseConfigArgs'] config: Main ClickHouse cluster configuration.
          """
          pulumi.set(__self__, "resources", resources)
          if config is not None:
              pulumi.set(__self__, "config", config)
  
      @property
      @pulumi.getter
      def resources(self) -> pulumi.Input['MdbClickhouseClusterClickhouseResourcesArgs']:
          """
          Resources allocated to hosts of the ZooKeeper subcluster. The structure is documented below.
          """
          return pulumi.get(self, "resources")
  
      @resources.setter
      def resources(self, value: pulumi.Input['MdbClickhouseClusterClickhouseResourcesArgs']):
          pulumi.set(self, "resources", value)
  
      @property
      @pulumi.getter
      def config(self) -> Optional[pulumi.Input['MdbClickhouseClusterClickhouseConfigArgs']]:
          """
          Main ClickHouse cluster configuration.
          """
          return pulumi.get(self, "config")
  
      @config.setter
      def config(self, value: Optional[pulumi.Input['MdbClickhouseClusterClickhouseConfigArgs']]):
          pulumi.set(self, "config", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterClickhouseConfigArgs:
      def __init__(__self__, *,
                   background_pool_size: Optional[pulumi.Input[int]] = None,
                   background_schedule_pool_size: Optional[pulumi.Input[int]] = None,
                   compressions: Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigCompressionArgs']]]] = None,
                   geobase_uri: Optional[pulumi.Input[str]] = None,
                   graphite_rollups: Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigGraphiteRollupArgs']]]] = None,
                   kafka: Optional[pulumi.Input['MdbClickhouseClusterClickhouseConfigKafkaArgs']] = None,
                   kafka_topics: Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigKafkaTopicArgs']]]] = None,
                   keep_alive_timeout: Optional[pulumi.Input[int]] = None,
                   log_level: Optional[pulumi.Input[str]] = None,
                   mark_cache_size: Optional[pulumi.Input[int]] = None,
                   max_concurrent_queries: Optional[pulumi.Input[int]] = None,
                   max_connections: Optional[pulumi.Input[int]] = None,
                   max_partition_size_to_drop: Optional[pulumi.Input[int]] = None,
                   max_table_size_to_drop: Optional[pulumi.Input[int]] = None,
                   merge_tree: Optional[pulumi.Input['MdbClickhouseClusterClickhouseConfigMergeTreeArgs']] = None,
                   metric_log_enabled: Optional[pulumi.Input[bool]] = None,
                   metric_log_retention_size: Optional[pulumi.Input[int]] = None,
                   metric_log_retention_time: Optional[pulumi.Input[int]] = None,
                   part_log_retention_size: Optional[pulumi.Input[int]] = None,
                   part_log_retention_time: Optional[pulumi.Input[int]] = None,
                   query_log_retention_size: Optional[pulumi.Input[int]] = None,
                   query_log_retention_time: Optional[pulumi.Input[int]] = None,
                   query_thread_log_enabled: Optional[pulumi.Input[bool]] = None,
                   query_thread_log_retention_size: Optional[pulumi.Input[int]] = None,
                   query_thread_log_retention_time: Optional[pulumi.Input[int]] = None,
                   rabbitmq: Optional[pulumi.Input['MdbClickhouseClusterClickhouseConfigRabbitmqArgs']] = None,
                   text_log_enabled: Optional[pulumi.Input[bool]] = None,
                   text_log_level: Optional[pulumi.Input[str]] = None,
                   text_log_retention_size: Optional[pulumi.Input[int]] = None,
                   text_log_retention_time: Optional[pulumi.Input[int]] = None,
                   timezone: Optional[pulumi.Input[str]] = None,
                   trace_log_enabled: Optional[pulumi.Input[bool]] = None,
                   trace_log_retention_size: Optional[pulumi.Input[int]] = None,
                   trace_log_retention_time: Optional[pulumi.Input[int]] = None,
                   uncompressed_cache_size: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigCompressionArgs']]] compressions: Data compression configuration. The structure is documented below.
          :param pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigGraphiteRollupArgs']]] graphite_rollups: Graphite rollup configuration. The structure is documented below.
          :param pulumi.Input['MdbClickhouseClusterClickhouseConfigKafkaArgs'] kafka: Kafka connection configuration. The structure is documented below.
          :param pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigKafkaTopicArgs']]] kafka_topics: Kafka topic connection configuration. The structure is documented below.
          :param pulumi.Input['MdbClickhouseClusterClickhouseConfigMergeTreeArgs'] merge_tree: MergeTree engine configuration. The structure is documented below.
          :param pulumi.Input['MdbClickhouseClusterClickhouseConfigRabbitmqArgs'] rabbitmq: RabbitMQ connection configuration. The structure is documented below.
          """
          if background_pool_size is not None:
              pulumi.set(__self__, "background_pool_size", background_pool_size)
          if background_schedule_pool_size is not None:
              pulumi.set(__self__, "background_schedule_pool_size", background_schedule_pool_size)
          if compressions is not None:
              pulumi.set(__self__, "compressions", compressions)
          if geobase_uri is not None:
              pulumi.set(__self__, "geobase_uri", geobase_uri)
          if graphite_rollups is not None:
              pulumi.set(__self__, "graphite_rollups", graphite_rollups)
          if kafka is not None:
              pulumi.set(__self__, "kafka", kafka)
          if kafka_topics is not None:
              pulumi.set(__self__, "kafka_topics", kafka_topics)
          if keep_alive_timeout is not None:
              pulumi.set(__self__, "keep_alive_timeout", keep_alive_timeout)
          if log_level is not None:
              pulumi.set(__self__, "log_level", log_level)
          if mark_cache_size is not None:
              pulumi.set(__self__, "mark_cache_size", mark_cache_size)
          if max_concurrent_queries is not None:
              pulumi.set(__self__, "max_concurrent_queries", max_concurrent_queries)
          if max_connections is not None:
              pulumi.set(__self__, "max_connections", max_connections)
          if max_partition_size_to_drop is not None:
              pulumi.set(__self__, "max_partition_size_to_drop", max_partition_size_to_drop)
          if max_table_size_to_drop is not None:
              pulumi.set(__self__, "max_table_size_to_drop", max_table_size_to_drop)
          if merge_tree is not None:
              pulumi.set(__self__, "merge_tree", merge_tree)
          if metric_log_enabled is not None:
              pulumi.set(__self__, "metric_log_enabled", metric_log_enabled)
          if metric_log_retention_size is not None:
              pulumi.set(__self__, "metric_log_retention_size", metric_log_retention_size)
          if metric_log_retention_time is not None:
              pulumi.set(__self__, "metric_log_retention_time", metric_log_retention_time)
          if part_log_retention_size is not None:
              pulumi.set(__self__, "part_log_retention_size", part_log_retention_size)
          if part_log_retention_time is not None:
              pulumi.set(__self__, "part_log_retention_time", part_log_retention_time)
          if query_log_retention_size is not None:
              pulumi.set(__self__, "query_log_retention_size", query_log_retention_size)
          if query_log_retention_time is not None:
              pulumi.set(__self__, "query_log_retention_time", query_log_retention_time)
          if query_thread_log_enabled is not None:
              pulumi.set(__self__, "query_thread_log_enabled", query_thread_log_enabled)
          if query_thread_log_retention_size is not None:
              pulumi.set(__self__, "query_thread_log_retention_size", query_thread_log_retention_size)
          if query_thread_log_retention_time is not None:
              pulumi.set(__self__, "query_thread_log_retention_time", query_thread_log_retention_time)
          if rabbitmq is not None:
              pulumi.set(__self__, "rabbitmq", rabbitmq)
          if text_log_enabled is not None:
              pulumi.set(__self__, "text_log_enabled", text_log_enabled)
          if text_log_level is not None:
              pulumi.set(__self__, "text_log_level", text_log_level)
          if text_log_retention_size is not None:
              pulumi.set(__self__, "text_log_retention_size", text_log_retention_size)
          if text_log_retention_time is not None:
              pulumi.set(__self__, "text_log_retention_time", text_log_retention_time)
          if timezone is not None:
              pulumi.set(__self__, "timezone", timezone)
          if trace_log_enabled is not None:
              pulumi.set(__self__, "trace_log_enabled", trace_log_enabled)
          if trace_log_retention_size is not None:
              pulumi.set(__self__, "trace_log_retention_size", trace_log_retention_size)
          if trace_log_retention_time is not None:
              pulumi.set(__self__, "trace_log_retention_time", trace_log_retention_time)
          if uncompressed_cache_size is not None:
              pulumi.set(__self__, "uncompressed_cache_size", uncompressed_cache_size)
  
      @property
      @pulumi.getter(name="backgroundPoolSize")
      def background_pool_size(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "background_pool_size")
  
      @background_pool_size.setter
      def background_pool_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "background_pool_size", value)
  
      @property
      @pulumi.getter(name="backgroundSchedulePoolSize")
      def background_schedule_pool_size(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "background_schedule_pool_size")
  
      @background_schedule_pool_size.setter
      def background_schedule_pool_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "background_schedule_pool_size", value)
  
      @property
      @pulumi.getter
      def compressions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigCompressionArgs']]]]:
          """
          Data compression configuration. The structure is documented below.
          """
          return pulumi.get(self, "compressions")
  
      @compressions.setter
      def compressions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigCompressionArgs']]]]):
          pulumi.set(self, "compressions", value)
  
      @property
      @pulumi.getter(name="geobaseUri")
      def geobase_uri(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "geobase_uri")
  
      @geobase_uri.setter
      def geobase_uri(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "geobase_uri", value)
  
      @property
      @pulumi.getter(name="graphiteRollups")
      def graphite_rollups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigGraphiteRollupArgs']]]]:
          """
          Graphite rollup configuration. The structure is documented below.
          """
          return pulumi.get(self, "graphite_rollups")
  
      @graphite_rollups.setter
      def graphite_rollups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigGraphiteRollupArgs']]]]):
          pulumi.set(self, "graphite_rollups", value)
  
      @property
      @pulumi.getter
      def kafka(self) -> Optional[pulumi.Input['MdbClickhouseClusterClickhouseConfigKafkaArgs']]:
          """
          Kafka connection configuration. The structure is documented below.
          """
          return pulumi.get(self, "kafka")
  
      @kafka.setter
      def kafka(self, value: Optional[pulumi.Input['MdbClickhouseClusterClickhouseConfigKafkaArgs']]):
          pulumi.set(self, "kafka", value)
  
      @property
      @pulumi.getter(name="kafkaTopics")
      def kafka_topics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigKafkaTopicArgs']]]]:
          """
          Kafka topic connection configuration. The structure is documented below.
          """
          return pulumi.get(self, "kafka_topics")
  
      @kafka_topics.setter
      def kafka_topics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigKafkaTopicArgs']]]]):
          pulumi.set(self, "kafka_topics", value)
  
      @property
      @pulumi.getter(name="keepAliveTimeout")
      def keep_alive_timeout(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "keep_alive_timeout")
  
      @keep_alive_timeout.setter
      def keep_alive_timeout(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "keep_alive_timeout", value)
  
      @property
      @pulumi.getter(name="logLevel")
      def log_level(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "log_level")
  
      @log_level.setter
      def log_level(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "log_level", value)
  
      @property
      @pulumi.getter(name="markCacheSize")
      def mark_cache_size(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "mark_cache_size")
  
      @mark_cache_size.setter
      def mark_cache_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "mark_cache_size", value)
  
      @property
      @pulumi.getter(name="maxConcurrentQueries")
      def max_concurrent_queries(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "max_concurrent_queries")
  
      @max_concurrent_queries.setter
      def max_concurrent_queries(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_concurrent_queries", value)
  
      @property
      @pulumi.getter(name="maxConnections")
      def max_connections(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "max_connections")
  
      @max_connections.setter
      def max_connections(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_connections", value)
  
      @property
      @pulumi.getter(name="maxPartitionSizeToDrop")
      def max_partition_size_to_drop(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "max_partition_size_to_drop")
  
      @max_partition_size_to_drop.setter
      def max_partition_size_to_drop(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_partition_size_to_drop", value)
  
      @property
      @pulumi.getter(name="maxTableSizeToDrop")
      def max_table_size_to_drop(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "max_table_size_to_drop")
  
      @max_table_size_to_drop.setter
      def max_table_size_to_drop(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_table_size_to_drop", value)
  
      @property
      @pulumi.getter(name="mergeTree")
      def merge_tree(self) -> Optional[pulumi.Input['MdbClickhouseClusterClickhouseConfigMergeTreeArgs']]:
          """
          MergeTree engine configuration. The structure is documented below.
          """
          return pulumi.get(self, "merge_tree")
  
      @merge_tree.setter
      def merge_tree(self, value: Optional[pulumi.Input['MdbClickhouseClusterClickhouseConfigMergeTreeArgs']]):
          pulumi.set(self, "merge_tree", value)
  
      @property
      @pulumi.getter(name="metricLogEnabled")
      def metric_log_enabled(self) -> Optional[pulumi.Input[bool]]:
          return pulumi.get(self, "metric_log_enabled")
  
      @metric_log_enabled.setter
      def metric_log_enabled(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "metric_log_enabled", value)
  
      @property
      @pulumi.getter(name="metricLogRetentionSize")
      def metric_log_retention_size(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "metric_log_retention_size")
  
      @metric_log_retention_size.setter
      def metric_log_retention_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "metric_log_retention_size", value)
  
      @property
      @pulumi.getter(name="metricLogRetentionTime")
      def metric_log_retention_time(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "metric_log_retention_time")
  
      @metric_log_retention_time.setter
      def metric_log_retention_time(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "metric_log_retention_time", value)
  
      @property
      @pulumi.getter(name="partLogRetentionSize")
      def part_log_retention_size(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "part_log_retention_size")
  
      @part_log_retention_size.setter
      def part_log_retention_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "part_log_retention_size", value)
  
      @property
      @pulumi.getter(name="partLogRetentionTime")
      def part_log_retention_time(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "part_log_retention_time")
  
      @part_log_retention_time.setter
      def part_log_retention_time(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "part_log_retention_time", value)
  
      @property
      @pulumi.getter(name="queryLogRetentionSize")
      def query_log_retention_size(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "query_log_retention_size")
  
      @query_log_retention_size.setter
      def query_log_retention_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "query_log_retention_size", value)
  
      @property
      @pulumi.getter(name="queryLogRetentionTime")
      def query_log_retention_time(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "query_log_retention_time")
  
      @query_log_retention_time.setter
      def query_log_retention_time(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "query_log_retention_time", value)
  
      @property
      @pulumi.getter(name="queryThreadLogEnabled")
      def query_thread_log_enabled(self) -> Optional[pulumi.Input[bool]]:
          return pulumi.get(self, "query_thread_log_enabled")
  
      @query_thread_log_enabled.setter
      def query_thread_log_enabled(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "query_thread_log_enabled", value)
  
      @property
      @pulumi.getter(name="queryThreadLogRetentionSize")
      def query_thread_log_retention_size(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "query_thread_log_retention_size")
  
      @query_thread_log_retention_size.setter
      def query_thread_log_retention_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "query_thread_log_retention_size", value)
  
      @property
      @pulumi.getter(name="queryThreadLogRetentionTime")
      def query_thread_log_retention_time(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "query_thread_log_retention_time")
  
      @query_thread_log_retention_time.setter
      def query_thread_log_retention_time(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "query_thread_log_retention_time", value)
  
      @property
      @pulumi.getter
      def rabbitmq(self) -> Optional[pulumi.Input['MdbClickhouseClusterClickhouseConfigRabbitmqArgs']]:
          """
          RabbitMQ connection configuration. The structure is documented below.
          """
          return pulumi.get(self, "rabbitmq")
  
      @rabbitmq.setter
      def rabbitmq(self, value: Optional[pulumi.Input['MdbClickhouseClusterClickhouseConfigRabbitmqArgs']]):
          pulumi.set(self, "rabbitmq", value)
  
      @property
      @pulumi.getter(name="textLogEnabled")
      def text_log_enabled(self) -> Optional[pulumi.Input[bool]]:
          return pulumi.get(self, "text_log_enabled")
  
      @text_log_enabled.setter
      def text_log_enabled(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "text_log_enabled", value)
  
      @property
      @pulumi.getter(name="textLogLevel")
      def text_log_level(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "text_log_level")
  
      @text_log_level.setter
      def text_log_level(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "text_log_level", value)
  
      @property
      @pulumi.getter(name="textLogRetentionSize")
      def text_log_retention_size(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "text_log_retention_size")
  
      @text_log_retention_size.setter
      def text_log_retention_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "text_log_retention_size", value)
  
      @property
      @pulumi.getter(name="textLogRetentionTime")
      def text_log_retention_time(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "text_log_retention_time")
  
      @text_log_retention_time.setter
      def text_log_retention_time(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "text_log_retention_time", value)
  
      @property
      @pulumi.getter
      def timezone(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "timezone")
  
      @timezone.setter
      def timezone(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "timezone", value)
  
      @property
      @pulumi.getter(name="traceLogEnabled")
      def trace_log_enabled(self) -> Optional[pulumi.Input[bool]]:
          return pulumi.get(self, "trace_log_enabled")
  
      @trace_log_enabled.setter
      def trace_log_enabled(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "trace_log_enabled", value)
  
      @property
      @pulumi.getter(name="traceLogRetentionSize")
      def trace_log_retention_size(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "trace_log_retention_size")
  
      @trace_log_retention_size.setter
      def trace_log_retention_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "trace_log_retention_size", value)
  
      @property
      @pulumi.getter(name="traceLogRetentionTime")
      def trace_log_retention_time(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "trace_log_retention_time")
  
      @trace_log_retention_time.setter
      def trace_log_retention_time(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "trace_log_retention_time", value)
  
      @property
      @pulumi.getter(name="uncompressedCacheSize")
      def uncompressed_cache_size(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "uncompressed_cache_size")
  
      @uncompressed_cache_size.setter
      def uncompressed_cache_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "uncompressed_cache_size", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterClickhouseConfigCompressionArgs:
      def __init__(__self__, *,
                   method: pulumi.Input[str],
                   min_part_size: pulumi.Input[int],
                   min_part_size_ratio: pulumi.Input[float]):
          """
          :param pulumi.Input[str] method: Method: Compression method. Two methods are available: LZ4 and zstd.
          :param pulumi.Input[int] min_part_size: Min part size: Minimum size (in bytes) of a data part in a table. ClickHouse only applies the rule to tables with data parts greater than or equal to the Min part size value.
          :param pulumi.Input[float] min_part_size_ratio: Min part size ratio: Minimum table part size to total table size ratio. ClickHouse only applies the rule to tables in which this ratio is greater than or equal to the Min part size ratio value.
          """
          pulumi.set(__self__, "method", method)
          pulumi.set(__self__, "min_part_size", min_part_size)
          pulumi.set(__self__, "min_part_size_ratio", min_part_size_ratio)
  
      @property
      @pulumi.getter
      def method(self) -> pulumi.Input[str]:
          """
          Method: Compression method. Two methods are available: LZ4 and zstd.
          """
          return pulumi.get(self, "method")
  
      @method.setter
      def method(self, value: pulumi.Input[str]):
          pulumi.set(self, "method", value)
  
      @property
      @pulumi.getter(name="minPartSize")
      def min_part_size(self) -> pulumi.Input[int]:
          """
          Min part size: Minimum size (in bytes) of a data part in a table. ClickHouse only applies the rule to tables with data parts greater than or equal to the Min part size value.
          """
          return pulumi.get(self, "min_part_size")
  
      @min_part_size.setter
      def min_part_size(self, value: pulumi.Input[int]):
          pulumi.set(self, "min_part_size", value)
  
      @property
      @pulumi.getter(name="minPartSizeRatio")
      def min_part_size_ratio(self) -> pulumi.Input[float]:
          """
          Min part size ratio: Minimum table part size to total table size ratio. ClickHouse only applies the rule to tables in which this ratio is greater than or equal to the Min part size ratio value.
          """
          return pulumi.get(self, "min_part_size_ratio")
  
      @min_part_size_ratio.setter
      def min_part_size_ratio(self, value: pulumi.Input[float]):
          pulumi.set(self, "min_part_size_ratio", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterClickhouseConfigGraphiteRollupArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   patterns: Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigGraphiteRollupPatternArgs']]]] = None):
          """
          :param pulumi.Input[str] name: Graphite rollup configuration name.
          :param pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigGraphiteRollupPatternArgs']]] patterns: Set of thinning rules.
          """
          pulumi.set(__self__, "name", name)
          if patterns is not None:
              pulumi.set(__self__, "patterns", patterns)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          Graphite rollup configuration name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigGraphiteRollupPatternArgs']]]]:
          """
          Set of thinning rules.
          """
          return pulumi.get(self, "patterns")
  
      @patterns.setter
      def patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigGraphiteRollupPatternArgs']]]]):
          pulumi.set(self, "patterns", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterClickhouseConfigGraphiteRollupPatternArgs:
      def __init__(__self__, *,
                   function: pulumi.Input[str],
                   regexp: Optional[pulumi.Input[str]] = None,
                   retentions: Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigGraphiteRollupPatternRetentionArgs']]]] = None):
          """
          :param pulumi.Input[str] function: Aggregation function name.
          :param pulumi.Input[str] regexp: Regular expression that the metric name must match.
          :param pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigGraphiteRollupPatternRetentionArgs']]] retentions: Retain parameters.
          """
          pulumi.set(__self__, "function", function)
          if regexp is not None:
              pulumi.set(__self__, "regexp", regexp)
          if retentions is not None:
              pulumi.set(__self__, "retentions", retentions)
  
      @property
      @pulumi.getter
      def function(self) -> pulumi.Input[str]:
          """
          Aggregation function name.
          """
          return pulumi.get(self, "function")
  
      @function.setter
      def function(self, value: pulumi.Input[str]):
          pulumi.set(self, "function", value)
  
      @property
      @pulumi.getter
      def regexp(self) -> Optional[pulumi.Input[str]]:
          """
          Regular expression that the metric name must match.
          """
          return pulumi.get(self, "regexp")
  
      @regexp.setter
      def regexp(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "regexp", value)
  
      @property
      @pulumi.getter
      def retentions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigGraphiteRollupPatternRetentionArgs']]]]:
          """
          Retain parameters.
          """
          return pulumi.get(self, "retentions")
  
      @retentions.setter
      def retentions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterClickhouseConfigGraphiteRollupPatternRetentionArgs']]]]):
          pulumi.set(self, "retentions", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterClickhouseConfigGraphiteRollupPatternRetentionArgs:
      def __init__(__self__, *,
                   age: pulumi.Input[int],
                   precision: pulumi.Input[int]):
          """
          :param pulumi.Input[int] age: Minimum data age in seconds.
          :param pulumi.Input[int] precision: Accuracy of determining the age of the data in seconds.
          """
          pulumi.set(__self__, "age", age)
          pulumi.set(__self__, "precision", precision)
  
      @property
      @pulumi.getter
      def age(self) -> pulumi.Input[int]:
          """
          Minimum data age in seconds.
          """
          return pulumi.get(self, "age")
  
      @age.setter
      def age(self, value: pulumi.Input[int]):
          pulumi.set(self, "age", value)
  
      @property
      @pulumi.getter
      def precision(self) -> pulumi.Input[int]:
          """
          Accuracy of determining the age of the data in seconds.
          """
          return pulumi.get(self, "precision")
  
      @precision.setter
      def precision(self, value: pulumi.Input[int]):
          pulumi.set(self, "precision", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterClickhouseConfigKafkaArgs:
      def __init__(__self__, *,
                   sasl_mechanism: Optional[pulumi.Input[str]] = None,
                   sasl_password: Optional[pulumi.Input[str]] = None,
                   sasl_username: Optional[pulumi.Input[str]] = None,
                   security_protocol: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] sasl_mechanism: SASL mechanism used in kafka authentication.
          :param pulumi.Input[str] sasl_password: User password on kafka server.
          :param pulumi.Input[str] sasl_username: Username on kafka server.
          :param pulumi.Input[str] security_protocol: Security protocol used to connect to kafka server.
          """
          if sasl_mechanism is not None:
              pulumi.set(__self__, "sasl_mechanism", sasl_mechanism)
          if sasl_password is not None:
              pulumi.set(__self__, "sasl_password", sasl_password)
          if sasl_username is not None:
              pulumi.set(__self__, "sasl_username", sasl_username)
          if security_protocol is not None:
              pulumi.set(__self__, "security_protocol", security_protocol)
  
      @property
      @pulumi.getter(name="saslMechanism")
      def sasl_mechanism(self) -> Optional[pulumi.Input[str]]:
          """
          SASL mechanism used in kafka authentication.
          """
          return pulumi.get(self, "sasl_mechanism")
  
      @sasl_mechanism.setter
      def sasl_mechanism(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "sasl_mechanism", value)
  
      @property
      @pulumi.getter(name="saslPassword")
      def sasl_password(self) -> Optional[pulumi.Input[str]]:
          """
          User password on kafka server.
          """
          return pulumi.get(self, "sasl_password")
  
      @sasl_password.setter
      def sasl_password(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "sasl_password", value)
  
      @property
      @pulumi.getter(name="saslUsername")
      def sasl_username(self) -> Optional[pulumi.Input[str]]:
          """
          Username on kafka server.
          """
          return pulumi.get(self, "sasl_username")
  
      @sasl_username.setter
      def sasl_username(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "sasl_username", value)
  
      @property
      @pulumi.getter(name="securityProtocol")
      def security_protocol(self) -> Optional[pulumi.Input[str]]:
          """
          Security protocol used to connect to kafka server.
          """
          return pulumi.get(self, "security_protocol")
  
      @security_protocol.setter
      def security_protocol(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "security_protocol", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterClickhouseConfigKafkaTopicArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   settings: Optional[pulumi.Input['MdbClickhouseClusterClickhouseConfigKafkaTopicSettingsArgs']] = None):
          """
          :param pulumi.Input[str] name: Graphite rollup configuration name.
          :param pulumi.Input['MdbClickhouseClusterClickhouseConfigKafkaTopicSettingsArgs'] settings: Kafka connection settngs sanem as `kafka` block.
          """
          pulumi.set(__self__, "name", name)
          if settings is not None:
              pulumi.set(__self__, "settings", settings)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          Graphite rollup configuration name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def settings(self) -> Optional[pulumi.Input['MdbClickhouseClusterClickhouseConfigKafkaTopicSettingsArgs']]:
          """
          Kafka connection settngs sanem as `kafka` block.
          """
          return pulumi.get(self, "settings")
  
      @settings.setter
      def settings(self, value: Optional[pulumi.Input['MdbClickhouseClusterClickhouseConfigKafkaTopicSettingsArgs']]):
          pulumi.set(self, "settings", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterClickhouseConfigKafkaTopicSettingsArgs:
      def __init__(__self__, *,
                   sasl_mechanism: Optional[pulumi.Input[str]] = None,
                   sasl_password: Optional[pulumi.Input[str]] = None,
                   sasl_username: Optional[pulumi.Input[str]] = None,
                   security_protocol: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] sasl_mechanism: SASL mechanism used in kafka authentication.
          :param pulumi.Input[str] sasl_password: User password on kafka server.
          :param pulumi.Input[str] sasl_username: Username on kafka server.
          :param pulumi.Input[str] security_protocol: Security protocol used to connect to kafka server.
          """
          if sasl_mechanism is not None:
              pulumi.set(__self__, "sasl_mechanism", sasl_mechanism)
          if sasl_password is not None:
              pulumi.set(__self__, "sasl_password", sasl_password)
          if sasl_username is not None:
              pulumi.set(__self__, "sasl_username", sasl_username)
          if security_protocol is not None:
              pulumi.set(__self__, "security_protocol", security_protocol)
  
      @property
      @pulumi.getter(name="saslMechanism")
      def sasl_mechanism(self) -> Optional[pulumi.Input[str]]:
          """
          SASL mechanism used in kafka authentication.
          """
          return pulumi.get(self, "sasl_mechanism")
  
      @sasl_mechanism.setter
      def sasl_mechanism(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "sasl_mechanism", value)
  
      @property
      @pulumi.getter(name="saslPassword")
      def sasl_password(self) -> Optional[pulumi.Input[str]]:
          """
          User password on kafka server.
          """
          return pulumi.get(self, "sasl_password")
  
      @sasl_password.setter
      def sasl_password(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "sasl_password", value)
  
      @property
      @pulumi.getter(name="saslUsername")
      def sasl_username(self) -> Optional[pulumi.Input[str]]:
          """
          Username on kafka server.
          """
          return pulumi.get(self, "sasl_username")
  
      @sasl_username.setter
      def sasl_username(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "sasl_username", value)
  
      @property
      @pulumi.getter(name="securityProtocol")
      def security_protocol(self) -> Optional[pulumi.Input[str]]:
          """
          Security protocol used to connect to kafka server.
          """
          return pulumi.get(self, "security_protocol")
  
      @security_protocol.setter
      def security_protocol(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "security_protocol", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterClickhouseConfigMergeTreeArgs:
      def __init__(__self__, *,
                   max_bytes_to_merge_at_min_space_in_pool: Optional[pulumi.Input[int]] = None,
                   max_replicated_merges_in_queue: Optional[pulumi.Input[int]] = None,
                   number_of_free_entries_in_pool_to_lower_max_size_of_merge: Optional[pulumi.Input[int]] = None,
                   parts_to_delay_insert: Optional[pulumi.Input[int]] = None,
                   parts_to_throw_insert: Optional[pulumi.Input[int]] = None,
                   replicated_deduplication_window: Optional[pulumi.Input[int]] = None,
                   replicated_deduplication_window_seconds: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] max_bytes_to_merge_at_min_space_in_pool: Max bytes to merge at min space in pool: Maximum total size of a data part to merge when the number of free threads in the background pool is minimum.
          :param pulumi.Input[int] max_replicated_merges_in_queue: Max replicated merges in queue: Maximum number of merge tasks that can be in the ReplicatedMergeTree queue at the same time.
          :param pulumi.Input[int] number_of_free_entries_in_pool_to_lower_max_size_of_merge: Number of free entries in pool to lower max size of merge: Threshold value of free entries in the pool. If the number of entries in the pool falls below this value, ClickHouse reduces the maximum size of a data part to merge. This helps handle small merges faster, rather than filling the pool with lengthy merges.
          :param pulumi.Input[int] parts_to_delay_insert: Parts to delay insert: Number of active data parts in a table, on exceeding which ClickHouse starts artificially reduce the rate of inserting data into the table.
          :param pulumi.Input[int] parts_to_throw_insert: Parts to throw insert: Threshold value of active data parts in a table, on exceeding which ClickHouse throws the 'Too many parts ...' exception.
          :param pulumi.Input[int] replicated_deduplication_window: Replicated deduplication window: Number of recent hash blocks that ZooKeeper will store (the old ones will be deleted).
          :param pulumi.Input[int] replicated_deduplication_window_seconds: Replicated deduplication window seconds: Time during which ZooKeeper stores the hash blocks (the old ones wil be deleted).
          """
          if max_bytes_to_merge_at_min_space_in_pool is not None:
              pulumi.set(__self__, "max_bytes_to_merge_at_min_space_in_pool", max_bytes_to_merge_at_min_space_in_pool)
          if max_replicated_merges_in_queue is not None:
              pulumi.set(__self__, "max_replicated_merges_in_queue", max_replicated_merges_in_queue)
          if number_of_free_entries_in_pool_to_lower_max_size_of_merge is not None:
              pulumi.set(__self__, "number_of_free_entries_in_pool_to_lower_max_size_of_merge", number_of_free_entries_in_pool_to_lower_max_size_of_merge)
          if parts_to_delay_insert is not None:
              pulumi.set(__self__, "parts_to_delay_insert", parts_to_delay_insert)
          if parts_to_throw_insert is not None:
              pulumi.set(__self__, "parts_to_throw_insert", parts_to_throw_insert)
          if replicated_deduplication_window is not None:
              pulumi.set(__self__, "replicated_deduplication_window", replicated_deduplication_window)
          if replicated_deduplication_window_seconds is not None:
              pulumi.set(__self__, "replicated_deduplication_window_seconds", replicated_deduplication_window_seconds)
  
      @property
      @pulumi.getter(name="maxBytesToMergeAtMinSpaceInPool")
      def max_bytes_to_merge_at_min_space_in_pool(self) -> Optional[pulumi.Input[int]]:
          """
          Max bytes to merge at min space in pool: Maximum total size of a data part to merge when the number of free threads in the background pool is minimum.
          """
          return pulumi.get(self, "max_bytes_to_merge_at_min_space_in_pool")
  
      @max_bytes_to_merge_at_min_space_in_pool.setter
      def max_bytes_to_merge_at_min_space_in_pool(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_bytes_to_merge_at_min_space_in_pool", value)
  
      @property
      @pulumi.getter(name="maxReplicatedMergesInQueue")
      def max_replicated_merges_in_queue(self) -> Optional[pulumi.Input[int]]:
          """
          Max replicated merges in queue: Maximum number of merge tasks that can be in the ReplicatedMergeTree queue at the same time.
          """
          return pulumi.get(self, "max_replicated_merges_in_queue")
  
      @max_replicated_merges_in_queue.setter
      def max_replicated_merges_in_queue(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_replicated_merges_in_queue", value)
  
      @property
      @pulumi.getter(name="numberOfFreeEntriesInPoolToLowerMaxSizeOfMerge")
      def number_of_free_entries_in_pool_to_lower_max_size_of_merge(self) -> Optional[pulumi.Input[int]]:
          """
          Number of free entries in pool to lower max size of merge: Threshold value of free entries in the pool. If the number of entries in the pool falls below this value, ClickHouse reduces the maximum size of a data part to merge. This helps handle small merges faster, rather than filling the pool with lengthy merges.
          """
          return pulumi.get(self, "number_of_free_entries_in_pool_to_lower_max_size_of_merge")
  
      @number_of_free_entries_in_pool_to_lower_max_size_of_merge.setter
      def number_of_free_entries_in_pool_to_lower_max_size_of_merge(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "number_of_free_entries_in_pool_to_lower_max_size_of_merge", value)
  
      @property
      @pulumi.getter(name="partsToDelayInsert")
      def parts_to_delay_insert(self) -> Optional[pulumi.Input[int]]:
          """
          Parts to delay insert: Number of active data parts in a table, on exceeding which ClickHouse starts artificially reduce the rate of inserting data into the table.
          """
          return pulumi.get(self, "parts_to_delay_insert")
  
      @parts_to_delay_insert.setter
      def parts_to_delay_insert(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "parts_to_delay_insert", value)
  
      @property
      @pulumi.getter(name="partsToThrowInsert")
      def parts_to_throw_insert(self) -> Optional[pulumi.Input[int]]:
          """
          Parts to throw insert: Threshold value of active data parts in a table, on exceeding which ClickHouse throws the 'Too many parts ...' exception.
          """
          return pulumi.get(self, "parts_to_throw_insert")
  
      @parts_to_throw_insert.setter
      def parts_to_throw_insert(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "parts_to_throw_insert", value)
  
      @property
      @pulumi.getter(name="replicatedDeduplicationWindow")
      def replicated_deduplication_window(self) -> Optional[pulumi.Input[int]]:
          """
          Replicated deduplication window: Number of recent hash blocks that ZooKeeper will store (the old ones will be deleted).
          """
          return pulumi.get(self, "replicated_deduplication_window")
  
      @replicated_deduplication_window.setter
      def replicated_deduplication_window(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "replicated_deduplication_window", value)
  
      @property
      @pulumi.getter(name="replicatedDeduplicationWindowSeconds")
      def replicated_deduplication_window_seconds(self) -> Optional[pulumi.Input[int]]:
          """
          Replicated deduplication window seconds: Time during which ZooKeeper stores the hash blocks (the old ones wil be deleted).
          """
          return pulumi.get(self, "replicated_deduplication_window_seconds")
  
      @replicated_deduplication_window_seconds.setter
      def replicated_deduplication_window_seconds(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "replicated_deduplication_window_seconds", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterClickhouseConfigRabbitmqArgs:
      def __init__(__self__, *,
                   password: Optional[pulumi.Input[str]] = None,
                   username: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] password: RabbitMQ user password.
          :param pulumi.Input[str] username: RabbitMQ username.
          """
          if password is not None:
              pulumi.set(__self__, "password", password)
          if username is not None:
              pulumi.set(__self__, "username", username)
  
      @property
      @pulumi.getter
      def password(self) -> Optional[pulumi.Input[str]]:
          """
          RabbitMQ user password.
          """
          return pulumi.get(self, "password")
  
      @password.setter
      def password(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "password", value)
  
      @property
      @pulumi.getter
      def username(self) -> Optional[pulumi.Input[str]]:
          """
          RabbitMQ username.
          """
          return pulumi.get(self, "username")
  
      @username.setter
      def username(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "username", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterClickhouseResourcesArgs:
      def __init__(__self__, *,
                   disk_size: pulumi.Input[int],
                   disk_type_id: pulumi.Input[str],
                   resource_preset_id: pulumi.Input[str]):
          """
          :param pulumi.Input[int] disk_size: Volume of the storage available to a ZooKeeper host, in gigabytes.
          :param pulumi.Input[str] disk_type_id: Type of the storage of ZooKeeper hosts.
                 For more information see [the official documentation](https://cloud.yandex.com/docs/managed-clickhouse/concepts/storage).
          """
          pulumi.set(__self__, "disk_size", disk_size)
          pulumi.set(__self__, "disk_type_id", disk_type_id)
          pulumi.set(__self__, "resource_preset_id", resource_preset_id)
  
      @property
      @pulumi.getter(name="diskSize")
      def disk_size(self) -> pulumi.Input[int]:
          """
          Volume of the storage available to a ZooKeeper host, in gigabytes.
          """
          return pulumi.get(self, "disk_size")
  
      @disk_size.setter
      def disk_size(self, value: pulumi.Input[int]):
          pulumi.set(self, "disk_size", value)
  
      @property
      @pulumi.getter(name="diskTypeId")
      def disk_type_id(self) -> pulumi.Input[str]:
          """
          Type of the storage of ZooKeeper hosts.
          For more information see [the official documentation](https://cloud.yandex.com/docs/managed-clickhouse/concepts/storage).
          """
          return pulumi.get(self, "disk_type_id")
  
      @disk_type_id.setter
      def disk_type_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "disk_type_id", value)
  
      @property
      @pulumi.getter(name="resourcePresetId")
      def resource_preset_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "resource_preset_id")
  
      @resource_preset_id.setter
      def resource_preset_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "resource_preset_id", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterCloudStorageArgs:
      def __init__(__self__, *,
                   enabled: pulumi.Input[bool]):
          """
          :param pulumi.Input[bool] enabled: Whether to use Yandex Object Storage for storing ClickHouse data. Can be either `true` or `false`.
          """
          pulumi.set(__self__, "enabled", enabled)
  
      @property
      @pulumi.getter
      def enabled(self) -> pulumi.Input[bool]:
          """
          Whether to use Yandex Object Storage for storing ClickHouse data. Can be either `true` or `false`.
          """
          return pulumi.get(self, "enabled")
  
      @enabled.setter
      def enabled(self, value: pulumi.Input[bool]):
          pulumi.set(self, "enabled", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterDatabaseArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str]):
          """
          :param pulumi.Input[str] name: Graphite rollup configuration name.
          """
          pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          Graphite rollup configuration name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterFormatSchemaArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   type: pulumi.Input[str],
                   uri: pulumi.Input[str]):
          """
          :param pulumi.Input[str] name: Graphite rollup configuration name.
          :param pulumi.Input[str] type: Type of maintenance window. Can be either `ANYTIME` or `WEEKLY`. A day and hour of window need to be specified with weekly window.
          :param pulumi.Input[str] uri: Model file URL. You can only use models stored in Yandex Object Storage.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "type", type)
          pulumi.set(__self__, "uri", uri)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          Graphite rollup configuration name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def type(self) -> pulumi.Input[str]:
          """
          Type of maintenance window. Can be either `ANYTIME` or `WEEKLY`. A day and hour of window need to be specified with weekly window.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: pulumi.Input[str]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter
      def uri(self) -> pulumi.Input[str]:
          """
          Model file URL. You can only use models stored in Yandex Object Storage.
          """
          return pulumi.get(self, "uri")
  
      @uri.setter
      def uri(self, value: pulumi.Input[str]):
          pulumi.set(self, "uri", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterHostArgs:
      def __init__(__self__, *,
                   type: pulumi.Input[str],
                   zone: pulumi.Input[str],
                   assign_public_ip: Optional[pulumi.Input[bool]] = None,
                   fqdn: Optional[pulumi.Input[str]] = None,
                   shard_name: Optional[pulumi.Input[str]] = None,
                   subnet_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] type: Type of maintenance window. Can be either `ANYTIME` or `WEEKLY`. A day and hour of window need to be specified with weekly window.
          :param pulumi.Input[str] zone: The availability zone where the ClickHouse host will be created.
                 For more information see [the official documentation](https://cloud.yandex.com/docs/overview/concepts/geo-scope).
          :param pulumi.Input[bool] assign_public_ip: Sets whether the host should get a public IP address on creation. Can be either `true` or `false`.
          :param pulumi.Input[str] fqdn: The fully qualified domain name of the host.
          :param pulumi.Input[str] shard_name: The name of the shard to which the host belongs.
          :param pulumi.Input[str] subnet_id: The ID of the subnet, to which the host belongs. The subnet must be a part of the network to which the cluster belongs.
          """
          pulumi.set(__self__, "type", type)
          pulumi.set(__self__, "zone", zone)
          if assign_public_ip is not None:
              pulumi.set(__self__, "assign_public_ip", assign_public_ip)
          if fqdn is not None:
              pulumi.set(__self__, "fqdn", fqdn)
          if shard_name is not None:
              pulumi.set(__self__, "shard_name", shard_name)
          if subnet_id is not None:
              pulumi.set(__self__, "subnet_id", subnet_id)
  
      @property
      @pulumi.getter
      def type(self) -> pulumi.Input[str]:
          """
          Type of maintenance window. Can be either `ANYTIME` or `WEEKLY`. A day and hour of window need to be specified with weekly window.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: pulumi.Input[str]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter
      def zone(self) -> pulumi.Input[str]:
          """
          The availability zone where the ClickHouse host will be created.
          For more information see [the official documentation](https://cloud.yandex.com/docs/overview/concepts/geo-scope).
          """
          return pulumi.get(self, "zone")
  
      @zone.setter
      def zone(self, value: pulumi.Input[str]):
          pulumi.set(self, "zone", value)
  
      @property
      @pulumi.getter(name="assignPublicIp")
      def assign_public_ip(self) -> Optional[pulumi.Input[bool]]:
          """
          Sets whether the host should get a public IP address on creation. Can be either `true` or `false`.
          """
          return pulumi.get(self, "assign_public_ip")
  
      @assign_public_ip.setter
      def assign_public_ip(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "assign_public_ip", value)
  
      @property
      @pulumi.getter
      def fqdn(self) -> Optional[pulumi.Input[str]]:
          """
          The fully qualified domain name of the host.
          """
          return pulumi.get(self, "fqdn")
  
      @fqdn.setter
      def fqdn(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "fqdn", value)
  
      @property
      @pulumi.getter(name="shardName")
      def shard_name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the shard to which the host belongs.
          """
          return pulumi.get(self, "shard_name")
  
      @shard_name.setter
      def shard_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "shard_name", value)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> Optional[pulumi.Input[str]]:
          """
          The ID of the subnet, to which the host belongs. The subnet must be a part of the network to which the cluster belongs.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "subnet_id", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterMaintenanceWindowArgs:
      def __init__(__self__, *,
                   type: pulumi.Input[str],
                   day: Optional[pulumi.Input[str]] = None,
                   hour: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] type: Type of maintenance window. Can be either `ANYTIME` or `WEEKLY`. A day and hour of window need to be specified with weekly window.
          :param pulumi.Input[str] day: Day of week for maintenance window if window type is weekly. Possible values: `MON`, `TUE`, `WED`, `THU`, `FRI`, `SAT`, `SUN`.
          :param pulumi.Input[int] hour: Hour of day in UTC time zone (1-24) for maintenance window if window type is weekly.
          """
          pulumi.set(__self__, "type", type)
          if day is not None:
              pulumi.set(__self__, "day", day)
          if hour is not None:
              pulumi.set(__self__, "hour", hour)
  
      @property
      @pulumi.getter
      def type(self) -> pulumi.Input[str]:
          """
          Type of maintenance window. Can be either `ANYTIME` or `WEEKLY`. A day and hour of window need to be specified with weekly window.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: pulumi.Input[str]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter
      def day(self) -> Optional[pulumi.Input[str]]:
          """
          Day of week for maintenance window if window type is weekly. Possible values: `MON`, `TUE`, `WED`, `THU`, `FRI`, `SAT`, `SUN`.
          """
          return pulumi.get(self, "day")
  
      @day.setter
      def day(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "day", value)
  
      @property
      @pulumi.getter
      def hour(self) -> Optional[pulumi.Input[int]]:
          """
          Hour of day in UTC time zone (1-24) for maintenance window if window type is weekly.
          """
          return pulumi.get(self, "hour")
  
      @hour.setter
      def hour(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "hour", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterMlModelArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   type: pulumi.Input[str],
                   uri: pulumi.Input[str]):
          """
          :param pulumi.Input[str] name: Graphite rollup configuration name.
          :param pulumi.Input[str] type: Type of maintenance window. Can be either `ANYTIME` or `WEEKLY`. A day and hour of window need to be specified with weekly window.
          :param pulumi.Input[str] uri: Model file URL. You can only use models stored in Yandex Object Storage.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "type", type)
          pulumi.set(__self__, "uri", uri)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          Graphite rollup configuration name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def type(self) -> pulumi.Input[str]:
          """
          Type of maintenance window. Can be either `ANYTIME` or `WEEKLY`. A day and hour of window need to be specified with weekly window.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: pulumi.Input[str]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter
      def uri(self) -> pulumi.Input[str]:
          """
          Model file URL. You can only use models stored in Yandex Object Storage.
          """
          return pulumi.get(self, "uri")
  
      @uri.setter
      def uri(self, value: pulumi.Input[str]):
          pulumi.set(self, "uri", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterShardGroupArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   shard_names: pulumi.Input[Sequence[pulumi.Input[str]]],
                   description: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] name: Graphite rollup configuration name.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] shard_names: List of shards names that belong to the shard group.
          :param pulumi.Input[str] description: Description of the shard group.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "shard_names", shard_names)
          if description is not None:
              pulumi.set(__self__, "description", description)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          Graphite rollup configuration name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="shardNames")
      def shard_names(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          """
          List of shards names that belong to the shard group.
          """
          return pulumi.get(self, "shard_names")
  
      @shard_names.setter
      def shard_names(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "shard_names", value)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[pulumi.Input[str]]:
          """
          Description of the shard group.
          """
          return pulumi.get(self, "description")
  
      @description.setter
      def description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "description", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterUserArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   password: pulumi.Input[str],
                   permissions: Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterUserPermissionArgs']]]] = None,
                   quotas: Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterUserQuotaArgs']]]] = None,
                   settings: Optional[pulumi.Input['MdbClickhouseClusterUserSettingsArgs']] = None):
          """
          :param pulumi.Input[str] name: Graphite rollup configuration name.
          :param pulumi.Input[str] password: RabbitMQ user password.
          :param pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterUserPermissionArgs']]] permissions: Set of permissions granted to the user. The structure is documented below.
          :param pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterUserQuotaArgs']]] quotas: Set of user quotas. The structure is documented below.
          :param pulumi.Input['MdbClickhouseClusterUserSettingsArgs'] settings: Kafka connection settngs sanem as `kafka` block.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "password", password)
          if permissions is not None:
              pulumi.set(__self__, "permissions", permissions)
          if quotas is not None:
              pulumi.set(__self__, "quotas", quotas)
          if settings is not None:
              pulumi.set(__self__, "settings", settings)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          Graphite rollup configuration name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def password(self) -> pulumi.Input[str]:
          """
          RabbitMQ user password.
          """
          return pulumi.get(self, "password")
  
      @password.setter
      def password(self, value: pulumi.Input[str]):
          pulumi.set(self, "password", value)
  
      @property
      @pulumi.getter
      def permissions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterUserPermissionArgs']]]]:
          """
          Set of permissions granted to the user. The structure is documented below.
          """
          return pulumi.get(self, "permissions")
  
      @permissions.setter
      def permissions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterUserPermissionArgs']]]]):
          pulumi.set(self, "permissions", value)
  
      @property
      @pulumi.getter
      def quotas(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterUserQuotaArgs']]]]:
          """
          Set of user quotas. The structure is documented below.
          """
          return pulumi.get(self, "quotas")
  
      @quotas.setter
      def quotas(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MdbClickhouseClusterUserQuotaArgs']]]]):
          pulumi.set(self, "quotas", value)
  
      @property
      @pulumi.getter
      def settings(self) -> Optional[pulumi.Input['MdbClickhouseClusterUserSettingsArgs']]:
          """
          Kafka connection settngs sanem as `kafka` block.
          """
          return pulumi.get(self, "settings")
  
      @settings.setter
      def settings(self, value: Optional[pulumi.Input['MdbClickhouseClusterUserSettingsArgs']]):
          pulumi.set(self, "settings", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterUserPermissionArgs:
      def __init__(__self__, *,
                   database_name: pulumi.Input[str]):
          """
          :param pulumi.Input[str] database_name: The name of the database that the permission grants access to.
          """
          pulumi.set(__self__, "database_name", database_name)
  
      @property
      @pulumi.getter(name="databaseName")
      def database_name(self) -> pulumi.Input[str]:
          """
          The name of the database that the permission grants access to.
          """
          return pulumi.get(self, "database_name")
  
      @database_name.setter
      def database_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "database_name", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterUserQuotaArgs:
      def __init__(__self__, *,
                   interval_duration: pulumi.Input[int],
                   errors: Optional[pulumi.Input[int]] = None,
                   execution_time: Optional[pulumi.Input[int]] = None,
                   queries: Optional[pulumi.Input[int]] = None,
                   read_rows: Optional[pulumi.Input[int]] = None,
                   result_rows: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] interval_duration: Duration of interval for quota in milliseconds.
          :param pulumi.Input[int] errors: The number of queries that threw exception.
          :param pulumi.Input[int] execution_time: The total query execution time, in milliseconds (wall time).
          :param pulumi.Input[int] queries: The total number of queries.
          :param pulumi.Input[int] read_rows: The total number of source rows read from tables for running the query, on all remote servers.
          :param pulumi.Input[int] result_rows: The total number of rows given as the result.
          """
          pulumi.set(__self__, "interval_duration", interval_duration)
          if errors is not None:
              pulumi.set(__self__, "errors", errors)
          if execution_time is not None:
              pulumi.set(__self__, "execution_time", execution_time)
          if queries is not None:
              pulumi.set(__self__, "queries", queries)
          if read_rows is not None:
              pulumi.set(__self__, "read_rows", read_rows)
          if result_rows is not None:
              pulumi.set(__self__, "result_rows", result_rows)
  
      @property
      @pulumi.getter(name="intervalDuration")
      def interval_duration(self) -> pulumi.Input[int]:
          """
          Duration of interval for quota in milliseconds.
          """
          return pulumi.get(self, "interval_duration")
  
      @interval_duration.setter
      def interval_duration(self, value: pulumi.Input[int]):
          pulumi.set(self, "interval_duration", value)
  
      @property
      @pulumi.getter
      def errors(self) -> Optional[pulumi.Input[int]]:
          """
          The number of queries that threw exception.
          """
          return pulumi.get(self, "errors")
  
      @errors.setter
      def errors(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "errors", value)
  
      @property
      @pulumi.getter(name="executionTime")
      def execution_time(self) -> Optional[pulumi.Input[int]]:
          """
          The total query execution time, in milliseconds (wall time).
          """
          return pulumi.get(self, "execution_time")
  
      @execution_time.setter
      def execution_time(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "execution_time", value)
  
      @property
      @pulumi.getter
      def queries(self) -> Optional[pulumi.Input[int]]:
          """
          The total number of queries.
          """
          return pulumi.get(self, "queries")
  
      @queries.setter
      def queries(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "queries", value)
  
      @property
      @pulumi.getter(name="readRows")
      def read_rows(self) -> Optional[pulumi.Input[int]]:
          """
          The total number of source rows read from tables for running the query, on all remote servers.
          """
          return pulumi.get(self, "read_rows")
  
      @read_rows.setter
      def read_rows(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "read_rows", value)
  
      @property
      @pulumi.getter(name="resultRows")
      def result_rows(self) -> Optional[pulumi.Input[int]]:
          """
          The total number of rows given as the result.
          """
          return pulumi.get(self, "result_rows")
  
      @result_rows.setter
      def result_rows(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "result_rows", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterUserSettingsArgs:
      def __init__(__self__, *,
                   add_http_cors_header: Optional[pulumi.Input[bool]] = None,
                   allow_ddl: Optional[pulumi.Input[bool]] = None,
                   compile: Optional[pulumi.Input[bool]] = None,
                   compile_expressions: Optional[pulumi.Input[bool]] = None,
                   connect_timeout: Optional[pulumi.Input[int]] = None,
                   count_distinct_implementation: Optional[pulumi.Input[str]] = None,
                   distinct_overflow_mode: Optional[pulumi.Input[str]] = None,
                   distributed_aggregation_memory_efficient: Optional[pulumi.Input[bool]] = None,
                   distributed_ddl_task_timeout: Optional[pulumi.Input[int]] = None,
                   distributed_product_mode: Optional[pulumi.Input[str]] = None,
                   empty_result_for_aggregation_by_empty_set: Optional[pulumi.Input[bool]] = None,
                   enable_http_compression: Optional[pulumi.Input[bool]] = None,
                   fallback_to_stale_replicas_for_distributed_queries: Optional[pulumi.Input[bool]] = None,
                   force_index_by_date: Optional[pulumi.Input[bool]] = None,
                   force_primary_key: Optional[pulumi.Input[bool]] = None,
                   group_by_overflow_mode: Optional[pulumi.Input[str]] = None,
                   group_by_two_level_threshold: Optional[pulumi.Input[int]] = None,
                   group_by_two_level_threshold_bytes: Optional[pulumi.Input[int]] = None,
                   http_connection_timeout: Optional[pulumi.Input[int]] = None,
                   http_headers_progress_interval: Optional[pulumi.Input[int]] = None,
                   http_receive_timeout: Optional[pulumi.Input[int]] = None,
                   http_send_timeout: Optional[pulumi.Input[int]] = None,
                   input_format_defaults_for_omitted_fields: Optional[pulumi.Input[bool]] = None,
                   input_format_values_interpret_expressions: Optional[pulumi.Input[bool]] = None,
                   insert_quorum: Optional[pulumi.Input[int]] = None,
                   insert_quorum_timeout: Optional[pulumi.Input[int]] = None,
                   join_overflow_mode: Optional[pulumi.Input[str]] = None,
                   join_use_nulls: Optional[pulumi.Input[bool]] = None,
                   joined_subquery_requires_alias: Optional[pulumi.Input[bool]] = None,
                   low_cardinality_allow_in_native_format: Optional[pulumi.Input[bool]] = None,
                   max_ast_depth: Optional[pulumi.Input[int]] = None,
                   max_ast_elements: Optional[pulumi.Input[int]] = None,
                   max_block_size: Optional[pulumi.Input[int]] = None,
                   max_bytes_before_external_group_by: Optional[pulumi.Input[int]] = None,
                   max_bytes_before_external_sort: Optional[pulumi.Input[int]] = None,
                   max_bytes_in_distinct: Optional[pulumi.Input[int]] = None,
                   max_bytes_in_join: Optional[pulumi.Input[int]] = None,
                   max_bytes_in_set: Optional[pulumi.Input[int]] = None,
                   max_bytes_to_read: Optional[pulumi.Input[int]] = None,
                   max_bytes_to_sort: Optional[pulumi.Input[int]] = None,
                   max_bytes_to_transfer: Optional[pulumi.Input[int]] = None,
                   max_columns_to_read: Optional[pulumi.Input[int]] = None,
                   max_execution_time: Optional[pulumi.Input[int]] = None,
                   max_expanded_ast_elements: Optional[pulumi.Input[int]] = None,
                   max_insert_block_size: Optional[pulumi.Input[int]] = None,
                   max_memory_usage: Optional[pulumi.Input[int]] = None,
                   max_memory_usage_for_user: Optional[pulumi.Input[int]] = None,
                   max_network_bandwidth: Optional[pulumi.Input[int]] = None,
                   max_network_bandwidth_for_user: Optional[pulumi.Input[int]] = None,
                   max_query_size: Optional[pulumi.Input[int]] = None,
                   max_replica_delay_for_distributed_queries: Optional[pulumi.Input[int]] = None,
                   max_result_bytes: Optional[pulumi.Input[int]] = None,
                   max_result_rows: Optional[pulumi.Input[int]] = None,
                   max_rows_in_distinct: Optional[pulumi.Input[int]] = None,
                   max_rows_in_join: Optional[pulumi.Input[int]] = None,
                   max_rows_in_set: Optional[pulumi.Input[int]] = None,
                   max_rows_to_group_by: Optional[pulumi.Input[int]] = None,
                   max_rows_to_read: Optional[pulumi.Input[int]] = None,
                   max_rows_to_sort: Optional[pulumi.Input[int]] = None,
                   max_rows_to_transfer: Optional[pulumi.Input[int]] = None,
                   max_temporary_columns: Optional[pulumi.Input[int]] = None,
                   max_temporary_non_const_columns: Optional[pulumi.Input[int]] = None,
                   max_threads: Optional[pulumi.Input[int]] = None,
                   merge_tree_max_bytes_to_use_cache: Optional[pulumi.Input[int]] = None,
                   merge_tree_max_rows_to_use_cache: Optional[pulumi.Input[int]] = None,
                   merge_tree_min_bytes_for_concurrent_read: Optional[pulumi.Input[int]] = None,
                   merge_tree_min_rows_for_concurrent_read: Optional[pulumi.Input[int]] = None,
                   min_bytes_to_use_direct_io: Optional[pulumi.Input[int]] = None,
                   min_count_to_compile: Optional[pulumi.Input[int]] = None,
                   min_count_to_compile_expression: Optional[pulumi.Input[int]] = None,
                   min_execution_speed: Optional[pulumi.Input[int]] = None,
                   min_execution_speed_bytes: Optional[pulumi.Input[int]] = None,
                   min_insert_block_size_bytes: Optional[pulumi.Input[int]] = None,
                   min_insert_block_size_rows: Optional[pulumi.Input[int]] = None,
                   output_format_json_quote64bit_integers: Optional[pulumi.Input[bool]] = None,
                   output_format_json_quote_denormals: Optional[pulumi.Input[bool]] = None,
                   priority: Optional[pulumi.Input[int]] = None,
                   quota_mode: Optional[pulumi.Input[str]] = None,
                   read_overflow_mode: Optional[pulumi.Input[str]] = None,
                   readonly: Optional[pulumi.Input[int]] = None,
                   receive_timeout: Optional[pulumi.Input[int]] = None,
                   replication_alter_partitions_sync: Optional[pulumi.Input[int]] = None,
                   result_overflow_mode: Optional[pulumi.Input[str]] = None,
                   select_sequential_consistency: Optional[pulumi.Input[bool]] = None,
                   send_progress_in_http_headers: Optional[pulumi.Input[bool]] = None,
                   send_timeout: Optional[pulumi.Input[int]] = None,
                   set_overflow_mode: Optional[pulumi.Input[str]] = None,
                   skip_unavailable_shards: Optional[pulumi.Input[bool]] = None,
                   sort_overflow_mode: Optional[pulumi.Input[str]] = None,
                   timeout_overflow_mode: Optional[pulumi.Input[str]] = None,
                   transfer_overflow_mode: Optional[pulumi.Input[str]] = None,
                   transform_null_in: Optional[pulumi.Input[bool]] = None,
                   use_uncompressed_cache: Optional[pulumi.Input[bool]] = None):
          """
          :param pulumi.Input[bool] add_http_cors_header: Include CORS headers in HTTP responces.
          :param pulumi.Input[bool] allow_ddl: Allows or denies DDL queries.
          :param pulumi.Input[bool] compile: Enable compilation of queries.
          :param pulumi.Input[bool] compile_expressions: Turn on expression compilation.
          :param pulumi.Input[int] connect_timeout: Connect timeout in milliseconds on the socket used for communicating with the client.
          :param pulumi.Input[str] count_distinct_implementation: Specifies which of the uniq* functions should be used to perform the COUNT(DISTINCT …) construction.
          :param pulumi.Input[str] distinct_overflow_mode: Sets behaviour on overflow when using DISTINCT. Possible values:
          :param pulumi.Input[bool] distributed_aggregation_memory_efficient: Determine the behavior of distributed subqueries.
          :param pulumi.Input[int] distributed_ddl_task_timeout: Timeout for DDL queries, in milliseconds.
          :param pulumi.Input[str] distributed_product_mode: Changes the behaviour of distributed subqueries.
          :param pulumi.Input[bool] empty_result_for_aggregation_by_empty_set: Allows to retunr empty result.
          :param pulumi.Input[bool] enable_http_compression: Enables or disables data compression in the response to an HTTP request.
          :param pulumi.Input[bool] fallback_to_stale_replicas_for_distributed_queries: Forces a query to an out-of-date replica if updated data is not available.
          :param pulumi.Input[bool] force_index_by_date: Disables query execution if the index can’t be used by date.
          :param pulumi.Input[bool] force_primary_key: Disables query execution if indexing by the primary key is not possible.
          :param pulumi.Input[str] group_by_overflow_mode: Sets behaviour on overflow while GROUP BY operation. Possible values:
          :param pulumi.Input[int] group_by_two_level_threshold: Sets the threshold of the number of keys, after that the two-level aggregation should be used.
          :param pulumi.Input[int] group_by_two_level_threshold_bytes: Sets the threshold of the number of bytes, after that the two-level aggregation should be used.
          :param pulumi.Input[int] http_connection_timeout: Timeout for HTTP connection in milliseconds.
          :param pulumi.Input[int] http_headers_progress_interval: Sets minimal interval between notifications about request process in HTTP header X-ClickHouse-Progress.
          :param pulumi.Input[int] http_receive_timeout: Timeout for HTTP connection in milliseconds.
          :param pulumi.Input[int] http_send_timeout: Timeout for HTTP connection in milliseconds.
          :param pulumi.Input[bool] input_format_defaults_for_omitted_fields: When performing INSERT queries, replace omitted input column values with default values of the respective columns.
          :param pulumi.Input[bool] input_format_values_interpret_expressions: Enables or disables the full SQL parser if the fast stream parser can’t parse the data.
          :param pulumi.Input[int] insert_quorum: Enables the quorum writes.
          :param pulumi.Input[int] insert_quorum_timeout: Write to a quorum timeout in milliseconds.
          :param pulumi.Input[str] join_overflow_mode: Sets behaviour on overflow in JOIN. Possible values:
          :param pulumi.Input[bool] join_use_nulls: Sets the type of JOIN behaviour. When merging tables, empty cells may appear. ClickHouse fills them differently based on this setting.
          :param pulumi.Input[bool] joined_subquery_requires_alias: Require aliases for subselects and table functions in FROM that more than one table is present.
          :param pulumi.Input[bool] low_cardinality_allow_in_native_format: Allows or restricts using the LowCardinality data type with the Native format.
          :param pulumi.Input[int] max_ast_depth: Maximum abstract syntax tree depth.
          :param pulumi.Input[int] max_ast_elements: Maximum abstract syntax tree elements.
          :param pulumi.Input[int] max_block_size: A recommendation for what size of the block (in a count of rows) to load from tables.
          :param pulumi.Input[int] max_bytes_before_external_group_by: Limit in bytes for using memoru for GROUP BY before using swap on disk.
          :param pulumi.Input[int] max_bytes_before_external_sort: This setting is equivalent of the max_bytes_before_external_group_by setting, except for it is for sort operation (ORDER BY), not aggregation.
          :param pulumi.Input[int] max_bytes_in_distinct: Limits the maximum size of a hash table in bytes (uncompressed data) when using DISTINCT.
          :param pulumi.Input[int] max_bytes_in_join: Limit on maximum size of the hash table for JOIN, in bytes.
          :param pulumi.Input[int] max_bytes_in_set: Limit on the number of bytes in the set resulting from the execution of the IN section.
          :param pulumi.Input[int] max_bytes_to_read: Limits the maximum number of bytes (uncompressed data) that can be read from a table when running a query.
          :param pulumi.Input[int] max_bytes_to_sort: Limits the maximum number of bytes (uncompressed data) that can be read from a table for sorting.
          :param pulumi.Input[int] max_bytes_to_transfer: Limits the maximum number of bytes (uncompressed data) that can be passed to a remote server or saved in a temporary table when using GLOBAL IN.
          :param pulumi.Input[int] max_columns_to_read: Limits the maximum number of columns that can be read from a table in a single query.
          :param pulumi.Input[int] max_execution_time: Limits the maximum query execution time in milliseconds.
          :param pulumi.Input[int] max_expanded_ast_elements: Maximum abstract syntax tree depth after after expansion of aliases.
          :param pulumi.Input[int] max_insert_block_size: The size of blocks (in a count of rows) to form for insertion into a table.
          :param pulumi.Input[int] max_memory_usage: Limits the maximum memory usage (in bytes) for processing queries on a single server.
          :param pulumi.Input[int] max_memory_usage_for_user: Limits the maximum memory usage (in bytes) for processing of user's queries on a single server.
          :param pulumi.Input[int] max_network_bandwidth: Limits the speed of the data exchange over the network in bytes per second.
          :param pulumi.Input[int] max_network_bandwidth_for_user: Limits the speed of the data exchange over the network in bytes per second.
          :param pulumi.Input[int] max_query_size: The maximum part of a query that can be taken to RAM for parsing with the SQL parser.
          :param pulumi.Input[int] max_replica_delay_for_distributed_queries: Disables lagging replicas for distributed queries.
          :param pulumi.Input[int] max_result_bytes: Limits the number of bytes in the result.
          :param pulumi.Input[int] max_result_rows: Limits the number of rows in the result.
          :param pulumi.Input[int] max_rows_in_distinct: Limits the maximum number of different rows when using DISTINCT.
          :param pulumi.Input[int] max_rows_in_join: Limit on maximum size of the hash table for JOIN, in rows.
          :param pulumi.Input[int] max_rows_in_set: Limit on the number of rows in the set resulting from the execution of the IN section.
          :param pulumi.Input[int] max_rows_to_group_by: Limits the maximum number of unique keys received from aggregation function.
          :param pulumi.Input[int] max_rows_to_read: Limits the maximum number of rows that can be read from a table when running a query.
          :param pulumi.Input[int] max_rows_to_sort: Limits the maximum number of rows that can be read from a table for sorting.
          :param pulumi.Input[int] max_rows_to_transfer: Limits the maximum number of rows that can be passed to a remote server or saved in a temporary table when using GLOBAL IN.
          :param pulumi.Input[int] max_temporary_columns: Limits the maximum number of temporary columns that must be kept in RAM at the same time when running a query, including constant columns.
          :param pulumi.Input[int] max_temporary_non_const_columns: Limits the maximum number of temporary columns that must be kept in RAM at the same time when running a query, excluding constant columns.
          :param pulumi.Input[int] max_threads: The maximum number of query processing threads, excluding threads for retrieving data from remote servers.
          :param pulumi.Input[int] merge_tree_max_bytes_to_use_cache: If ClickHouse should read more than merge_tree_max_bytes_to_use_cache bytes in one query, it doesn’t use the cache of uncompressed blocks.
          :param pulumi.Input[int] merge_tree_max_rows_to_use_cache: If ClickHouse should read more than merge_tree_max_rows_to_use_cache rows in one query, it doesn’t use the cache of uncompressed blocks.
          :param pulumi.Input[int] merge_tree_min_bytes_for_concurrent_read: If the number of bytes to read from one file of a MergeTree-engine table exceeds merge_tree_min_bytes_for_concurrent_read, then ClickHouse tries to concurrently read from this file in several threads.
          :param pulumi.Input[int] merge_tree_min_rows_for_concurrent_read: If the number of rows to be read from a file of a MergeTree table exceeds merge_tree_min_rows_for_concurrent_read then ClickHouse tries to perform a concurrent reading from this file on several threads.
          :param pulumi.Input[int] min_bytes_to_use_direct_io: The minimum data volume required for using direct I/O access to the storage disk.
          :param pulumi.Input[int] min_count_to_compile: How many times to potentially use a compiled chunk of code before running compilation.
          :param pulumi.Input[int] min_count_to_compile_expression: A query waits for expression compilation process to complete prior to continuing execution.
          :param pulumi.Input[int] min_execution_speed: Minimal execution speed in rows per second.
          :param pulumi.Input[int] min_execution_speed_bytes: Minimal execution speed in bytes per second.
          :param pulumi.Input[int] min_insert_block_size_bytes: Sets the minimum number of bytes in the block which can be inserted into a table by an INSERT query.
          :param pulumi.Input[int] min_insert_block_size_rows: Sets the minimum number of rows in the block which can be inserted into a table by an INSERT query.
          :param pulumi.Input[bool] output_format_json_quote64bit_integers: If the value is true, integers appear in quotes when using JSON* Int64 and UInt64 formats (for compatibility with most JavaScript implementations); otherwise, integers are output without the quotes.
          :param pulumi.Input[bool] output_format_json_quote_denormals: Enables +nan, -nan, +inf, -inf outputs in JSON output format.
          :param pulumi.Input[int] priority: Query priority.
          :param pulumi.Input[str] quota_mode: Quota accounting mode.
          :param pulumi.Input[str] read_overflow_mode: Sets behaviour on overflow while read. Possible values:
          :param pulumi.Input[int] readonly: Restricts permissions for reading data, write data and change settings queries.
          :param pulumi.Input[int] receive_timeout: Receive timeout in milliseconds on the socket used for communicating with the client.
          :param pulumi.Input[int] replication_alter_partitions_sync: For ALTER ... ATTACH|DETACH|DROP queries, you can use the replication_alter_partitions_sync setting to set up waiting.
          :param pulumi.Input[str] result_overflow_mode: Sets behaviour on overflow in result. Possible values:
          :param pulumi.Input[bool] select_sequential_consistency: Enables or disables sequential consistency for SELECT queries.
          :param pulumi.Input[bool] send_progress_in_http_headers: Enables or disables X-ClickHouse-Progress HTTP response headers in clickhouse-server responses.
          :param pulumi.Input[int] send_timeout: Send timeout in milliseconds on the socket used for communicating with the client.
          :param pulumi.Input[str] set_overflow_mode: Sets behaviour on overflow in the set resulting. Possible values:
          :param pulumi.Input[bool] skip_unavailable_shards: Enables or disables silently skipping of unavailable shards.
          :param pulumi.Input[str] sort_overflow_mode: Sets behaviour on overflow while sort. Possible values:
          :param pulumi.Input[str] timeout_overflow_mode: Sets behaviour on overflow. Possible values:
          :param pulumi.Input[str] transfer_overflow_mode: Sets behaviour on overflow. Possible values:
          :param pulumi.Input[bool] transform_null_in: Enables equality of NULL values for IN operator.
          :param pulumi.Input[bool] use_uncompressed_cache: Whether to use a cache of uncompressed blocks.
          """
          if add_http_cors_header is not None:
              pulumi.set(__self__, "add_http_cors_header", add_http_cors_header)
          if allow_ddl is not None:
              pulumi.set(__self__, "allow_ddl", allow_ddl)
          if compile is not None:
              pulumi.set(__self__, "compile", compile)
          if compile_expressions is not None:
              pulumi.set(__self__, "compile_expressions", compile_expressions)
          if connect_timeout is not None:
              pulumi.set(__self__, "connect_timeout", connect_timeout)
          if count_distinct_implementation is not None:
              pulumi.set(__self__, "count_distinct_implementation", count_distinct_implementation)
          if distinct_overflow_mode is not None:
              pulumi.set(__self__, "distinct_overflow_mode", distinct_overflow_mode)
          if distributed_aggregation_memory_efficient is not None:
              pulumi.set(__self__, "distributed_aggregation_memory_efficient", distributed_aggregation_memory_efficient)
          if distributed_ddl_task_timeout is not None:
              pulumi.set(__self__, "distributed_ddl_task_timeout", distributed_ddl_task_timeout)
          if distributed_product_mode is not None:
              pulumi.set(__self__, "distributed_product_mode", distributed_product_mode)
          if empty_result_for_aggregation_by_empty_set is not None:
              pulumi.set(__self__, "empty_result_for_aggregation_by_empty_set", empty_result_for_aggregation_by_empty_set)
          if enable_http_compression is not None:
              pulumi.set(__self__, "enable_http_compression", enable_http_compression)
          if fallback_to_stale_replicas_for_distributed_queries is not None:
              pulumi.set(__self__, "fallback_to_stale_replicas_for_distributed_queries", fallback_to_stale_replicas_for_distributed_queries)
          if force_index_by_date is not None:
              pulumi.set(__self__, "force_index_by_date", force_index_by_date)
          if force_primary_key is not None:
              pulumi.set(__self__, "force_primary_key", force_primary_key)
          if group_by_overflow_mode is not None:
              pulumi.set(__self__, "group_by_overflow_mode", group_by_overflow_mode)
          if group_by_two_level_threshold is not None:
              pulumi.set(__self__, "group_by_two_level_threshold", group_by_two_level_threshold)
          if group_by_two_level_threshold_bytes is not None:
              pulumi.set(__self__, "group_by_two_level_threshold_bytes", group_by_two_level_threshold_bytes)
          if http_connection_timeout is not None:
              pulumi.set(__self__, "http_connection_timeout", http_connection_timeout)
          if http_headers_progress_interval is not None:
              pulumi.set(__self__, "http_headers_progress_interval", http_headers_progress_interval)
          if http_receive_timeout is not None:
              pulumi.set(__self__, "http_receive_timeout", http_receive_timeout)
          if http_send_timeout is not None:
              pulumi.set(__self__, "http_send_timeout", http_send_timeout)
          if input_format_defaults_for_omitted_fields is not None:
              pulumi.set(__self__, "input_format_defaults_for_omitted_fields", input_format_defaults_for_omitted_fields)
          if input_format_values_interpret_expressions is not None:
              pulumi.set(__self__, "input_format_values_interpret_expressions", input_format_values_interpret_expressions)
          if insert_quorum is not None:
              pulumi.set(__self__, "insert_quorum", insert_quorum)
          if insert_quorum_timeout is not None:
              pulumi.set(__self__, "insert_quorum_timeout", insert_quorum_timeout)
          if join_overflow_mode is not None:
              pulumi.set(__self__, "join_overflow_mode", join_overflow_mode)
          if join_use_nulls is not None:
              pulumi.set(__self__, "join_use_nulls", join_use_nulls)
          if joined_subquery_requires_alias is not None:
              pulumi.set(__self__, "joined_subquery_requires_alias", joined_subquery_requires_alias)
          if low_cardinality_allow_in_native_format is not None:
              pulumi.set(__self__, "low_cardinality_allow_in_native_format", low_cardinality_allow_in_native_format)
          if max_ast_depth is not None:
              pulumi.set(__self__, "max_ast_depth", max_ast_depth)
          if max_ast_elements is not None:
              pulumi.set(__self__, "max_ast_elements", max_ast_elements)
          if max_block_size is not None:
              pulumi.set(__self__, "max_block_size", max_block_size)
          if max_bytes_before_external_group_by is not None:
              pulumi.set(__self__, "max_bytes_before_external_group_by", max_bytes_before_external_group_by)
          if max_bytes_before_external_sort is not None:
              pulumi.set(__self__, "max_bytes_before_external_sort", max_bytes_before_external_sort)
          if max_bytes_in_distinct is not None:
              pulumi.set(__self__, "max_bytes_in_distinct", max_bytes_in_distinct)
          if max_bytes_in_join is not None:
              pulumi.set(__self__, "max_bytes_in_join", max_bytes_in_join)
          if max_bytes_in_set is not None:
              pulumi.set(__self__, "max_bytes_in_set", max_bytes_in_set)
          if max_bytes_to_read is not None:
              pulumi.set(__self__, "max_bytes_to_read", max_bytes_to_read)
          if max_bytes_to_sort is not None:
              pulumi.set(__self__, "max_bytes_to_sort", max_bytes_to_sort)
          if max_bytes_to_transfer is not None:
              pulumi.set(__self__, "max_bytes_to_transfer", max_bytes_to_transfer)
          if max_columns_to_read is not None:
              pulumi.set(__self__, "max_columns_to_read", max_columns_to_read)
          if max_execution_time is not None:
              pulumi.set(__self__, "max_execution_time", max_execution_time)
          if max_expanded_ast_elements is not None:
              pulumi.set(__self__, "max_expanded_ast_elements", max_expanded_ast_elements)
          if max_insert_block_size is not None:
              pulumi.set(__self__, "max_insert_block_size", max_insert_block_size)
          if max_memory_usage is not None:
              pulumi.set(__self__, "max_memory_usage", max_memory_usage)
          if max_memory_usage_for_user is not None:
              pulumi.set(__self__, "max_memory_usage_for_user", max_memory_usage_for_user)
          if max_network_bandwidth is not None:
              pulumi.set(__self__, "max_network_bandwidth", max_network_bandwidth)
          if max_network_bandwidth_for_user is not None:
              pulumi.set(__self__, "max_network_bandwidth_for_user", max_network_bandwidth_for_user)
          if max_query_size is not None:
              pulumi.set(__self__, "max_query_size", max_query_size)
          if max_replica_delay_for_distributed_queries is not None:
              pulumi.set(__self__, "max_replica_delay_for_distributed_queries", max_replica_delay_for_distributed_queries)
          if max_result_bytes is not None:
              pulumi.set(__self__, "max_result_bytes", max_result_bytes)
          if max_result_rows is not None:
              pulumi.set(__self__, "max_result_rows", max_result_rows)
          if max_rows_in_distinct is not None:
              pulumi.set(__self__, "max_rows_in_distinct", max_rows_in_distinct)
          if max_rows_in_join is not None:
              pulumi.set(__self__, "max_rows_in_join", max_rows_in_join)
          if max_rows_in_set is not None:
              pulumi.set(__self__, "max_rows_in_set", max_rows_in_set)
          if max_rows_to_group_by is not None:
              pulumi.set(__self__, "max_rows_to_group_by", max_rows_to_group_by)
          if max_rows_to_read is not None:
              pulumi.set(__self__, "max_rows_to_read", max_rows_to_read)
          if max_rows_to_sort is not None:
              pulumi.set(__self__, "max_rows_to_sort", max_rows_to_sort)
          if max_rows_to_transfer is not None:
              pulumi.set(__self__, "max_rows_to_transfer", max_rows_to_transfer)
          if max_temporary_columns is not None:
              pulumi.set(__self__, "max_temporary_columns", max_temporary_columns)
          if max_temporary_non_const_columns is not None:
              pulumi.set(__self__, "max_temporary_non_const_columns", max_temporary_non_const_columns)
          if max_threads is not None:
              pulumi.set(__self__, "max_threads", max_threads)
          if merge_tree_max_bytes_to_use_cache is not None:
              pulumi.set(__self__, "merge_tree_max_bytes_to_use_cache", merge_tree_max_bytes_to_use_cache)
          if merge_tree_max_rows_to_use_cache is not None:
              pulumi.set(__self__, "merge_tree_max_rows_to_use_cache", merge_tree_max_rows_to_use_cache)
          if merge_tree_min_bytes_for_concurrent_read is not None:
              pulumi.set(__self__, "merge_tree_min_bytes_for_concurrent_read", merge_tree_min_bytes_for_concurrent_read)
          if merge_tree_min_rows_for_concurrent_read is not None:
              pulumi.set(__self__, "merge_tree_min_rows_for_concurrent_read", merge_tree_min_rows_for_concurrent_read)
          if min_bytes_to_use_direct_io is not None:
              pulumi.set(__self__, "min_bytes_to_use_direct_io", min_bytes_to_use_direct_io)
          if min_count_to_compile is not None:
              pulumi.set(__self__, "min_count_to_compile", min_count_to_compile)
          if min_count_to_compile_expression is not None:
              pulumi.set(__self__, "min_count_to_compile_expression", min_count_to_compile_expression)
          if min_execution_speed is not None:
              pulumi.set(__self__, "min_execution_speed", min_execution_speed)
          if min_execution_speed_bytes is not None:
              pulumi.set(__self__, "min_execution_speed_bytes", min_execution_speed_bytes)
          if min_insert_block_size_bytes is not None:
              pulumi.set(__self__, "min_insert_block_size_bytes", min_insert_block_size_bytes)
          if min_insert_block_size_rows is not None:
              pulumi.set(__self__, "min_insert_block_size_rows", min_insert_block_size_rows)
          if output_format_json_quote64bit_integers is not None:
              pulumi.set(__self__, "output_format_json_quote64bit_integers", output_format_json_quote64bit_integers)
          if output_format_json_quote_denormals is not None:
              pulumi.set(__self__, "output_format_json_quote_denormals", output_format_json_quote_denormals)
          if priority is not None:
              pulumi.set(__self__, "priority", priority)
          if quota_mode is not None:
              pulumi.set(__self__, "quota_mode", quota_mode)
          if read_overflow_mode is not None:
              pulumi.set(__self__, "read_overflow_mode", read_overflow_mode)
          if readonly is not None:
              pulumi.set(__self__, "readonly", readonly)
          if receive_timeout is not None:
              pulumi.set(__self__, "receive_timeout", receive_timeout)
          if replication_alter_partitions_sync is not None:
              pulumi.set(__self__, "replication_alter_partitions_sync", replication_alter_partitions_sync)
          if result_overflow_mode is not None:
              pulumi.set(__self__, "result_overflow_mode", result_overflow_mode)
          if select_sequential_consistency is not None:
              pulumi.set(__self__, "select_sequential_consistency", select_sequential_consistency)
          if send_progress_in_http_headers is not None:
              pulumi.set(__self__, "send_progress_in_http_headers", send_progress_in_http_headers)
          if send_timeout is not None:
              pulumi.set(__self__, "send_timeout", send_timeout)
          if set_overflow_mode is not None:
              pulumi.set(__self__, "set_overflow_mode", set_overflow_mode)
          if skip_unavailable_shards is not None:
              pulumi.set(__self__, "skip_unavailable_shards", skip_unavailable_shards)
          if sort_overflow_mode is not None:
              pulumi.set(__self__, "sort_overflow_mode", sort_overflow_mode)
          if timeout_overflow_mode is not None:
              pulumi.set(__self__, "timeout_overflow_mode", timeout_overflow_mode)
          if transfer_overflow_mode is not None:
              pulumi.set(__self__, "transfer_overflow_mode", transfer_overflow_mode)
          if transform_null_in is not None:
              pulumi.set(__self__, "transform_null_in", transform_null_in)
          if use_uncompressed_cache is not None:
              pulumi.set(__self__, "use_uncompressed_cache", use_uncompressed_cache)
  
      @property
      @pulumi.getter(name="addHttpCorsHeader")
      def add_http_cors_header(self) -> Optional[pulumi.Input[bool]]:
          """
          Include CORS headers in HTTP responces.
          """
          return pulumi.get(self, "add_http_cors_header")
  
      @add_http_cors_header.setter
      def add_http_cors_header(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "add_http_cors_header", value)
  
      @property
      @pulumi.getter(name="allowDdl")
      def allow_ddl(self) -> Optional[pulumi.Input[bool]]:
          """
          Allows or denies DDL queries.
          """
          return pulumi.get(self, "allow_ddl")
  
      @allow_ddl.setter
      def allow_ddl(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "allow_ddl", value)
  
      @property
      @pulumi.getter
      def compile(self) -> Optional[pulumi.Input[bool]]:
          """
          Enable compilation of queries.
          """
          return pulumi.get(self, "compile")
  
      @compile.setter
      def compile(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "compile", value)
  
      @property
      @pulumi.getter(name="compileExpressions")
      def compile_expressions(self) -> Optional[pulumi.Input[bool]]:
          """
          Turn on expression compilation.
          """
          return pulumi.get(self, "compile_expressions")
  
      @compile_expressions.setter
      def compile_expressions(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "compile_expressions", value)
  
      @property
      @pulumi.getter(name="connectTimeout")
      def connect_timeout(self) -> Optional[pulumi.Input[int]]:
          """
          Connect timeout in milliseconds on the socket used for communicating with the client.
          """
          return pulumi.get(self, "connect_timeout")
  
      @connect_timeout.setter
      def connect_timeout(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "connect_timeout", value)
  
      @property
      @pulumi.getter(name="countDistinctImplementation")
      def count_distinct_implementation(self) -> Optional[pulumi.Input[str]]:
          """
          Specifies which of the uniq* functions should be used to perform the COUNT(DISTINCT …) construction.
          """
          return pulumi.get(self, "count_distinct_implementation")
  
      @count_distinct_implementation.setter
      def count_distinct_implementation(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "count_distinct_implementation", value)
  
      @property
      @pulumi.getter(name="distinctOverflowMode")
      def distinct_overflow_mode(self) -> Optional[pulumi.Input[str]]:
          """
          Sets behaviour on overflow when using DISTINCT. Possible values:
          """
          return pulumi.get(self, "distinct_overflow_mode")
  
      @distinct_overflow_mode.setter
      def distinct_overflow_mode(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "distinct_overflow_mode", value)
  
      @property
      @pulumi.getter(name="distributedAggregationMemoryEfficient")
      def distributed_aggregation_memory_efficient(self) -> Optional[pulumi.Input[bool]]:
          """
          Determine the behavior of distributed subqueries.
          """
          return pulumi.get(self, "distributed_aggregation_memory_efficient")
  
      @distributed_aggregation_memory_efficient.setter
      def distributed_aggregation_memory_efficient(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "distributed_aggregation_memory_efficient", value)
  
      @property
      @pulumi.getter(name="distributedDdlTaskTimeout")
      def distributed_ddl_task_timeout(self) -> Optional[pulumi.Input[int]]:
          """
          Timeout for DDL queries, in milliseconds.
          """
          return pulumi.get(self, "distributed_ddl_task_timeout")
  
      @distributed_ddl_task_timeout.setter
      def distributed_ddl_task_timeout(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "distributed_ddl_task_timeout", value)
  
      @property
      @pulumi.getter(name="distributedProductMode")
      def distributed_product_mode(self) -> Optional[pulumi.Input[str]]:
          """
          Changes the behaviour of distributed subqueries.
          """
          return pulumi.get(self, "distributed_product_mode")
  
      @distributed_product_mode.setter
      def distributed_product_mode(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "distributed_product_mode", value)
  
      @property
      @pulumi.getter(name="emptyResultForAggregationByEmptySet")
      def empty_result_for_aggregation_by_empty_set(self) -> Optional[pulumi.Input[bool]]:
          """
          Allows to retunr empty result.
          """
          return pulumi.get(self, "empty_result_for_aggregation_by_empty_set")
  
      @empty_result_for_aggregation_by_empty_set.setter
      def empty_result_for_aggregation_by_empty_set(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "empty_result_for_aggregation_by_empty_set", value)
  
      @property
      @pulumi.getter(name="enableHttpCompression")
      def enable_http_compression(self) -> Optional[pulumi.Input[bool]]:
          """
          Enables or disables data compression in the response to an HTTP request.
          """
          return pulumi.get(self, "enable_http_compression")
  
      @enable_http_compression.setter
      def enable_http_compression(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enable_http_compression", value)
  
      @property
      @pulumi.getter(name="fallbackToStaleReplicasForDistributedQueries")
      def fallback_to_stale_replicas_for_distributed_queries(self) -> Optional[pulumi.Input[bool]]:
          """
          Forces a query to an out-of-date replica if updated data is not available.
          """
          return pulumi.get(self, "fallback_to_stale_replicas_for_distributed_queries")
  
      @fallback_to_stale_replicas_for_distributed_queries.setter
      def fallback_to_stale_replicas_for_distributed_queries(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "fallback_to_stale_replicas_for_distributed_queries", value)
  
      @property
      @pulumi.getter(name="forceIndexByDate")
      def force_index_by_date(self) -> Optional[pulumi.Input[bool]]:
          """
          Disables query execution if the index can’t be used by date.
          """
          return pulumi.get(self, "force_index_by_date")
  
      @force_index_by_date.setter
      def force_index_by_date(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "force_index_by_date", value)
  
      @property
      @pulumi.getter(name="forcePrimaryKey")
      def force_primary_key(self) -> Optional[pulumi.Input[bool]]:
          """
          Disables query execution if indexing by the primary key is not possible.
          """
          return pulumi.get(self, "force_primary_key")
  
      @force_primary_key.setter
      def force_primary_key(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "force_primary_key", value)
  
      @property
      @pulumi.getter(name="groupByOverflowMode")
      def group_by_overflow_mode(self) -> Optional[pulumi.Input[str]]:
          """
          Sets behaviour on overflow while GROUP BY operation. Possible values:
          """
          return pulumi.get(self, "group_by_overflow_mode")
  
      @group_by_overflow_mode.setter
      def group_by_overflow_mode(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "group_by_overflow_mode", value)
  
      @property
      @pulumi.getter(name="groupByTwoLevelThreshold")
      def group_by_two_level_threshold(self) -> Optional[pulumi.Input[int]]:
          """
          Sets the threshold of the number of keys, after that the two-level aggregation should be used.
          """
          return pulumi.get(self, "group_by_two_level_threshold")
  
      @group_by_two_level_threshold.setter
      def group_by_two_level_threshold(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "group_by_two_level_threshold", value)
  
      @property
      @pulumi.getter(name="groupByTwoLevelThresholdBytes")
      def group_by_two_level_threshold_bytes(self) -> Optional[pulumi.Input[int]]:
          """
          Sets the threshold of the number of bytes, after that the two-level aggregation should be used.
          """
          return pulumi.get(self, "group_by_two_level_threshold_bytes")
  
      @group_by_two_level_threshold_bytes.setter
      def group_by_two_level_threshold_bytes(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "group_by_two_level_threshold_bytes", value)
  
      @property
      @pulumi.getter(name="httpConnectionTimeout")
      def http_connection_timeout(self) -> Optional[pulumi.Input[int]]:
          """
          Timeout for HTTP connection in milliseconds.
          """
          return pulumi.get(self, "http_connection_timeout")
  
      @http_connection_timeout.setter
      def http_connection_timeout(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "http_connection_timeout", value)
  
      @property
      @pulumi.getter(name="httpHeadersProgressInterval")
      def http_headers_progress_interval(self) -> Optional[pulumi.Input[int]]:
          """
          Sets minimal interval between notifications about request process in HTTP header X-ClickHouse-Progress.
          """
          return pulumi.get(self, "http_headers_progress_interval")
  
      @http_headers_progress_interval.setter
      def http_headers_progress_interval(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "http_headers_progress_interval", value)
  
      @property
      @pulumi.getter(name="httpReceiveTimeout")
      def http_receive_timeout(self) -> Optional[pulumi.Input[int]]:
          """
          Timeout for HTTP connection in milliseconds.
          """
          return pulumi.get(self, "http_receive_timeout")
  
      @http_receive_timeout.setter
      def http_receive_timeout(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "http_receive_timeout", value)
  
      @property
      @pulumi.getter(name="httpSendTimeout")
      def http_send_timeout(self) -> Optional[pulumi.Input[int]]:
          """
          Timeout for HTTP connection in milliseconds.
          """
          return pulumi.get(self, "http_send_timeout")
  
      @http_send_timeout.setter
      def http_send_timeout(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "http_send_timeout", value)
  
      @property
      @pulumi.getter(name="inputFormatDefaultsForOmittedFields")
      def input_format_defaults_for_omitted_fields(self) -> Optional[pulumi.Input[bool]]:
          """
          When performing INSERT queries, replace omitted input column values with default values of the respective columns.
          """
          return pulumi.get(self, "input_format_defaults_for_omitted_fields")
  
      @input_format_defaults_for_omitted_fields.setter
      def input_format_defaults_for_omitted_fields(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "input_format_defaults_for_omitted_fields", value)
  
      @property
      @pulumi.getter(name="inputFormatValuesInterpretExpressions")
      def input_format_values_interpret_expressions(self) -> Optional[pulumi.Input[bool]]:
          """
          Enables or disables the full SQL parser if the fast stream parser can’t parse the data.
          """
          return pulumi.get(self, "input_format_values_interpret_expressions")
  
      @input_format_values_interpret_expressions.setter
      def input_format_values_interpret_expressions(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "input_format_values_interpret_expressions", value)
  
      @property
      @pulumi.getter(name="insertQuorum")
      def insert_quorum(self) -> Optional[pulumi.Input[int]]:
          """
          Enables the quorum writes.
          """
          return pulumi.get(self, "insert_quorum")
  
      @insert_quorum.setter
      def insert_quorum(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "insert_quorum", value)
  
      @property
      @pulumi.getter(name="insertQuorumTimeout")
      def insert_quorum_timeout(self) -> Optional[pulumi.Input[int]]:
          """
          Write to a quorum timeout in milliseconds.
          """
          return pulumi.get(self, "insert_quorum_timeout")
  
      @insert_quorum_timeout.setter
      def insert_quorum_timeout(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "insert_quorum_timeout", value)
  
      @property
      @pulumi.getter(name="joinOverflowMode")
      def join_overflow_mode(self) -> Optional[pulumi.Input[str]]:
          """
          Sets behaviour on overflow in JOIN. Possible values:
          """
          return pulumi.get(self, "join_overflow_mode")
  
      @join_overflow_mode.setter
      def join_overflow_mode(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "join_overflow_mode", value)
  
      @property
      @pulumi.getter(name="joinUseNulls")
      def join_use_nulls(self) -> Optional[pulumi.Input[bool]]:
          """
          Sets the type of JOIN behaviour. When merging tables, empty cells may appear. ClickHouse fills them differently based on this setting.
          """
          return pulumi.get(self, "join_use_nulls")
  
      @join_use_nulls.setter
      def join_use_nulls(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "join_use_nulls", value)
  
      @property
      @pulumi.getter(name="joinedSubqueryRequiresAlias")
      def joined_subquery_requires_alias(self) -> Optional[pulumi.Input[bool]]:
          """
          Require aliases for subselects and table functions in FROM that more than one table is present.
          """
          return pulumi.get(self, "joined_subquery_requires_alias")
  
      @joined_subquery_requires_alias.setter
      def joined_subquery_requires_alias(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "joined_subquery_requires_alias", value)
  
      @property
      @pulumi.getter(name="lowCardinalityAllowInNativeFormat")
      def low_cardinality_allow_in_native_format(self) -> Optional[pulumi.Input[bool]]:
          """
          Allows or restricts using the LowCardinality data type with the Native format.
          """
          return pulumi.get(self, "low_cardinality_allow_in_native_format")
  
      @low_cardinality_allow_in_native_format.setter
      def low_cardinality_allow_in_native_format(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "low_cardinality_allow_in_native_format", value)
  
      @property
      @pulumi.getter(name="maxAstDepth")
      def max_ast_depth(self) -> Optional[pulumi.Input[int]]:
          """
          Maximum abstract syntax tree depth.
          """
          return pulumi.get(self, "max_ast_depth")
  
      @max_ast_depth.setter
      def max_ast_depth(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_ast_depth", value)
  
      @property
      @pulumi.getter(name="maxAstElements")
      def max_ast_elements(self) -> Optional[pulumi.Input[int]]:
          """
          Maximum abstract syntax tree elements.
          """
          return pulumi.get(self, "max_ast_elements")
  
      @max_ast_elements.setter
      def max_ast_elements(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_ast_elements", value)
  
      @property
      @pulumi.getter(name="maxBlockSize")
      def max_block_size(self) -> Optional[pulumi.Input[int]]:
          """
          A recommendation for what size of the block (in a count of rows) to load from tables.
          """
          return pulumi.get(self, "max_block_size")
  
      @max_block_size.setter
      def max_block_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_block_size", value)
  
      @property
      @pulumi.getter(name="maxBytesBeforeExternalGroupBy")
      def max_bytes_before_external_group_by(self) -> Optional[pulumi.Input[int]]:
          """
          Limit in bytes for using memoru for GROUP BY before using swap on disk.
          """
          return pulumi.get(self, "max_bytes_before_external_group_by")
  
      @max_bytes_before_external_group_by.setter
      def max_bytes_before_external_group_by(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_bytes_before_external_group_by", value)
  
      @property
      @pulumi.getter(name="maxBytesBeforeExternalSort")
      def max_bytes_before_external_sort(self) -> Optional[pulumi.Input[int]]:
          """
          This setting is equivalent of the max_bytes_before_external_group_by setting, except for it is for sort operation (ORDER BY), not aggregation.
          """
          return pulumi.get(self, "max_bytes_before_external_sort")
  
      @max_bytes_before_external_sort.setter
      def max_bytes_before_external_sort(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_bytes_before_external_sort", value)
  
      @property
      @pulumi.getter(name="maxBytesInDistinct")
      def max_bytes_in_distinct(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the maximum size of a hash table in bytes (uncompressed data) when using DISTINCT.
          """
          return pulumi.get(self, "max_bytes_in_distinct")
  
      @max_bytes_in_distinct.setter
      def max_bytes_in_distinct(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_bytes_in_distinct", value)
  
      @property
      @pulumi.getter(name="maxBytesInJoin")
      def max_bytes_in_join(self) -> Optional[pulumi.Input[int]]:
          """
          Limit on maximum size of the hash table for JOIN, in bytes.
          """
          return pulumi.get(self, "max_bytes_in_join")
  
      @max_bytes_in_join.setter
      def max_bytes_in_join(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_bytes_in_join", value)
  
      @property
      @pulumi.getter(name="maxBytesInSet")
      def max_bytes_in_set(self) -> Optional[pulumi.Input[int]]:
          """
          Limit on the number of bytes in the set resulting from the execution of the IN section.
          """
          return pulumi.get(self, "max_bytes_in_set")
  
      @max_bytes_in_set.setter
      def max_bytes_in_set(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_bytes_in_set", value)
  
      @property
      @pulumi.getter(name="maxBytesToRead")
      def max_bytes_to_read(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the maximum number of bytes (uncompressed data) that can be read from a table when running a query.
          """
          return pulumi.get(self, "max_bytes_to_read")
  
      @max_bytes_to_read.setter
      def max_bytes_to_read(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_bytes_to_read", value)
  
      @property
      @pulumi.getter(name="maxBytesToSort")
      def max_bytes_to_sort(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the maximum number of bytes (uncompressed data) that can be read from a table for sorting.
          """
          return pulumi.get(self, "max_bytes_to_sort")
  
      @max_bytes_to_sort.setter
      def max_bytes_to_sort(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_bytes_to_sort", value)
  
      @property
      @pulumi.getter(name="maxBytesToTransfer")
      def max_bytes_to_transfer(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the maximum number of bytes (uncompressed data) that can be passed to a remote server or saved in a temporary table when using GLOBAL IN.
          """
          return pulumi.get(self, "max_bytes_to_transfer")
  
      @max_bytes_to_transfer.setter
      def max_bytes_to_transfer(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_bytes_to_transfer", value)
  
      @property
      @pulumi.getter(name="maxColumnsToRead")
      def max_columns_to_read(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the maximum number of columns that can be read from a table in a single query.
          """
          return pulumi.get(self, "max_columns_to_read")
  
      @max_columns_to_read.setter
      def max_columns_to_read(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_columns_to_read", value)
  
      @property
      @pulumi.getter(name="maxExecutionTime")
      def max_execution_time(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the maximum query execution time in milliseconds.
          """
          return pulumi.get(self, "max_execution_time")
  
      @max_execution_time.setter
      def max_execution_time(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_execution_time", value)
  
      @property
      @pulumi.getter(name="maxExpandedAstElements")
      def max_expanded_ast_elements(self) -> Optional[pulumi.Input[int]]:
          """
          Maximum abstract syntax tree depth after after expansion of aliases.
          """
          return pulumi.get(self, "max_expanded_ast_elements")
  
      @max_expanded_ast_elements.setter
      def max_expanded_ast_elements(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_expanded_ast_elements", value)
  
      @property
      @pulumi.getter(name="maxInsertBlockSize")
      def max_insert_block_size(self) -> Optional[pulumi.Input[int]]:
          """
          The size of blocks (in a count of rows) to form for insertion into a table.
          """
          return pulumi.get(self, "max_insert_block_size")
  
      @max_insert_block_size.setter
      def max_insert_block_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_insert_block_size", value)
  
      @property
      @pulumi.getter(name="maxMemoryUsage")
      def max_memory_usage(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the maximum memory usage (in bytes) for processing queries on a single server.
          """
          return pulumi.get(self, "max_memory_usage")
  
      @max_memory_usage.setter
      def max_memory_usage(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_memory_usage", value)
  
      @property
      @pulumi.getter(name="maxMemoryUsageForUser")
      def max_memory_usage_for_user(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the maximum memory usage (in bytes) for processing of user's queries on a single server.
          """
          return pulumi.get(self, "max_memory_usage_for_user")
  
      @max_memory_usage_for_user.setter
      def max_memory_usage_for_user(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_memory_usage_for_user", value)
  
      @property
      @pulumi.getter(name="maxNetworkBandwidth")
      def max_network_bandwidth(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the speed of the data exchange over the network in bytes per second.
          """
          return pulumi.get(self, "max_network_bandwidth")
  
      @max_network_bandwidth.setter
      def max_network_bandwidth(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_network_bandwidth", value)
  
      @property
      @pulumi.getter(name="maxNetworkBandwidthForUser")
      def max_network_bandwidth_for_user(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the speed of the data exchange over the network in bytes per second.
          """
          return pulumi.get(self, "max_network_bandwidth_for_user")
  
      @max_network_bandwidth_for_user.setter
      def max_network_bandwidth_for_user(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_network_bandwidth_for_user", value)
  
      @property
      @pulumi.getter(name="maxQuerySize")
      def max_query_size(self) -> Optional[pulumi.Input[int]]:
          """
          The maximum part of a query that can be taken to RAM for parsing with the SQL parser.
          """
          return pulumi.get(self, "max_query_size")
  
      @max_query_size.setter
      def max_query_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_query_size", value)
  
      @property
      @pulumi.getter(name="maxReplicaDelayForDistributedQueries")
      def max_replica_delay_for_distributed_queries(self) -> Optional[pulumi.Input[int]]:
          """
          Disables lagging replicas for distributed queries.
          """
          return pulumi.get(self, "max_replica_delay_for_distributed_queries")
  
      @max_replica_delay_for_distributed_queries.setter
      def max_replica_delay_for_distributed_queries(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_replica_delay_for_distributed_queries", value)
  
      @property
      @pulumi.getter(name="maxResultBytes")
      def max_result_bytes(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the number of bytes in the result.
          """
          return pulumi.get(self, "max_result_bytes")
  
      @max_result_bytes.setter
      def max_result_bytes(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_result_bytes", value)
  
      @property
      @pulumi.getter(name="maxResultRows")
      def max_result_rows(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the number of rows in the result.
          """
          return pulumi.get(self, "max_result_rows")
  
      @max_result_rows.setter
      def max_result_rows(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_result_rows", value)
  
      @property
      @pulumi.getter(name="maxRowsInDistinct")
      def max_rows_in_distinct(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the maximum number of different rows when using DISTINCT.
          """
          return pulumi.get(self, "max_rows_in_distinct")
  
      @max_rows_in_distinct.setter
      def max_rows_in_distinct(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_rows_in_distinct", value)
  
      @property
      @pulumi.getter(name="maxRowsInJoin")
      def max_rows_in_join(self) -> Optional[pulumi.Input[int]]:
          """
          Limit on maximum size of the hash table for JOIN, in rows.
          """
          return pulumi.get(self, "max_rows_in_join")
  
      @max_rows_in_join.setter
      def max_rows_in_join(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_rows_in_join", value)
  
      @property
      @pulumi.getter(name="maxRowsInSet")
      def max_rows_in_set(self) -> Optional[pulumi.Input[int]]:
          """
          Limit on the number of rows in the set resulting from the execution of the IN section.
          """
          return pulumi.get(self, "max_rows_in_set")
  
      @max_rows_in_set.setter
      def max_rows_in_set(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_rows_in_set", value)
  
      @property
      @pulumi.getter(name="maxRowsToGroupBy")
      def max_rows_to_group_by(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the maximum number of unique keys received from aggregation function.
          """
          return pulumi.get(self, "max_rows_to_group_by")
  
      @max_rows_to_group_by.setter
      def max_rows_to_group_by(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_rows_to_group_by", value)
  
      @property
      @pulumi.getter(name="maxRowsToRead")
      def max_rows_to_read(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the maximum number of rows that can be read from a table when running a query.
          """
          return pulumi.get(self, "max_rows_to_read")
  
      @max_rows_to_read.setter
      def max_rows_to_read(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_rows_to_read", value)
  
      @property
      @pulumi.getter(name="maxRowsToSort")
      def max_rows_to_sort(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the maximum number of rows that can be read from a table for sorting.
          """
          return pulumi.get(self, "max_rows_to_sort")
  
      @max_rows_to_sort.setter
      def max_rows_to_sort(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_rows_to_sort", value)
  
      @property
      @pulumi.getter(name="maxRowsToTransfer")
      def max_rows_to_transfer(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the maximum number of rows that can be passed to a remote server or saved in a temporary table when using GLOBAL IN.
          """
          return pulumi.get(self, "max_rows_to_transfer")
  
      @max_rows_to_transfer.setter
      def max_rows_to_transfer(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_rows_to_transfer", value)
  
      @property
      @pulumi.getter(name="maxTemporaryColumns")
      def max_temporary_columns(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the maximum number of temporary columns that must be kept in RAM at the same time when running a query, including constant columns.
          """
          return pulumi.get(self, "max_temporary_columns")
  
      @max_temporary_columns.setter
      def max_temporary_columns(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_temporary_columns", value)
  
      @property
      @pulumi.getter(name="maxTemporaryNonConstColumns")
      def max_temporary_non_const_columns(self) -> Optional[pulumi.Input[int]]:
          """
          Limits the maximum number of temporary columns that must be kept in RAM at the same time when running a query, excluding constant columns.
          """
          return pulumi.get(self, "max_temporary_non_const_columns")
  
      @max_temporary_non_const_columns.setter
      def max_temporary_non_const_columns(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_temporary_non_const_columns", value)
  
      @property
      @pulumi.getter(name="maxThreads")
      def max_threads(self) -> Optional[pulumi.Input[int]]:
          """
          The maximum number of query processing threads, excluding threads for retrieving data from remote servers.
          """
          return pulumi.get(self, "max_threads")
  
      @max_threads.setter
      def max_threads(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_threads", value)
  
      @property
      @pulumi.getter(name="mergeTreeMaxBytesToUseCache")
      def merge_tree_max_bytes_to_use_cache(self) -> Optional[pulumi.Input[int]]:
          """
          If ClickHouse should read more than merge_tree_max_bytes_to_use_cache bytes in one query, it doesn’t use the cache of uncompressed blocks.
          """
          return pulumi.get(self, "merge_tree_max_bytes_to_use_cache")
  
      @merge_tree_max_bytes_to_use_cache.setter
      def merge_tree_max_bytes_to_use_cache(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "merge_tree_max_bytes_to_use_cache", value)
  
      @property
      @pulumi.getter(name="mergeTreeMaxRowsToUseCache")
      def merge_tree_max_rows_to_use_cache(self) -> Optional[pulumi.Input[int]]:
          """
          If ClickHouse should read more than merge_tree_max_rows_to_use_cache rows in one query, it doesn’t use the cache of uncompressed blocks.
          """
          return pulumi.get(self, "merge_tree_max_rows_to_use_cache")
  
      @merge_tree_max_rows_to_use_cache.setter
      def merge_tree_max_rows_to_use_cache(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "merge_tree_max_rows_to_use_cache", value)
  
      @property
      @pulumi.getter(name="mergeTreeMinBytesForConcurrentRead")
      def merge_tree_min_bytes_for_concurrent_read(self) -> Optional[pulumi.Input[int]]:
          """
          If the number of bytes to read from one file of a MergeTree-engine table exceeds merge_tree_min_bytes_for_concurrent_read, then ClickHouse tries to concurrently read from this file in several threads.
          """
          return pulumi.get(self, "merge_tree_min_bytes_for_concurrent_read")
  
      @merge_tree_min_bytes_for_concurrent_read.setter
      def merge_tree_min_bytes_for_concurrent_read(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "merge_tree_min_bytes_for_concurrent_read", value)
  
      @property
      @pulumi.getter(name="mergeTreeMinRowsForConcurrentRead")
      def merge_tree_min_rows_for_concurrent_read(self) -> Optional[pulumi.Input[int]]:
          """
          If the number of rows to be read from a file of a MergeTree table exceeds merge_tree_min_rows_for_concurrent_read then ClickHouse tries to perform a concurrent reading from this file on several threads.
          """
          return pulumi.get(self, "merge_tree_min_rows_for_concurrent_read")
  
      @merge_tree_min_rows_for_concurrent_read.setter
      def merge_tree_min_rows_for_concurrent_read(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "merge_tree_min_rows_for_concurrent_read", value)
  
      @property
      @pulumi.getter(name="minBytesToUseDirectIo")
      def min_bytes_to_use_direct_io(self) -> Optional[pulumi.Input[int]]:
          """
          The minimum data volume required for using direct I/O access to the storage disk.
          """
          return pulumi.get(self, "min_bytes_to_use_direct_io")
  
      @min_bytes_to_use_direct_io.setter
      def min_bytes_to_use_direct_io(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "min_bytes_to_use_direct_io", value)
  
      @property
      @pulumi.getter(name="minCountToCompile")
      def min_count_to_compile(self) -> Optional[pulumi.Input[int]]:
          """
          How many times to potentially use a compiled chunk of code before running compilation.
          """
          return pulumi.get(self, "min_count_to_compile")
  
      @min_count_to_compile.setter
      def min_count_to_compile(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "min_count_to_compile", value)
  
      @property
      @pulumi.getter(name="minCountToCompileExpression")
      def min_count_to_compile_expression(self) -> Optional[pulumi.Input[int]]:
          """
          A query waits for expression compilation process to complete prior to continuing execution.
          """
          return pulumi.get(self, "min_count_to_compile_expression")
  
      @min_count_to_compile_expression.setter
      def min_count_to_compile_expression(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "min_count_to_compile_expression", value)
  
      @property
      @pulumi.getter(name="minExecutionSpeed")
      def min_execution_speed(self) -> Optional[pulumi.Input[int]]:
          """
          Minimal execution speed in rows per second.
          """
          return pulumi.get(self, "min_execution_speed")
  
      @min_execution_speed.setter
      def min_execution_speed(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "min_execution_speed", value)
  
      @property
      @pulumi.getter(name="minExecutionSpeedBytes")
      def min_execution_speed_bytes(self) -> Optional[pulumi.Input[int]]:
          """
          Minimal execution speed in bytes per second.
          """
          return pulumi.get(self, "min_execution_speed_bytes")
  
      @min_execution_speed_bytes.setter
      def min_execution_speed_bytes(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "min_execution_speed_bytes", value)
  
      @property
      @pulumi.getter(name="minInsertBlockSizeBytes")
      def min_insert_block_size_bytes(self) -> Optional[pulumi.Input[int]]:
          """
          Sets the minimum number of bytes in the block which can be inserted into a table by an INSERT query.
          """
          return pulumi.get(self, "min_insert_block_size_bytes")
  
      @min_insert_block_size_bytes.setter
      def min_insert_block_size_bytes(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "min_insert_block_size_bytes", value)
  
      @property
      @pulumi.getter(name="minInsertBlockSizeRows")
      def min_insert_block_size_rows(self) -> Optional[pulumi.Input[int]]:
          """
          Sets the minimum number of rows in the block which can be inserted into a table by an INSERT query.
          """
          return pulumi.get(self, "min_insert_block_size_rows")
  
      @min_insert_block_size_rows.setter
      def min_insert_block_size_rows(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "min_insert_block_size_rows", value)
  
      @property
      @pulumi.getter(name="outputFormatJsonQuote64bitIntegers")
      def output_format_json_quote64bit_integers(self) -> Optional[pulumi.Input[bool]]:
          """
          If the value is true, integers appear in quotes when using JSON* Int64 and UInt64 formats (for compatibility with most JavaScript implementations); otherwise, integers are output without the quotes.
          """
          return pulumi.get(self, "output_format_json_quote64bit_integers")
  
      @output_format_json_quote64bit_integers.setter
      def output_format_json_quote64bit_integers(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "output_format_json_quote64bit_integers", value)
  
      @property
      @pulumi.getter(name="outputFormatJsonQuoteDenormals")
      def output_format_json_quote_denormals(self) -> Optional[pulumi.Input[bool]]:
          """
          Enables +nan, -nan, +inf, -inf outputs in JSON output format.
          """
          return pulumi.get(self, "output_format_json_quote_denormals")
  
      @output_format_json_quote_denormals.setter
      def output_format_json_quote_denormals(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "output_format_json_quote_denormals", value)
  
      @property
      @pulumi.getter
      def priority(self) -> Optional[pulumi.Input[int]]:
          """
          Query priority.
          """
          return pulumi.get(self, "priority")
  
      @priority.setter
      def priority(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "priority", value)
  
      @property
      @pulumi.getter(name="quotaMode")
      def quota_mode(self) -> Optional[pulumi.Input[str]]:
          """
          Quota accounting mode.
          """
          return pulumi.get(self, "quota_mode")
  
      @quota_mode.setter
      def quota_mode(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "quota_mode", value)
  
      @property
      @pulumi.getter(name="readOverflowMode")
      def read_overflow_mode(self) -> Optional[pulumi.Input[str]]:
          """
          Sets behaviour on overflow while read. Possible values:
          """
          return pulumi.get(self, "read_overflow_mode")
  
      @read_overflow_mode.setter
      def read_overflow_mode(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "read_overflow_mode", value)
  
      @property
      @pulumi.getter
      def readonly(self) -> Optional[pulumi.Input[int]]:
          """
          Restricts permissions for reading data, write data and change settings queries.
          """
          return pulumi.get(self, "readonly")
  
      @readonly.setter
      def readonly(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "readonly", value)
  
      @property
      @pulumi.getter(name="receiveTimeout")
      def receive_timeout(self) -> Optional[pulumi.Input[int]]:
          """
          Receive timeout in milliseconds on the socket used for communicating with the client.
          """
          return pulumi.get(self, "receive_timeout")
  
      @receive_timeout.setter
      def receive_timeout(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "receive_timeout", value)
  
      @property
      @pulumi.getter(name="replicationAlterPartitionsSync")
      def replication_alter_partitions_sync(self) -> Optional[pulumi.Input[int]]:
          """
          For ALTER ... ATTACH|DETACH|DROP queries, you can use the replication_alter_partitions_sync setting to set up waiting.
          """
          return pulumi.get(self, "replication_alter_partitions_sync")
  
      @replication_alter_partitions_sync.setter
      def replication_alter_partitions_sync(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "replication_alter_partitions_sync", value)
  
      @property
      @pulumi.getter(name="resultOverflowMode")
      def result_overflow_mode(self) -> Optional[pulumi.Input[str]]:
          """
          Sets behaviour on overflow in result. Possible values:
          """
          return pulumi.get(self, "result_overflow_mode")
  
      @result_overflow_mode.setter
      def result_overflow_mode(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "result_overflow_mode", value)
  
      @property
      @pulumi.getter(name="selectSequentialConsistency")
      def select_sequential_consistency(self) -> Optional[pulumi.Input[bool]]:
          """
          Enables or disables sequential consistency for SELECT queries.
          """
          return pulumi.get(self, "select_sequential_consistency")
  
      @select_sequential_consistency.setter
      def select_sequential_consistency(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "select_sequential_consistency", value)
  
      @property
      @pulumi.getter(name="sendProgressInHttpHeaders")
      def send_progress_in_http_headers(self) -> Optional[pulumi.Input[bool]]:
          """
          Enables or disables X-ClickHouse-Progress HTTP response headers in clickhouse-server responses.
          """
          return pulumi.get(self, "send_progress_in_http_headers")
  
      @send_progress_in_http_headers.setter
      def send_progress_in_http_headers(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "send_progress_in_http_headers", value)
  
      @property
      @pulumi.getter(name="sendTimeout")
      def send_timeout(self) -> Optional[pulumi.Input[int]]:
          """
          Send timeout in milliseconds on the socket used for communicating with the client.
          """
          return pulumi.get(self, "send_timeout")
  
      @send_timeout.setter
      def send_timeout(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "send_timeout", value)
  
      @property
      @pulumi.getter(name="setOverflowMode")
      def set_overflow_mode(self) -> Optional[pulumi.Input[str]]:
          """
          Sets behaviour on overflow in the set resulting. Possible values:
          """
          return pulumi.get(self, "set_overflow_mode")
  
      @set_overflow_mode.setter
      def set_overflow_mode(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "set_overflow_mode", value)
  
      @property
      @pulumi.getter(name="skipUnavailableShards")
      def skip_unavailable_shards(self) -> Optional[pulumi.Input[bool]]:
          """
          Enables or disables silently skipping of unavailable shards.
          """
          return pulumi.get(self, "skip_unavailable_shards")
  
      @skip_unavailable_shards.setter
      def skip_unavailable_shards(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "skip_unavailable_shards", value)
  
      @property
      @pulumi.getter(name="sortOverflowMode")
      def sort_overflow_mode(self) -> Optional[pulumi.Input[str]]:
          """
          Sets behaviour on overflow while sort. Possible values:
          """
          return pulumi.get(self, "sort_overflow_mode")
  
      @sort_overflow_mode.setter
      def sort_overflow_mode(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "sort_overflow_mode", value)
  
      @property
      @pulumi.getter(name="timeoutOverflowMode")
      def timeout_overflow_mode(self) -> Optional[pulumi.Input[str]]:
          """
          Sets behaviour on overflow. Possible values:
          """
          return pulumi.get(self, "timeout_overflow_mode")
  
      @timeout_overflow_mode.setter
      def timeout_overflow_mode(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "timeout_overflow_mode", value)
  
      @property
      @pulumi.getter(name="transferOverflowMode")
      def transfer_overflow_mode(self) -> Optional[pulumi.Input[str]]:
          """
          Sets behaviour on overflow. Possible values:
          """
          return pulumi.get(self, "transfer_overflow_mode")
  
      @transfer_overflow_mode.setter
      def transfer_overflow_mode(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "transfer_overflow_mode", value)
  
      @property
      @pulumi.getter(name="transformNullIn")
      def transform_null_in(self) -> Optional[pulumi.Input[bool]]:
          """
          Enables equality of NULL values for IN operator.
          """
          return pulumi.get(self, "transform_null_in")
  
      @transform_null_in.setter
      def transform_null_in(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "transform_null_in", value)
  
      @property
      @pulumi.getter(name="useUncompressedCache")
      def use_uncompressed_cache(self) -> Optional[pulumi.Input[bool]]:
          """
          Whether to use a cache of uncompressed blocks.
          """
          return pulumi.get(self, "use_uncompressed_cache")
  
      @use_uncompressed_cache.setter
      def use_uncompressed_cache(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "use_uncompressed_cache", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterZookeeperArgs:
      def __init__(__self__, *,
                   resources: Optional[pulumi.Input['MdbClickhouseClusterZookeeperResourcesArgs']] = None):
          """
          :param pulumi.Input['MdbClickhouseClusterZookeeperResourcesArgs'] resources: Resources allocated to hosts of the ZooKeeper subcluster. The structure is documented below.
          """
          if resources is not None:
              pulumi.set(__self__, "resources", resources)
  
      @property
      @pulumi.getter
      def resources(self) -> Optional[pulumi.Input['MdbClickhouseClusterZookeeperResourcesArgs']]:
          """
          Resources allocated to hosts of the ZooKeeper subcluster. The structure is documented below.
          """
          return pulumi.get(self, "resources")
  
      @resources.setter
      def resources(self, value: Optional[pulumi.Input['MdbClickhouseClusterZookeeperResourcesArgs']]):
          pulumi.set(self, "resources", value)
  
  
  @pulumi.input_type
  class MdbClickhouseClusterZookeeperResourcesArgs:
      def __init__(__self__, *,
                   disk_size: Optional[pulumi.Input[int]] = None,
                   disk_type_id: Optional[pulumi.Input[str]] = None,
                   resource_preset_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[int] disk_size: Volume of the storage available to a ZooKeeper host, in gigabytes.
          :param pulumi.Input[str] disk_type_id: Type of the storage of ZooKeeper hosts.
                 For more information see [the official documentation](https://cloud.yandex.com/docs/managed-clickhouse/concepts/storage).
          """
          if disk_size is not None:
              pulumi.set(__self__, "disk_size", disk_size)
          if disk_type_id is not None:
              pulumi.set(__self__, "disk_type_id", disk_type_id)
          if resource_preset_id is not None:
              pulumi.set(__self__, "resource_preset_id", resource_preset_id)
  
      @property
      @pulumi.getter(name="diskSize")
      def disk_size(self) -> Optional[pulumi.Input[int]]:
          """
          Volume of the storage available to a ZooKeeper host, in gigabytes.
          """
          return pulumi.get(self, "disk_size")
  
      @disk_size.setter
      def disk_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "disk_size", value)
  
      @property
      @pulumi.getter(name="diskTypeId")
      def disk_type_id(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the storage of ZooKeeper hosts.
          For more information see [the official documentation](https://cloud.yandex.com/docs/managed-clickhouse/concepts/storage).
          """
          return pulumi.get(self, "disk_type_id")
  
      @disk_type_id.setter
      def disk_type_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "disk_type_id", value)
  
      @property
      @pulumi.getter(name="resourcePresetId")
      def resource_preset_id(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "resource_preset_id")
  
      @resource_preset_id.setter
      def resource_preset_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "resource_preset_id", value)
  
  
  @pulumi.input_type
  class MdbElasticSearchClusterConfigArgs:
      def __init__(__self__, *,
                   admin_password: pulumi.Input[str],
                   data_node: pulumi.Input['MdbElasticSearchClusterConfigDataNodeArgs'],
                   edition: Optional[pulumi.Input[str]] = None,
                   master_node: Optional[pulumi.Input['MdbElasticSearchClusterConfigMasterNodeArgs']] = None,
                   plugins: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   version: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] admin_password: Password for admin user of Elasticsearch.
          :param pulumi.Input['MdbElasticSearchClusterConfigDataNodeArgs'] data_node: Configuration for Elasticsearch data nodes subcluster. The structure is documented below.
          :param pulumi.Input[str] edition: Edition of Elasticsearch. For more information, see [the official documentation](https://cloud.yandex.com/en-ru/docs/managed-elasticsearch/concepts/es-editions).
          :param pulumi.Input['MdbElasticSearchClusterConfigMasterNodeArgs'] master_node: Configuration for Elasticsearch master nodes subcluster. The structure is documented below.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] plugins: A set of Elasticsearch plugins to install.
          :param pulumi.Input[str] version: Version of Elasticsearch.
          """
          pulumi.set(__self__, "admin_password", admin_password)
          pulumi.set(__self__, "data_node", data_node)
          if edition is not None:
              pulumi.set(__self__, "edition", edition)
          if master_node is not None:
              pulumi.set(__self__, "master_node", master_node)
          if plugins is not None:
              pulumi.set(__self__, "plugins", plugins)
          if version is not None:
              pulumi.set(__self__, "version", version)
  
      @property
      @pulumi.getter(name="adminPassword")
      def admin_password(self) -> pulumi.Input[str]:
          """
          Password for admin user of Elasticsearch.
          """
          return pulumi.get(self, "admin_password")
  
      @admin_password.setter
      def admin_password(self, value: pulumi.Input[str]):
          pulumi.set(self, "admin_password", value)
  
      @property
      @pulumi.getter(name="dataNode")
      def data_node(self) -> pulumi.Input['MdbElasticSearchClusterConfigDataNodeArgs']:
          """
          Configuration for Elasticsearch data nodes subcluster. The structure is documented below.
          """
          return pulumi.get(self, "data_node")
  
      @data_node.setter
      def data_node(self, value: pulumi.Input['MdbElasticSearchClusterConfigDataNodeArgs']):
          pulumi.set(self, "data_node", value)
  
      @property
      @pulumi.getter
      def edition(self) -> Optional[pulumi.Input[str]]:
          """
          Edition of Elasticsearch. For more information, see [the official documentation](https://cloud.yandex.com/en-ru/docs/managed-elasticsearch/concepts/es-editions).
          """
          return pulumi.get(self, "edition")
  
      @edition.setter
      def edition(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "edition", value)
  
      @property
      @pulumi.getter(name="masterNode")
      def master_node(self) -> Optional[pulumi.Input['MdbElasticSearchClusterConfigMasterNodeArgs']]:
          """
          Configuration for Elasticsearch master nodes subcluster. The structure is documented below.
          """
          return pulumi.get(self, "master_node")
  
      @master_node.setter
      def master_node(self, value: Optional[pulumi.Input['MdbElasticSearchClusterConfigMasterNodeArgs']]):
          pulumi.set(self, "master_node", value)
  
      @property
      @pulumi.getter
      def plugins(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          A set of Elasticsearch plugins to install.
          """
          return pulumi.get(self, "plugins")
  
      @plugins.setter
      def plugins(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "plugins", value)
  
      @property
      @pulumi.getter
      def version(self) -> Optional[pulumi.Input[str]]:
          """
          Version of Elasticsearch.
          """
          return pulumi.get(self, "version")
  
      @version.setter
      def version(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "version", value)
  
  
  @pulumi.input_type
  class MdbElasticSearchClusterConfigDataNodeArgs:
      def __init__(__self__, *,
                   resources: pulumi.Input['MdbElasticSearchClusterConfigDataNodeResourcesArgs']):
          """
          :param pulumi.Input['MdbElasticSearchClusterConfigDataNodeResourcesArgs'] resources: Resources allocated to hosts of the Elasticsearch master nodes subcluster. The structure is documented below.
          """
          pulumi.set(__self__, "resources", resources)
  
      @property
      @pulumi.getter
      def resources(self) -> pulumi.Input['MdbElasticSearchClusterConfigDataNodeResourcesArgs']:
          """
          Resources allocated to hosts of the Elasticsearch master nodes subcluster. The structure is documented below.
          """
          return pulumi.get(self, "resources")
  
      @resources.setter
      def resources(self, value: pulumi.Input['MdbElasticSearchClusterConfigDataNodeResourcesArgs']):
          pulumi.set(self, "resources", value)
  
  
  @pulumi.input_type
  class MdbElasticSearchClusterConfigDataNodeResourcesArgs:
      def __init__(__self__, *,
                   disk_size: pulumi.Input[int],
                   disk_type_id: pulumi.Input[str],
                   resource_preset_id: pulumi.Input[str]):
          """
          :param pulumi.Input[int] disk_size: Volume of the storage available to a host, in gigabytes.
          :param pulumi.Input[str] disk_type_id: Type of the storage of Elasticsearch hosts.
          """
          pulumi.set(__self__, "disk_size", disk_size)
          pulumi.set(__self__, "disk_type_id", disk_type_id)
          pulumi.set(__self__, "resource_preset_id", resource_preset_id)
  
      @property
      @pulumi.getter(name="diskSize")
      def disk_size(self) -> pulumi.Input[int]:
          """
          Volume of the storage available to a host, in gigabytes.
          """
          return pulumi.get(self, "disk_size")
  
      @disk_size.setter
      def disk_size(self, value: pulumi.Input[int]):
          pulumi.set(self, "disk_size", value)
  
      @property
      @pulumi.getter(name="diskTypeId")
      def disk_type_id(self) -> pulumi.Input[str]:
          """
          Type of the storage of Elasticsearch hosts.
          """
          return pulumi.get(self, "disk_type_id")
  
      @disk_type_id.setter
      def disk_type_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "disk_type_id", value)
  
      @property
      @pulumi.getter(name="resourcePresetId")
      def resource_preset_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "resource_preset_id")
  
      @resource_preset_id.setter
      def resource_preset_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "resource_preset_id", value)
  
  
  @pulumi.input_type
  class MdbElasticSearchClusterConfigMasterNodeArgs:
      def __init__(__self__, *,
                   resources: pulumi.Input['MdbElasticSearchClusterConfigMasterNodeResourcesArgs']):
          """
          :param pulumi.Input['MdbElasticSearchClusterConfigMasterNodeResourcesArgs'] resources: Resources allocated to hosts of the Elasticsearch master nodes subcluster. The structure is documented below.
          """
          pulumi.set(__self__, "resources", resources)
  
      @property
      @pulumi.getter
      def resources(self) -> pulumi.Input['MdbElasticSearchClusterConfigMasterNodeResourcesArgs']:
          """
          Resources allocated to hosts of the Elasticsearch master nodes subcluster. The structure is documented below.
          """
          return pulumi.get(self, "resources")
  
      @resources.setter
      def resources(self, value: pulumi.Input['MdbElasticSearchClusterConfigMasterNodeResourcesArgs']):
          pulumi.set(self, "resources", value)
  
  
  @pulumi.input_type
  class MdbElasticSearchClusterConfigMasterNodeResourcesArgs:
      def __init__(__self__, *,
                   disk_size: pulumi.Input[int],
                   disk_type_id: pulumi.Input[str],
                   resource_preset_id: pulumi.Input[str]):
          """
          :param pulumi.Input[int] disk_size: Volume of the storage available to a host, in gigabytes.
          :param pulumi.Input[str] disk_type_id: Type of the storage of Elasticsearch hosts.
          """
          pulumi.set(__self__, "disk_size", disk_size)
          pulumi.set(__self__, "disk_type_id", disk_type_id)
          pulumi.set(__self__, "resource_preset_id", resource_preset_id)
  
      @property
      @pulumi.getter(name="diskSize")
      def disk_size(self) -> pulumi.Input[int]:
          """
          Volume of the storage available to a host, in gigabytes.
          """
          return pulumi.get(self, "disk_size")
  
      @disk_size.setter
      def disk_size(self, value: pulumi.Input[int]):
          pulumi.set(self, "disk_size", value)
  
      @property
      @pulumi.getter(name="diskTypeId")
      def disk_type_id(self) -> pulumi.Input[str]:
          """
          Type of the storage of Elasticsearch hosts.
          """
          return pulumi.get(self, "disk_type_id")
  
      @disk_type_id.setter
      def disk_type_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "disk_type_id", value)
  
      @property
      @pulumi.getter(name="resourcePresetId")
      def resource_preset_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "resource_preset_id")
  
      @resource_preset_id.setter
      def resource_preset_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "resource_preset_id", value)
  
  
  @pulumi.input_type
  class MdbElasticSearchClusterHostArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   type: pulumi.Input[str],
                   zone: pulumi.Input[str],
                   assign_public_ip: Optional[pulumi.Input[bool]] = None,
                   fqdn: Optional[pulumi.Input[str]] = None,
                   subnet_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] name: User defined host name.
          :param pulumi.Input[str] type: The type of the host to be deployed. Can be either `DATA_NODE` or `MASTER_NODE`.
          :param pulumi.Input[str] zone: The availability zone where the Elasticsearch host will be created.
                 For more information see [the official documentation](https://cloud.yandex.com/docs/overview/concepts/geo-scope).
          :param pulumi.Input[bool] assign_public_ip: Sets whether the host should get a public IP address on creation. Can be either `true` or `false`.
          :param pulumi.Input[str] fqdn: The fully qualified domain name of the host.
          :param pulumi.Input[str] subnet_id: The ID of the subnet, to which the host belongs. The subnet must
                 be a part of the network to which the cluster belongs.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "type", type)
          pulumi.set(__self__, "zone", zone)
          if assign_public_ip is not None:
              pulumi.set(__self__, "assign_public_ip", assign_public_ip)
          if fqdn is not None:
              pulumi.set(__self__, "fqdn", fqdn)
          if subnet_id is not None:
              pulumi.set(__self__, "subnet_id", subnet_id)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          User defined host name.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def type(self) -> pulumi.Input[str]:
          """
          The type of the host to be deployed. Can be either `DATA_NODE` or `MASTER_NODE`.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: pulumi.Input[str]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter
      def zone(self) -> pulumi.Input[str]:
          """
          The availability zone where the Elasticsearch host will be created.
          For more information see [the official documentation](https://cloud.yandex.com/docs/overview/concepts/geo-scope).
          """
          return pulumi.get(self, "zone")
  
      @zone.setter
      def zone(self, value: pulumi.Input[str]):
          pulumi.set(self, "zone", value)
  
      @property
      @pulumi.getter(name="assignPublicIp")
      def assign_public_ip(self) -> Optional[pulumi.Input[bool]]:
          """
          Sets whether the host should get a public IP address on creation. Can be either `true` or `false`.
          """
          return pulumi.get(self, "assign_public_ip")
  
      @assign_public_ip.setter
      def assign_public_ip(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "assign_public_ip", value)
  
      @property
      @pulumi.getter
      def fqdn(self) -> Optional[pulumi.Input[str]]:
          """
          The fully qualified domain name of the host.
          """
          return pulumi.get(self, "fqdn")
  
      @fqdn.setter
      def fqdn(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "fqdn", value)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> Optional[pulumi.Input[str]]:
          """
          The ID of the subnet, to which the host belongs. The subnet must
          be a part of the network to which the cluster belongs.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "subnet_id", value)
  
  
  @pulumi.input_type
  class MdbGreenplumClusterAccessArgs:
      def __init__(__self__, *,
                   data_lens: Optional[pulumi.Input[bool]] = None,
                   web_sql: Optional[pulumi.Input[bool]] = None):
          """
          :param pulumi.Input[bool] data_lens: Allow access for [Yandex DataLens](https://cloud.yandex.com/services/datalens).
          :param pulumi.Input[bool] web_sql: Allows access for SQL queries in the management console
          """
          if data_lens is not None:
              pulumi.set(__self__, "data_lens", data_lens)
          if web_sql is not None:
              pulumi.set(__self__, "web_sql", web_sql)
  
      @property
      @pulumi.getter(name="dataLens")
      def data_lens(self) -> Optional[pulumi.Input[bool]]:
          """
          Allow access for [Yandex DataLens](https://cloud.yandex.com/services/datalens).
          """
          return pulumi.get(self, "data_lens")
  
      @data_lens.setter
      def data_lens(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "data_lens", value)
  
      @property
      @pulumi.getter(name="webSql")
      def web_sql(self) -> Optional[pulumi.Input[bool]]:
          """
          Allows access for SQL queries in the management console
          """
          return pulumi.get(self, "web_sql")
  
      @web_sql.setter
      def web_sql(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "web_sql", value)
  
  
  @pulumi.input_type
  class MdbGreenplumClusterBackupWindowStartArgs:
      def __init__(__self__, *,
                   hours: Optional[pulumi.Input[int]] = None,
                   minutes: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] hours: The hour at which backup will be started (UTC).
          :param pulumi.Input[int] minutes: The minute at which backup will be started (UTC).
          """
          if hours is not None:
              pulumi.set(__self__, "hours", hours)
          if minutes is not None:
              pulumi.set(__self__, "minutes", minutes)
  
      @property
      @pulumi.getter
      def hours(self) -> Optional[pulumi.Input[int]]:
          """
          The hour at which backup will be started (UTC).
          """
          return pulumi.get(self, "hours")
  
      @hours.setter
      def hours(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "hours", value)
  
      @property
      @pulumi.getter
      def minutes(self) -> Optional[pulumi.Input[int]]:
          """
          The minute at which backup will be started (UTC).
          """
          return pulumi.get(self, "minutes")
  
      @minutes.setter
      def minutes(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "minutes", value)
  
  
  @pulumi.input_type
  class MdbGreenplumClusterMasterHostArgs:
      def __init__(__self__, *,
                   assign_public_ip: Optional[pulumi.Input[bool]] = None,
                   fqdn: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[bool] assign_public_ip: Sets whether the master hosts should get a public IP address on creation. Changing this parameter for an existing host is not supported at the moment.
          :param pulumi.Input[str] fqdn: (Computed) The fully qualified domain name of the host.
          """
          if assign_public_ip is not None:
              pulumi.set(__self__, "assign_public_ip", assign_public_ip)
          if fqdn is not None:
              pulumi.set(__self__, "fqdn", fqdn)
  
      @property
      @pulumi.getter(name="assignPublicIp")
      def assign_public_ip(self) -> Optional[pulumi.Input[bool]]:
          """
          Sets whether the master hosts should get a public IP address on creation. Changing this parameter for an existing host is not supported at the moment.
          """
          return pulumi.get(self, "assign_public_ip")
  
      @assign_public_ip.setter
      def assign_public_ip(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "assign_public_ip", value)
  
      @property
      @pulumi.getter
      def fqdn(self) -> Optional[pulumi.Input[str]]:
          """
          (Computed) The fully qualified domain name of the host.
          """
          return pulumi.get(self, "fqdn")
  
      @fqdn.setter
      def fqdn(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "fqdn", value)
  
  
  @pulumi.input_type
  class MdbGreenplumClusterMasterSubclusterArgs:
      def __init__(__self__, *,
                   resources: pulumi.Input['MdbGreenplumClusterMasterSubclusterResourcesArgs']):
          """
          :param pulumi.Input['MdbGreenplumClusterMasterSubclusterResourcesArgs'] resources: Resources allocated to hosts for segment subcluster of the Greenplum cluster. The structure is documented below.
          """
          pulumi.set(__self__, "resources", resources)
  
      @property
      @pulumi.getter
      def resources(self) -> pulumi.Input['MdbGreenplumClusterMasterSubclusterResourcesArgs']:
          """
          Resources allocated to hosts for segment subcluster of the Greenplum cluster. The structure is documented below.
          """
          return pulumi.get(self, "resources")
  
      @resources.setter
      def resources(self, value: pulumi.Input['MdbGreenplumClusterMasterSubclusterResourcesArgs']):
          pulumi.set(self, "resources", value)
  
  
  @pulumi.input_type
  class MdbGreenplumClusterMasterSubclusterResourcesArgs:
      def __init__(__self__, *,
                   disk_size: pulumi.Input[int],
                   disk_type_id: pulumi.Input[str],
                   resource_preset_id: pulumi.Input[str]):
          pulumi.set(__self__, "disk_size", disk_size)
          pulumi.set(__self__, "disk_type_id", disk_type_id)
          pulumi.set(__self__, "resource_preset_id", resource_preset_id)
  
      @property
      @pulumi.getter(name="diskSize")
      def disk_size(self) -> pulumi.Input[int]:
          return pulumi.get(self, "disk_size")
  
      @disk_size.setter
      def disk_size(self, value: pulumi.Input[int]):
          pulumi.set(self, "disk_size", value)
  
      @property
      @pulumi.getter(name="diskTypeId")
      def disk_type_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "disk_type_id")
  
      @disk_type_id.setter
      def disk_type_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "disk_type_id", value)
  
      @property
      @pulumi.getter(name="resourcePresetId")
      def resource_preset_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "resource_preset_id")
  
      @resource_preset_id.setter
      def resource_preset_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "resource_preset_id", value)
  
  
  @pulumi.input_type
  class MdbGreenplumClusterSegmentHostArgs:
      def __init__(__self__, *,
                   fqdn: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] fqdn: (Computed) The fully qualified domain name of the host.
          """
          if fqdn is not None:
              pulumi.set(__self__, "fqdn", fqdn)
  
      @property
      @pulumi.getter
      def fqdn(self) -> Optional[pulumi.Input[str]]:
          """
          (Computed) The fully qualified domain name of the host.
          """
          return pulumi.get(self, "fqdn")
  
      @fqdn.setter
      def fqdn(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "fqdn", value)
  
  
  @pulumi.input_type
  class MdbGreenplumClusterSegmentSubclusterArgs:
      def __init__(__self__, *,
                   resources: pulumi.Input['MdbGreenplumClusterSegmentSubclusterResourcesArgs']):
          """
          :param pulumi.Input['MdbGreenplumClusterSegmentSubclusterResourcesArgs'] resources: Resources allocated to hosts for segment subcluster of the Greenplum cluster. The structure is documented below.
          """
          pulumi.set(__self__, "resources", resources)
  
      @property
      @pulumi.getter
      def resources(self) -> pulumi.Input['MdbGreenplumClusterSegmentSubclusterResourcesArgs']:
          """
          Resources allocated to hosts for segment subcluster of the Greenplum cluster. The structure is documented below.
          """
          return pulumi.get(self, "resources")
  
      @resources.setter
      def resources(self, value: pulumi.Input['MdbGreenplumClusterSegmentSubclusterResourcesArgs']):
          pulumi.set(self, "resources", value)
  
  
  @pulumi.input_type
  class MdbGreenplumClusterSegmentSubclusterResourcesArgs:
      def __init__(__self__, *,
                   disk_size: pulumi.Input[int],
                   disk_type_id: pulumi.Input[str],
                   resource_preset_id: pulumi.Input[str]):
          pulumi.set(__self__, "disk_size", disk_size)
          pulumi.set(__self__, "disk_type_id", disk_type_id)
          pulumi.set(__self__, "resource_preset_id", resource_preset_id)
  
      @property
      @pulumi.getter(name="diskSize")
      def disk_size(self) -> pulumi.Input[int]:
          return pulumi.get(self, "disk_size")
  
      @disk_size.setter
      def disk_size(self, value: pulumi.Input[int]):
          pulumi.set(self, "disk_size", value)
  
      @property
      @pulumi.getter(name="diskTypeId")
      def disk_type_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "disk_type_id")
  
      @disk_type_id.setter
      def disk_type_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "disk_type_id", value)
  
      @property
      @pulumi.getter(name="resourcePresetId")
      def resource_preset_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "resource_preset_id")
  
      @resource_preset_id.setter
      def resource_preset_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "resource_preset_id", value)
  
  
  @pulumi.input_type
  class MdbKafkaClusterConfigArgs:
      def __init__(__self__, *,
                   kafka: pulumi.Input['MdbKafkaClusterConfigKafkaArgs'],
                   version: pulumi.Input[str],
                   zones: pulumi.Input[Sequence[pulumi.Input[str]]],
                   assign_public_ip: Optional[pulumi.Input[bool]] = None,
                   brokers_count: Optional[pulumi.Input[int]] = None,
                   schema_registry: Optional[pulumi.Input[bool]] = None,
                   unmanaged_topics: Optional[pulumi.Input[bool]] = None,
                   zookeeper: Optional[pulumi.Input['MdbKafkaClusterConfigZookeeperArgs']] = None):
          """
          :param pulumi.Input['MdbKafkaClusterConfigKafkaArgs'] kafka: Configuration of the Kafka subcluster. The structure is documented below.
          :param pulumi.Input[str] version: Version of the Kafka server software.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] zones: List of availability zones.
          :param pulumi.Input[bool] assign_public_ip: Determines whether each broker will be assigned a public IP address. The default is `false`.
          :param pulumi.Input[int] brokers_count: Count of brokers per availability zone. The default is `1`.
          :param pulumi.Input[bool] schema_registry: Enables managed schema registry on cluster. The default is `false`.
          :param pulumi.Input[bool] unmanaged_topics: Allows to use Kafka AdminAPI to manage topics. The default is `false`.
          :param pulumi.Input['MdbKafkaClusterConfigZookeeperArgs'] zookeeper: Configuration of the ZooKeeper subcluster. The structure is documented below.
          """
          pulumi.set(__self__, "kafka", kafka)
          pulumi.set(__self__, "version", version)
          pulumi.set(__self__, "zones", zones)
          if assign_public_ip is not None:
              pulumi.set(__self__, "assign_public_ip", assign_public_ip)
          if brokers_count is not None:
              pulumi.set(__self__, "brokers_count", brokers_count)
          if schema_registry is not None:
              pulumi.set(__self__, "schema_registry", schema_registry)
          if unmanaged_topics is not None:
              pulumi.set(__self__, "unmanaged_topics", unmanaged_topics)
          if zookeeper is not None:
              pulumi.set(__self__, "zookeeper", zookeeper)
  
      @property
      @pulumi.getter
      def kafka(self) -> pulumi.Input['MdbKafkaClusterConfigKafkaArgs']:
          """
          Configuration of the Kafka subcluster. The structure is documented below.
          """
          return pulumi.get(self, "kafka")
  
      @kafka.setter
      def kafka(self, value: pulumi.Input['MdbKafkaClusterConfigKafkaArgs']):
          pulumi.set(self, "kafka", value)
  
      @property
      @pulumi.getter
      def version(self) -> pulumi.Input[str]:
          """
          Version of the Kafka server software.
          """
          return pulumi.get(self, "version")
  
      @version.setter
      def version(self, value: pulumi.Input[str]):
          pulumi.set(self, "version", value)
  
      @property
      @pulumi.getter
      def zones(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          """
          List of availability zones.
          """
          return pulumi.get(self, "zones")
  
      @zones.setter
      def zones(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "zones", value)
  
      @property
      @pulumi.getter(name="assignPublicIp")
      def assign_public_ip(self) -> Optional[pulumi.Input[bool]]:
          """
          Determines whether each broker will be assigned a public IP address. The default is `false`.
          """
          return pulumi.get(self, "assign_public_ip")
  
      @assign_public_ip.setter
      def assign_public_ip(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "assign_public_ip", value)
  
      @property
      @pulumi.getter(name="brokersCount")
      def brokers_count(self) -> Optional[pulumi.Input[int]]:
          """
          Count of brokers per availability zone. The default is `1`.
          """
          return pulumi.get(self, "brokers_count")
  
      @brokers_count.setter
      def brokers_count(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "brokers_count", value)
  
      @property
      @pulumi.getter(name="schemaRegistry")
      def schema_registry(self) -> Optional[pulumi.Input[bool]]:
          """
          Enables managed schema registry on cluster. The default is `false`.
          """
          return pulumi.get(self, "schema_registry")
  
      @schema_registry.setter
      def schema_registry(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "schema_registry", value)
  
      @property
      @pulumi.getter(name="unmanagedTopics")
      def unmanaged_topics(self) -> Optional[pulumi.Input[bool]]:
          """
          Allows to use Kafka AdminAPI to manage topics. The default is `false`.
          """
          return pulumi.get(self, "unmanaged_topics")
  
      @unmanaged_topics.setter
      def unmanaged_topics(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "unmanaged_topics", value)
  
      @property
      @pulumi.getter
      def zookeeper(self) -> Optional[pulumi.Input['MdbKafkaClusterConfigZookeeperArgs']]:
          """
          Configuration of the ZooKeeper subcluster. The structure is documented below.
          """
          return pulumi.get(self, "zookeeper")
  
      @zookeeper.setter
      def zookeeper(self, value: Optional[pulumi.Input['MdbKafkaClusterConfigZookeeperArgs']]):
          pulumi.set(self, "zookeeper", value)
  
  
  @pulumi.input_type
  class MdbKafkaClusterConfigKafkaArgs:
      def __init__(__self__, *,
                   resources: pulumi.Input['MdbKafkaClusterConfigKafkaResourcesArgs'],
                   kafka_config: Optional[pulumi.Input['MdbKafkaClusterConfigKafkaKafkaConfigArgs']] = None):
          """
          :param pulumi.Input['MdbKafkaClusterConfigKafkaResourcesArgs'] resources: Resources allocated to hosts of the ZooKeeper subcluster. The structure is documented below.
          :param pulumi.Input['MdbKafkaClusterConfigKafkaKafkaConfigArgs'] kafka_config: User-defined settings for the Kafka cluster. The structure is documented below.
          """
          pulumi.set(__self__, "resources", resources)
          if kafka_config is not None:
              pulumi.set(__self__, "kafka_config", kafka_config)
  
      @property
      @pulumi.getter
      def resources(self) -> pulumi.Input['MdbKafkaClusterConfigKafkaResourcesArgs']:
          """
          Resources allocated to hosts of the ZooKeeper subcluster. The structure is documented below.
          """
          return pulumi.get(self, "resources")
  
      @resources.setter
      def resources(self, value: pulumi.Input['MdbKafkaClusterConfigKafkaResourcesArgs']):
          pulumi.set(self, "resources", value)
  
      @property
      @pulumi.getter(name="kafkaConfig")
      def kafka_config(self) -> Optional[pulumi.Input['MdbKafkaClusterConfigKafkaKafkaConfigArgs']]:
          """
          User-defined settings for the Kafka cluster. The structure is documented below.
          """
          return pulumi.get(self, "kafka_config")
  
      @kafka_config.setter
      def kafka_config(self, value: Optional[pulumi.Input['MdbKafkaClusterConfigKafkaKafkaConfigArgs']]):
          pulumi.set(self, "kafka_config", value)
  
  
  @pulumi.input_type
  class MdbKafkaClusterConfigKafkaKafkaConfigArgs:
      def __init__(__self__, *,
                   auto_create_topics_enable: Optional[pulumi.Input[bool]] = None,
                   compression_type: Optional[pulumi.Input[str]] = None,
                   default_replication_factor: Optional[pulumi.Input[str]] = None,
                   log_flush_interval_messages: Optional[pulumi.Input[str]] = None,
                   log_flush_interval_ms: Optional[pulumi.Input[str]] = None,
                   log_flush_scheduler_interval_ms: Optional[pulumi.Input[str]] = None,
                   log_preallocate: Optional[pulumi.Input[bool]] = None,
                   log_retention_bytes: Optional[pulumi.Input[str]] = None,
                   log_retention_hours: Optional[pulumi.Input[str]] = None,
                   log_retention_minutes: Optional[pulumi.Input[str]] = None,
                   log_retention_ms: Optional[pulumi.Input[str]] = None,
                   log_segment_bytes: Optional[pulumi.Input[str]] = None,
                   num_partitions: Optional[pulumi.Input[str]] = None,
                   socket_receive_buffer_bytes: Optional[pulumi.Input[str]] = None,
                   socket_send_buffer_bytes: Optional[pulumi.Input[str]] = None):
          if auto_create_topics_enable is not None:
              pulumi.set(__self__, "auto_create_topics_enable", auto_create_topics_enable)
          if compression_type is not None:
              pulumi.set(__self__, "compression_type", compression_type)
          if default_replication_factor is not None:
              pulumi.set(__self__, "default_replication_factor", default_replication_factor)
          if log_flush_interval_messages is not None:
              pulumi.set(__self__, "log_flush_interval_messages", log_flush_interval_messages)
          if log_flush_interval_ms is not None:
              pulumi.set(__self__, "log_flush_interval_ms", log_flush_interval_ms)
          if log_flush_scheduler_interval_ms is not None:
              pulumi.set(__self__, "log_flush_scheduler_interval_ms", log_flush_scheduler_interval_ms)
          if log_preallocate is not None:
              pulumi.set(__self__, "log_preallocate", log_preallocate)
          if log_retention_bytes is not None:
              pulumi.set(__self__, "log_retention_bytes", log_retention_bytes)
          if log_retention_hours is not None:
              pulumi.set(__self__, "log_retention_hours", log_retention_hours)
          if log_retention_minutes is not None:
              pulumi.set(__self__, "log_retention_minutes", log_retention_minutes)
          if log_retention_ms is not None:
              pulumi.set(__self__, "log_retention_ms", log_retention_ms)
          if log_segment_bytes is not None:
              pulumi.set(__self__, "log_segment_bytes", log_segment_bytes)
          if num_partitions is not None:
              pulumi.set(__self__, "num_partitions", num_partitions)
          if socket_receive_buffer_bytes is not None:
              pulumi.set(__self__, "socket_receive_buffer_bytes", socket_receive_buffer_bytes)
          if socket_send_buffer_bytes is not None:
              pulumi.set(__self__, "socket_send_buffer_bytes", socket_send_buffer_bytes)
  
      @property
      @pulumi.getter(name="autoCreateTopicsEnable")
      def auto_create_topics_enable(self) -> Optional[pulumi.Input[bool]]:
          return pulumi.get(self, "auto_create_topics_enable")
  
      @auto_create_topics_enable.setter
      def auto_create_topics_enable(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "auto_create_topics_enable", value)
  
      @property
      @pulumi.getter(name="compressionType")
      def compression_type(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "compression_type")
  
      @compression_type.setter
      def compression_type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "compression_type", value)
  
      @property
      @pulumi.getter(name="defaultReplicationFactor")
      def default_replication_factor(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "default_replication_factor")
  
      @default_replication_factor.setter
      def default_replication_factor(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "default_replication_factor", value)
  
      @property
      @pulumi.getter(name="logFlushIntervalMessages")
      def log_flush_interval_messages(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "log_flush_interval_messages")
  
      @log_flush_interval_messages.setter
      def log_flush_interval_messages(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "log_flush_interval_messages", value)
  
      @property
      @pulumi.getter(name="logFlushIntervalMs")
      def log_flush_interval_ms(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "log_flush_interval_ms")
  
      @log_flush_interval_ms.setter
      def log_flush_interval_ms(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "log_flush_interval_ms", value)
  
      @property
      @pulumi.getter(name="logFlushSchedulerIntervalMs")
      def log_flush_scheduler_interval_ms(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "log_flush_scheduler_interval_ms")
  
      @log_flush_scheduler_interval_ms.setter
      def log_flush_scheduler_interval_ms(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "log_flush_scheduler_interval_ms", value)
  
      @property
      @pulumi.getter(name="logPreallocate")
      def log_preallocate(self) -> Optional[pulumi.Input[bool]]:
          return pulumi.get(self, "log_preallocate")
  
      @log_preallocate.setter
      def log_preallocate(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "log_preallocate", value)
  
      @property
      @pulumi.getter(name="logRetentionBytes")
      def log_retention_bytes(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "log_retention_bytes")
  
      @log_retention_bytes.setter
      def log_retention_bytes(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "log_retention_bytes", value)
  
      @property
      @pulumi.getter(name="logRetentionHours")
      def log_retention_hours(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "log_retention_hours")
  
      @log_retention_hours.setter
      def log_retention_hours(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "log_retention_hours", value)
  
      @property
      @pulumi.getter(name="logRetentionMinutes")
      def log_retention_minutes(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "log_retention_minutes")
  
      @log_retention_minutes.setter
      def log_retention_minutes(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "log_retention_minutes", value)
  
      @property
      @pulumi.getter(name="logRetentionMs")
      def log_retention_ms(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "log_retention_ms")
  
      @log_retention_ms.setter
      def log_retention_ms(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "log_retention_ms", value)
  
      @property
      @pulumi.getter(name="logSegmentBytes")
      def log_segment_bytes(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "log_segment_bytes")
  
      @log_segment_bytes.setter
      def log_segment_bytes(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "log_segment_bytes", value)
  
      @property
      @pulumi.getter(name="numPartitions")
      def num_partitions(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "num_partitions")
  
      @num_partitions.setter
      def num_partitions(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "num_partitions", value)
  
      @property
      @pulumi.getter(name="socketReceiveBufferBytes")
      def socket_receive_buffer_bytes(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "socket_receive_buffer_bytes")
  
      @socket_receive_buffer_bytes.setter
      def socket_receive_buffer_bytes(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "socket_receive_buffer_bytes", value)
  
      @property
      @pulumi.getter(name="socketSendBufferBytes")
      def socket_send_buffer_bytes(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "socket_send_buffer_bytes")
  
      @socket_send_buffer_bytes.setter
      def socket_send_buffer_bytes(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "socket_send_buffer_bytes", value)
  
  
  @pulumi.input_type
  class MdbKafkaClusterConfigKafkaResourcesArgs:
      def __init__(__self__, *,
                   disk_size: pulumi.Input[int],
                   disk_type_id: pulumi.Input[str],
                   resource_preset_id: pulumi.Input[str]):
          """
          :param pulumi.Input[int] disk_size: Volume of the storage available to a ZooKeeper host, in gigabytes.
          :param pulumi.Input[str] disk_type_id: Type of the storage of ZooKeeper hosts.
                 For more information see [the official documentation](https://cloud.yandex.com/docs/managed-kafka/concepts/storage).
          """
          pulumi.set(__self__, "disk_size", disk_size)
          pulumi.set(__self__, "disk_type_id", disk_type_id)
          pulumi.set(__self__, "resource_preset_id", resource_preset_id)
  
      @property
      @pulumi.getter(name="diskSize")
      def disk_size(self) -> pulumi.Input[int]:
          """
          Volume of the storage available to a ZooKeeper host, in gigabytes.
          """
          return pulumi.get(self, "disk_size")
  
      @disk_size.setter
      def disk_size(self, value: pulumi.Input[int]):
          pulumi.set(self, "disk_size", value)
  
      @property
      @pulumi.getter(name="diskTypeId")
      def disk_type_id(self) -> pulumi.Input[str]:
          """
          Type of the storage of ZooKeeper hosts.
          For more information see [the official documentation](https://cloud.yandex.com/docs/managed-kafka/concepts/storage).
          """
          return pulumi.get(self, "disk_type_id")
  
      @disk_type_id.setter
      def disk_type_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "disk_type_id", value)
  
      @property
      @pulumi.getter(name="resourcePresetId")
      def resource_preset_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "resource_preset_id")
  
      @resource_preset_id.setter
      def resource_preset_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "resource_preset_id", value)
  
  
  @pulumi.input_type
  class MdbKafkaClusterConfigZookeeperArgs:
      def __init__(__self__, *,
                   resources: Optional[pulumi.Input['MdbKafkaClusterConfigZookeeperResourcesArgs']] = None):
          """
          :param pulumi.Input['MdbKafkaClusterConfigZookeeperResourcesArgs'] resources: Resources allocated to hosts of the ZooKeeper subcluster. The structure is documented below.
          """
          if resources is not None:
              pulumi.set(__self__, "resources", resources)
  
      @property
      @pulumi.getter
      def resources(self) -> Optional[pulumi.Input['MdbKafkaClusterConfigZookeeperResourcesArgs']]:
          """
          Resources allocated to hosts of the ZooKeeper subcluster. The structure is documented below.
          """
          return pulumi.get(self, "resources")
  
      @resources.setter
      def resources(self, value: Optional[pulumi.Input['MdbKafkaClusterConfigZookeeperResourcesArgs']]):
          pulumi.set(self, "resources", value)
  
  
  @pulumi.input_type
  class MdbKafkaClusterConfigZookeeperResourcesArgs:
      def __init__(__self__, *,
                   disk_size: Optional[pulumi.Input[int]] = None,
                   disk_type_id: Optional[pulumi.Input[str]] = None,
                   resource_preset_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[int] disk_size: Volume of the storage available to a ZooKeeper host, in gigabytes.
          :param pulumi.Input[str] disk_type_id: Type of the storage of ZooKeeper hosts.
                 For more information see [the official documentation](https://cloud.yandex.com/docs/managed-kafka/concepts/storage).
          """
          if disk_size is not None:
              pulumi.set(__self__, "disk_size", disk_size)
          if disk_type_id is not None:
              pulumi.set(__self__, "disk_type_id", disk_type_id)
          if resource_preset_id is not None:
              pulumi.set(__self__, "resource_preset_id", resource_preset_id)
  
      @property
      @pulumi.getter(name="diskSize")
      def disk_size(self) -> Optional[pulumi.Input[int]]:
          """
          Volume of the storage available to a ZooKeeper host, in gigabytes.
          """
          return pulumi.get(self, "disk_size")
  
      @disk_size.setter
      def disk_size(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "disk_size", value)
  
      @property
      @pulumi.getter(name="diskTypeId")
      def disk_type_id(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the storage of ZooKeeper hosts.
          For more information see [the official documentation](https://cloud.yandex.com/docs/managed-kafka/concepts/storage).
          """
          return pulumi.get(self, "disk_type_id")
  
      @disk_type_id.setter
      def disk_type_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "disk_type_id", value)
  
      @property
      @pulumi.getter(name="resourcePresetId")
      def resource_preset_id(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "resource_preset_id")
  
      @resource_preset_id.setter
      def resource_preset_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "resource_preset_id", value)
  
  
  @pulumi.input_type
  class MdbKafkaClusterHostArgs:
      def __init__(__self__, *,
                   assign_public_ip: Optional[pulumi.Input[bool]] = None,
                   health: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   role: Optional[pulumi.Input[str]] = None,
                   subnet_id: Optional[pulumi.Input[str]] = None,
                   zone_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[bool] assign_public_ip: Determines whether each broker will be assigned a public IP address. The default is `false`.
          :param pulumi.Input[str] health: Health of the host.
          :param pulumi.Input[str] name: The name of the topic.
          :param pulumi.Input[str] role: The role type to grant to the topic.
          :param pulumi.Input[str] subnet_id: The ID of the subnet, to which the host belongs.
          :param pulumi.Input[str] zone_id: The availability zone where the Kafka host was created.
          """
          if assign_public_ip is not None:
              pulumi.set(__self__, "assign_public_ip", assign_public_ip)
          if health is not None:
              pulumi.set(__self__, "health", health)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if role is not None:
              pulumi.set(__self__, "role", role)
          if subnet_id is not None:
              pulumi.set(__self__, "subnet_id", subnet_id)
          if zone_id is not None:
              pulumi.set(__self__, "zone_id", zone_id)
  
      @property
      @pulumi.getter(name="assignPublicIp")
      def assign_public_ip(self) -> Optional[pulumi.Input[bool]]:
          """
          Determines whether each broker will be assigned a public IP address. The default is `false`.
          """
          return pulumi.get(self, "assign_public_ip")
  
      @assign_public_ip.setter
      def assign_public_ip(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "assign_public_ip", value)
  
      @property
      @pulumi.getter
      def health(self) -> Optional[pulumi.Input[str]]:
          """
          Health of the host.
          """
          return pulumi.get(self, "health")
  
      @health.setter
      def health(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "health", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the topic.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def role(self) -> Optional[pulumi.Input[str]]:
          """
          The role type to grant to the topic.
          """
          return pulumi.get(self, "role")
  
      @role.setter
      def role(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "role", value)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> Optional[pulumi.Input[str]]:
          """
          The ID of the subnet, to which the host belongs.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "subnet_id", value)
  
      @property
      @pulumi.getter(name="zoneId")
      def zone_id(self) -> Optional[pulumi.Input[str]]:
          """
          The availability zone where the Kafka host was created.
          """
          return pulumi.get(self, "zone_id")
  
      @zone_id.setter
      def zone_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "zone_id", value)
  
  
  @pulumi.input_type
  class MdbKafkaClusterTopicArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   partitions: pulumi.Input[int],
                   replication_factor: pulumi.Input[int],
                   topic_config: Optional[pulumi.Input['MdbKafkaClusterTopicTopicConfigArgs']] = None):
          """
          :param pulumi.Input[str] name: The name of the topic.
          :param pulumi.Input[int] partitions: The number of the topic's partitions.
          :param pulumi.Input[int] replication_factor: Amount of data copies (replicas) for the topic in the cluster.
          :param pulumi.Input['MdbKafkaClusterTopicTopicConfigArgs'] topic_config: User-defined settings for the topic. The structure is documented below.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "partitions", partitions)
          pulumi.set(__self__, "replication_factor", replication_factor)
          if topic_config is not None:
              pulumi.set(__self__, "topic_config", topic_config)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          The name of the topic.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def partitions(self) -> pulumi.Input[int]:
          """
          The number of the topic's partitions.
          """
          return pulumi.get(self, "partitions")
  
      @partitions.setter
      def partitions(self, value: pulumi.Input[int]):
          pulumi.set(self, "partitions", value)
  
      @property
      @pulumi.getter(name="replicationFactor")
      def replication_factor(self) -> pulumi.Input[int]:
          """
          Amount of data copies (replicas) for the topic in the cluster.
          """
          return pulumi.get(self, "replication_factor")
  
      @replication_factor.setter
      def replication_factor(self, value: pulumi.Input[int]):
          pulumi.set(self, "replication_factor", value)
  
      @property
      @pulumi.getter(name="topicConfig")
      def topic_config(self) -> Optional[pulumi.Input['MdbKafkaClusterTopicTopicConfigArgs']]:
          """
          User-defined settings for the topic. The structure is documented below.
          """
          return pulumi.get(self, "topic_config")
  
      @topic_config.setter
      def topic_config(self, value: Optional[pulumi.Input['MdbKafkaClusterTopicTopicConfigArgs']]):
          pulumi.set(self, "topic_config", value)
  
  
  @pulumi.input_type
  class MdbKafkaClusterTopicTopicConfigArgs:
      def __init__(__self__, *,
                   cleanup_policy: Optional[pulumi.Input[str]] = None,
                   compression_type: Optional[pulumi.Input[str]] = None,
                   delete_retention_ms: Optional[pulumi.Input[str]] = None,
                   file_delete_delay_ms: Optional[pulumi.Input[str]] = None,
                   flush_messages: Optional[pulumi.Input[str]] = None,
                   flush_ms: Optional[pulumi.Input[str]] = None,
                   max_message_bytes: Optional[pulumi.Input[str]] = None,
                   min_compaction_lag_ms: Optional[pulumi.Input[str]] = None,
                   min_insync_replicas: Optional[pulumi.Input[str]] = None,
                   preallocate: Optional[pulumi.Input[bool]] = None,
                   retention_bytes: Optional[pulumi.Input[str]] = None,
                   retention_ms: Optional[pulumi.Input[str]] = None,
                   segment_bytes: Optional[pulumi.Input[str]] = None):
          if cleanup_policy is not None:
              pulumi.set(__self__, "cleanup_policy", cleanup_policy)
          if compression_type is not None:
              pulumi.set(__self__, "compression_type", compression_type)
          if delete_retention_ms is not None:
              pulumi.set(__self__, "delete_retention_ms", delete_retention_ms)
          if file_delete_delay_ms is not None:
              pulumi.set(__self__, "file_delete_delay_ms", file_delete_delay_ms)
          if flush_messages is not None:
              pulumi.set(__self__, "flush_messages", flush_messages)
          if flush_ms is not None:
              pulumi.set(__self__, "flush_ms", flush_ms)
          if max_message_bytes is not None:
              pulumi.set(__self__, "max_message_bytes", max_message_bytes)
          if min_compaction_lag_ms is not None:
              pulumi.set(__self__, "min_compaction_lag_ms", min_compaction_lag_ms)
          if min_insync_replicas is not None:
              pulumi.set(__self__, "min_insync_replicas", min_insync_replicas)
          if preallocate is not None:
              pulumi.set(__self__, "preallocate", preallocate)
          if retention_bytes is not None:
              pulumi.set(__self__, "retention_bytes", retention_bytes)
          if retention_ms is not None:
              pulumi.set(__self__, "retention_ms", retention_ms)
          if segment_bytes is not None:
              pulumi.set(__self__, "segment_bytes", segment_bytes)
  
      @property
      @pulumi.getter(name="cleanupPolicy")
      def cleanup_policy(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "cleanup_policy")
  
      @cleanup_policy.setter
      def cleanup_policy(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "cleanup_policy", value)
  
      @property
      @pulumi.getter(name="compressionType")
      def compression_type(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "compression_type")
  
      @compression_type.setter
      def compression_type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "compression_type", value)
  
      @property
      @pulumi.getter(name="deleteRetentionMs")
      def delete_retention_ms(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "delete_retention_ms")
  
      @delete_retention_ms.setter
      def delete_retention_ms(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "delete_retention_ms", value)
  
      @property
      @pulumi.getter(name="fileDeleteDelayMs")
      def file_delete_delay_ms(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "file_delete_delay_ms")
  
      @file_delete_delay_ms.setter
      def file_delete_delay_ms(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "file_delete_delay_ms", value)
  
      @property
      @pulumi.getter(name="flushMessages")
      def flush_messages(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "flush_messages")
  
      @flush_messages.setter
      def flush_messages(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "flush_messages", value)
  
      @property
      @pulumi.getter(name="flushMs")
      def flush_ms(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "flush_ms")
  
      @flush_ms.setter
      def flush_ms(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "flush_ms", value)
  
      @property
      @pulumi.getter(name="maxMessageBytes")
      def max_message_bytes(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "max_message_bytes")
  
      @max_message_bytes.setter
      def max_message_bytes(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "max_message_bytes", value)
  
      @property
      @pulumi.getter(name="minCompactionLagMs")
      def min_compaction_lag_ms(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "min_compaction_lag_ms")
  
      @min_compaction_lag_ms.setter
      def min_compaction_lag_ms(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "min_compaction_lag_ms", value)
  
      @property
      @pulumi.getter(name="minInsyncReplicas")
      def min_insync_replicas(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "min_insync_replicas")
  
      @min_insync_replicas.setter
      def min_insync_replicas(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "min_insync_replicas", value)
  
      @property
      @pulumi.getter
      def preallocate(self) -> Optional[pulumi.Input[bool]]:
          return pulumi.get(self, "preallocate")
  
      @preallocate.setter
      def preallocate(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "preallocate", value)
  
      @property
      @pulumi.getter(name="retentionBytes")
      def retention_bytes(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "retention_bytes")
  
      @retention_bytes.setter
      def retention_bytes(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "retention_bytes", value)
  
      @property
      @pulumi.getter(name="retentionMs")
      def retention_ms(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "retention_ms")
  
      @retention_ms.setter
      def retention_ms(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "retention_ms", value)
  
      @property
      @pulumi.getter(name="segmentBytes")
      def segment_bytes(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "segment_bytes")
  
      @segment_bytes.setter
      def segment_bytes(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "segment_bytes", value)
  
  
  @pulumi.input_type
  class MdbKafkaClusterUserArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   password: pulumi.Input[str],
                   permissions: Optional[pulumi.Input[Sequence[pulumi.Input['MdbKafkaClusterUserPermissionArgs']]]] = None):
          """
          :param pulumi.Input[str] name: The name of the topic.
          :param pulumi.Input[str] password: The password of the user.
          :param pulumi.Input[Sequence[pulumi.Input['MdbKafkaClusterUserPermissionArgs']]] permissions: Set of permissions granted to the user. The structure is documented below.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "password", password)
          if permissions is not None:
              pulumi.set(__self__, "permissions", permissions)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          The name of the topic.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def password(self) -> pulumi.Input[str]:
          """
          The password of the user.
          """
          return pulumi.get(self, "password")
  
      @password.setter
      def password(self, value: pulumi.Input[str]):
          pulumi.set(self, "password", value)
  
      @property
      @pulumi.getter
      def permissions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MdbKafkaClusterUserPermissionArgs']]]]:
          """
          Set of permissions granted to the user. The structure is documented below.
          """
          return pulumi.get(self, "permissions")
  
      @permissions.setter
      def permissions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MdbKafkaClusterUserPermissionArgs']]]]):
          pulumi.set(self, "permissions", value)
  
  
  @pulumi.input_type
  class MdbKafkaClusterUserPermissionArgs:
      def __init__(__self__, *,
                   role: pulumi.Input[str],
                   topic_name: pulumi.Input[str]):
          """
          :param pulumi.Input[str] role: The role type to grant to the topic.
          :param pulumi.Input[str] topic_name: The name of the topic that the permission grants access to.
          """
          pulumi.set(__self__, "role", role)
          pulumi.set(__self__, "topic_name", topic_name)
  
      @property
      @pulumi.getter
      def role(self) -> pulumi.Input[str]:
          """
          The role type to grant to the topic.
          """
          return pulumi.get(self, "role")
  
      @role.setter
      def role(self, value: pulumi.Input[str]):
          pulumi.set(self, "role", value)
  
      @property
      @pulumi.getter(name="topicName")
      def topic_name(self) -> pulumi.Input[str]:
          """
          The name of the topic that the permission grants access to.
          """
          return pulumi.get(self, "topic_name")
  
      @topic_name.setter
      def topic_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "topic_name", value)
  
  
  @pulumi.input_type
  class MdbKafkaTopicTopicConfigArgs:
      def __init__(__self__, *,
                   cleanup_policy: Optional[pulumi.Input[str]] = None,
                   compression_type: Optional[pulumi.Input[str]] = None,
                   delete_retention_ms: Optional[pulumi.Input[str]] = None,
                   file_delete_delay_ms: Optional[pulumi.Input[str]] = None,
                   flush_messages: Optional[pulumi.Input[str]] = None,
                   flush_ms: Optional[pulumi.Input[str]] = None,
                   max_message_bytes: Optional[pulumi.Input[str]] = None,
                   min_compaction_lag_ms: Optional[pulumi.Input[str]] = None,
                   min_insync_replicas: Optional[pulumi.Input[str]] = None,
                   preallocate: Optional[pulumi.Input[bool]] = None,
                   retention_bytes: Optional[pulumi.Input[str]] = None,
                   retention_ms: Optional[pulumi.Input[str]] = None,
                   segment_bytes: Optional[pulumi.Input[str]] = None):
          if cleanup_policy is not None:
              pulumi.set(__self__, "cleanup_policy", cleanup_policy)
          if compression_type is not None:
              pulumi.set(__self__, "compression_type", compression_type)
          if delete_retention_ms is not None:
              pulumi.set(__self__, "delete_retention_ms", delete_retention_ms)
          if file_delete_delay_ms is not None:
              pulumi.set(__self__, "file_delete_delay_ms", file_delete_delay_ms)
          if flush_messages is not None:
              pulumi.set(__self__, "flush_messages", flush_messages)
          if flush_ms is not None:
              pulumi.set(__self__, "flush_ms", flush_ms)
          if max_message_bytes is not None:
              pulumi.set(__self__, "max_message_bytes", max_message_bytes)
          if min_compaction_lag_ms is not None:
              pulumi.set(__self__, "min_compaction_lag_ms", min_compaction_lag_ms)
          if min_insync_replicas is not None:
              pulumi.set(__self__, "min_insync_replicas", min_insync_replicas)
          if preallocate is not None:
              pulumi.set(__self__, "preallocate", preallocate)
          if retention_bytes is not None:
              pulumi.set(__self__, "retention_bytes", retention_bytes)
          if retention_ms is not None:
              pulumi.set(__self__, "retention_ms", retention_ms)
          if segment_bytes is not None:
              pulumi.set(__self__, "segment_bytes", segment_bytes)
  
      @property
      @pulumi.getter(name="cleanupPolicy")
      def cleanup_policy(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "cleanup_policy")
  
      @cleanup_policy.setter
      def cleanup_policy(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "cleanup_policy", value)
  
      @property
      @pulumi.getter(name="compressionType")
      def compression_type(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "compression_type")
  
      @compression_type.setter
      def compression_type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "compression_type", value)
  
      @property
      @pulumi.getter(name="deleteRetentionMs")
      def delete_retention_ms(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "delete_retention_ms")
  
      @delete_retention_ms.setter
      def delete_retention_ms(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "delete_retention_ms", value)
  
      @property
      @pulumi.getter(name="fileDeleteDelayMs")
      def file_delete_delay_ms(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "file_delete_delay_ms")
  
      @file_delete_delay_ms.setter
      def file_delete_delay_ms(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "file_delete_delay_ms", value)
  
      @property
      @pulumi.getter(name="flushMessages")
      def flush_messages(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "flush_messages")
  
      @flush_messages.setter
      def flush_messages(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "flush_messages", value)
  
      @property
      @pulumi.getter(name="flushMs")
      def flush_ms(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "flush_ms")
  
      @flush_ms.setter
      def flush_ms(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "flush_ms", value)
  
      @property
      @pulumi.getter(name="maxMessageBytes")
      def max_message_bytes(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "max_message_bytes")
  
      @max_message_bytes.setter
      def max_message_bytes(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "max_message_bytes", value)
  
      @property
      @pulumi.getter(name="minCompactionLagMs")
      def min_compaction_lag_ms(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "min_compaction_lag_ms")
  
      @min_compaction_lag_ms.setter
      def min_compaction_lag_ms(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "min_compaction_lag_ms", value)
  
      @property
      @pulumi.getter(name="minInsyncReplicas")
      def min_insync_replicas(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "min_insync_replicas")
  
      @min_insync_replicas.setter
      def min_insync_replicas(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "min_insync_replicas", value)
  
      @property
      @pulumi.getter
      def preallocate(self) -> Optional[pulumi.Input[bool]]:
          return pulumi.get(self, "preallocate")
  
      @preallocate.setter
      def preallocate(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "preallocate", value)
  
      @property
      @pulumi.getter(name="retentionBytes")
      def retention_bytes(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "retention_bytes")
  
      @retention_bytes.setter
      def retention_bytes(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "retention_bytes", value)
  
      @property
      @pulumi.getter(name="retentionMs")
      def retention_ms(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "retention_ms")
  
      @retention_ms.setter
      def retention_ms(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "retention_ms", value)
  
      @property
      @pulumi.getter(name="segmentBytes")
      def segment_bytes(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "segment_bytes")
  
      @segment_bytes.setter
      def segment_bytes(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "segment_bytes", value)
  
  
  @pulumi.input_type
  class MdbMongodbClusterClusterConfigArgs:
      def __init__(__self__, *,
                   version: pulumi.Input[str],
                   access: Optional[pulumi.Input['MdbMongodbClusterClusterConfigAccessArgs']] = None,
                   backup_window_start: Optional[pulumi.Input['MdbMongodbClusterClusterConfigBackupWindowStartArgs']] = None,
                   feature_compatibility_version: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] version: Version of MongoDB (either 5.0, 4.4, 4.2 or 4.0).
          :param pulumi.Input['MdbMongodbClusterClusterConfigAccessArgs'] access: Shows whether cluster has access to data lens. The structure is documented below.
          :param pulumi.Input['MdbMongodbClusterClusterConfigBackupWindowStartArgs'] backup_window_start: Time to start the daily backup, in the UTC timezone. The structure is documented below.
          :param pulumi.Input[str] feature_compatibility_version: Feature compatibility version of MongoDB. If not provided version is taken. Can be either `5.0`, `4.4`, `4.2` and `4.0`.
          """
          pulumi.set(__self__, "version", version)
          if access is not None:
              pulumi.set(__self__, "access", access)
          if backup_window_start is not None:
              pulumi.set(__self__, "backup_window_start", backup_window_start)
          if feature_compatibility_version is not None:
              pulumi.set(__self__, "feature_compatibility_version", feature_compatibility_version)
  
      @property
      @pulumi.getter
      def version(self) -> pulumi.Input[str]:
          """
          Version of MongoDB (either 5.0, 4.4, 4.2 or 4.0).
          """
          return pulumi.get(self, "version")
  
      @version.setter
      def version(self, value: pulumi.Input[str]):
          pulumi.set(self, "version", value)
  
      @property
      @pulumi.getter
      def access(self) -> Optional[pulumi.Input['MdbMongodbClusterClusterConfigAccessArgs']]:
          """
          Shows whether cluster has access to data lens. The structure is documented below.
          """
          return pulumi.get(self, "access")
  
      @access.setter
      def access(self, value: Optional[pulumi.Input['MdbMongodbClusterClusterConfigAccessArgs']]):
          pulumi.set(self, "access", value)
  
      @property
      @pulumi.getter(name="backupWindowStart")
      def backup_window_start(self) -> Optional[pulumi.Input['MdbMongodbClusterClusterConfigBackupWindowStartArgs']]:
          """
          Time to start the daily backup, in the UTC timezone. The structure is documented below.
          """
          return pulumi.get(self, "backup_window_start")
  
      @backup_window_start.setter
      def backup_window_start(self, value: Optional[pulumi.Input['MdbMongodbClusterClusterConfigBackupWindowStartArgs']]):
          pulumi.set(self, "backup_window_start", value)
  
      @property
      @pulumi.getter(name="featureCompatibilityVersion")
      def feature_compatibility_version(self) -> Optional[pulumi.Input[str]]:
          """
          Feature compatibility version of MongoDB. If not provided version is taken. Can be either `5.0`, `4.4`, `4.2` and `4.0`.
          """
          return pulumi.get(self, "feature_compatibility_version")
  
      @feature_compatibility_version.setter
      def feature_compatibility_version(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "feature_compatibility_version", value)
  
  
  @pulumi.input_type
  class MdbMongodbClusterClusterConfigAccessArgs:
      def __init__(__self__, *,
                   data_lens: Optional[pulumi.Input[bool]] = None):
          """
          :param pulumi.Input[bool] data_lens: Allow access for DataLens.
          """
          if data_lens is not None:
              pulumi.set(__self__, "data_lens", data_lens)
  
      @property
      @pulumi.getter(name="dataLens")
      def data_lens(self) -> Optional[pulumi.Input[bool]]:
          """
          Allow access for DataLens.
          """
          return pulumi.get(self, "data_lens")
  
      @data_lens.setter
      def data_lens(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "data_lens", value)
  
  
  @pulumi.input_type
  class MdbMongodbClusterClusterConfigBackupWindowStartArgs:
      def __init__(__self__, *,
                   hours: Optional[pulumi.Input[int]] = None,
                   minutes: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] hours: The hour at which backup will be started.
          :param pulumi.Input[int] minutes: The minute at which backup will be started.
          """
          if hours is not None:
              pulumi.set(__self__, "hours", hours)
          if minutes is not None:
              pulumi.set(__self__, "minutes", minutes)
  
      @property
      @pulumi.getter
      def hours(self) -> Optional[pulumi.Input[int]]:
          """
          The hour at which backup will be started.
          """
          return pulumi.get(self, "hours")
  
      @hours.setter
      def hours(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "hours", value)
  
      @property
      @pulumi.getter
      def minutes(self) -> Optional[pulumi.Input[int]]:
          """
          The minute at which backup will be started.
          """
          return pulumi.get(self, "minutes")
  
      @minutes.setter
      def minutes(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "minutes", value)
  
  
  @pulumi.input_type
  class MdbMongodbClusterDatabaseArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str]):
          """
          :param pulumi.Input[str] name: The fully qualified domain name of the host. Computed on server side.
          """
          pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          The fully qualified domain name of the host. Computed on server side.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class MdbMongodbClusterHostArgs:
      def __init__(__self__, *,
                   subnet_id: pulumi.Input[str],
                   zone_id: pulumi.Input[str],
                   assign_public_ip: Optional[pulumi.Input[bool]] = None,
                   health: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   role: Optional[pulumi.Input[str]] = None,
                   shard_name: Optional[pulumi.Input[str]] = None,
                   type: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] subnet_id: The ID of the subnet, to which the host belongs. The subnet must
                 be a part of the network to which the cluster belongs.
          :param pulumi.Input[str] zone_id: The availability zone where the MongoDB host will be created.
                 For more information see [the official documentation](https://cloud.yandex.com/docs/overview/concepts/geo-scope).
          :param pulumi.Input[bool] assign_public_ip: -(Optional)  Should this host have assigned public IP assigned. Can be either `true` or `false`.
          :param pulumi.Input[str] health: The health of the host.
          :param pulumi.Input[str] name: The fully qualified domain name of the host. Computed on server side.
          :param pulumi.Input[str] role: The role of the cluster (either PRIMARY or SECONDARY).
          :param pulumi.Input[str] shard_name: The name of the shard to which the host belongs.
          :param pulumi.Input[str] type: Type of maintenance window. Can be either `ANYTIME` or `WEEKLY`. A day and hour of window need to be specified with weekly window.
          """
          pulumi.set(__self__, "subnet_id", subnet_id)
          pulumi.set(__self__, "zone_id", zone_id)
          if assign_public_ip is not None:
              pulumi.set(__self__, "assign_public_ip", assign_public_ip)
          if health is not None:
              pulumi.set(__self__, "health", health)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if role is not None:
              pulumi.set(__self__, "role", role)
          if shard_name is not None:
              pulumi.set(__self__, "shard_name", shard_name)
          if type is not None:
              pulumi.set(__self__, "type", type)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> pulumi.Input[str]:
          """
          The ID of the subnet, to which the host belongs. The subnet must
          be a part of the network to which the cluster belongs.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "subnet_id", value)
  
      @property
      @pulumi.getter(name="zoneId")
      def zone_id(self) -> pulumi.Input[str]:
          """
          The availability zone where the MongoDB host will be created.
          For more information see [the official documentation](https://cloud.yandex.com/docs/overview/concepts/geo-scope).
          """
          return pulumi.get(self, "zone_id")
  
      @zone_id.setter
      def zone_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "zone_id", value)
  
      @property
      @pulumi.getter(name="assignPublicIp")
      def assign_public_ip(self) -> Optional[pulumi.Input[bool]]:
          """
          -(Optional)  Should this host have assigned public IP assigned. Can be either `true` or `false`.
          """
          return pulumi.get(self, "assign_public_ip")
  
      @assign_public_ip.setter
      def assign_public_ip(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "assign_public_ip", value)
  
      @property
      @pulumi.getter
      def health(self) -> Optional[pulumi.Input[str]]:
          """
          The health of the host.
          """
          return pulumi.get(self, "health")
  
      @health.setter
      def health(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "health", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          The fully qualified domain name of the host. Computed on server side.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def role(self) -> Optional[pulumi.Input[str]]:
          """
          The role of the cluster (either PRIMARY or SECONDARY).
          """
          return pulumi.get(self, "role")
  
      @role.setter
      def role(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "role", value)
  
      @property
      @pulumi.getter(name="shardName")
      def shard_name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the shard to which the host belongs.
          """
          return pulumi.get(self, "shard_name")
  
      @shard_name.setter
      def shard_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "shard_name", value)
  
      @property
      @pulumi.getter
      def type(self) -> Optional[pulumi.Input[str]]:
          """
          Type of maintenance window. Can be either `ANYTIME` or `WEEKLY`. A day and hour of window need to be specified with weekly window.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "type", value)
  
  
  @pulumi.input_type
  class MdbMongodbClusterMaintenanceWindowArgs:
      def __init__(__self__, *,
                   type: pulumi.Input[str],
                   day: Optional[pulumi.Input[str]] = None,
                   hour: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] type: Type of maintenance window. Can be either `ANYTIME` or `WEEKLY`. A day and hour of window need to be specified with weekly window.
          :param pulumi.Input[str] day: Day of week for maintenance window if window type is weekly. Possible values: `MON`, `TUE`, `WED`, `THU`, `FRI`, `SAT`, `SUN`.
          :param pulumi.Input[int] hour: Hour of day in UTC time zone (1-24) for maintenance window if window type is weekly.
          """
          pulumi.set(__self__, "type", type)
          if day is not None:
              pulumi.set(__self__, "day", day)
          if hour is not None:
              pulumi.set(__self__, "hour", hour)
  
      @property
      @pulumi.getter
      def type(self) -> pulumi.Input[str]:
          """
          Type of maintenance window. Can be either `ANYTIME` or `WEEKLY`. A day and hour of window need to be specified with weekly window.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: pulumi.Input[str]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter
      def day(self) -> Optional[pulumi.Input[str]]:
          """
          Day of week for maintenance window if window type is weekly. Possible values: `MON`, `TUE`, `WED`, `THU`, `FRI`, `SAT`, `SUN`.
          """
          return pulumi.get(self, "day")
  
      @day.setter
      def day(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "day", value)
  
      @property
      @pulumi.getter
      def hour(self) -> Optional[pulumi.Input[int]]:
          """
          Hour of day in UTC time zone (1-24) for maintenance window if window type is weekly.
          """
          return pulumi.get(self, "hour")
  
      @hour.setter
      def hour(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "hour", value)
  
  
  @pulumi.input_type
  class MdbMongodbClusterResourcesArgs:
      def __init__(__self__, *,
                   disk_size: pulumi.Input[int],
                   disk_type_id: pulumi.Input[str],
                   resource_preset_id: pulumi.Input[str]):
          """
          :param pulumi.Input[int] disk_size: Volume of the storage available to a MongoDB host, in gigabytes.
          :param pulumi.Input[str] disk_type_id: Type of the storage of MongoDB hosts.
                 For more information see [the official documentation](https://cloud.yandex.com/docs/managed-clickhouse/concepts/storage).
          """
          pulumi.set(__self__, "disk_size", disk_size)
          pulumi.set(__self__, "disk_type_id", disk_type_id)
          pulumi.set(__self__, "resource_preset_id", resource_preset_id)
  
      @property
      @pulumi.getter(name="diskSize")
      def disk_size(self) -> pulumi.Input[int]:
          """
          Volume of the storage available to a MongoDB host, in gigabytes.
          """
          return pulumi.get(self, "disk_size")
  
      @disk_size.setter
      def disk_size(self, value: pulumi.Input[int]):
          pulumi.set(self, "disk_size", value)
  
      @property
      @pulumi.getter(name="diskTypeId")
      def disk_type_id(self) -> pulumi.Input[str]:
          """
          Type of the storage of MongoDB hosts.
          For more information see [the official documentation](https://cloud.yandex.com/docs/managed-clickhouse/concepts/storage).
          """
          return pulumi.get(self, "disk_type_id")
  
      @disk_type_id.setter
      def disk_type_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "disk_type_id", value)
  
      @property
      @pulumi.getter(name="resourcePresetId")
      def resource_preset_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "resource_preset_id")
  
      @resource_preset_id.setter
      def resource_preset_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "resource_preset_id", value)
  
  
  @pulumi.input_type
  class MdbMongodbClusterUserArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   password: pulumi.Input[str],
                   permissions: Optional[pulumi.Input[Sequence[pulumi.Input['MdbMongodbClusterUserPermissionArgs']]]] = None):
          """
          :param pulumi.Input[str] name: The fully qualified domain name of the host. Computed on server side.
          :param pulumi.Input[str] password: The password of the user.
          :param pulumi.Input[Sequence[pulumi.Input['MdbMongodbClusterUserPermissionArgs']]] permissions: Set of permissions granted to the user. The structure is documented below.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "password", password)
          if permissions is not None:
              pulumi.set(__self__, "permissions", permissions)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          The fully qualified domain name of the host. Computed on server side.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def password(self) -> pulumi.Input[str]:
          """
          The password of the user.
          """
          return pulumi.get(self, "password")
  
      @password.setter
      def password(self, value: pulumi.Input[str]):
          pulumi.set(self, "password", value)
  
      @property
      @pulumi.getter
      def permissions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MdbMongodbClusterUserPermissionArgs']]]]:
          """
          Set of permissions granted to the user. The structure is documented below.
          """
          return pulumi.get(self, "permissions")
  
      @permissions.setter
      def permissions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MdbMongodbClusterUserPermissionArgs']]]]):
          pulumi.set(self, "permissions", value)
  
  
  @pulumi.input_type
  class MdbMongodbClusterUserPermissionArgs:
      def __init__(__self__, *,
                   database_name: pulumi.Input[str],
                   roles: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          :param pulumi.Input[str] database_name: The name of the database that the permission grants access to.
          """
          pulumi.set(__self__, "database_name", database_name)
          if roles is not None:
              pulumi.set(__self__, "roles", roles)
  
      @property
      @pulumi.getter(name="databaseName")
      def database_name(self) -> pulumi.Input[str]:
          """
          The name of the database that the permission grants access to.
          """
          return pulumi.get(self, "database_name")
  
      @database_name.setter
      def database_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "database_name", value)
  
      @property
      @pulumi.getter
      def roles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          return pulumi.get(self, "roles")
  
      @roles.setter
      def roles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "roles", value)
  
  
  @pulumi.input_type
  class MdbMysqlClusterAccessArgs:
      def __init__(__self__, *,
                   data_lens: Optional[pulumi.Input[bool]] = None,
                   web_sql: Optional[pulumi.Input[bool]] = None):
          """
          :param pulumi.Input[bool] data_lens: Allow access for [Yandex DataLens](https://cloud.yandex.com/services/datalens).
          :param pulumi.Input[bool] web_sql: Allows access for [SQL queries in the management console](https://cloud.yandex.com/docs/managed-mysql/operations/web-sql-query).
          """
          if data_lens is not None:
              pulumi.set(__self__, "data_lens", data_lens)
          if web_sql is not None:
              pulumi.set(__self__, "web_sql", web_sql)
  
      @property
      @pulumi.getter(name="dataLens")
      def data_lens(self) -> Optional[pulumi.Input[bool]]:
          """
          Allow access for [Yandex DataLens](https://cloud.yandex.com/services/datalens).
          """
          return pulumi.get(self, "data_lens")
  
      @data_lens.setter
      def data_lens(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "data_lens", value)
  
      @property
      @pulumi.getter(name="webSql")
      def web_sql(self) -> Optional[pulumi.Input[bool]]:
          """
          Allows access for [SQL queries in the management console](https://cloud.yandex.com/docs/managed-mysql/operations/web-sql-query).
          """
          return pulumi.get(self, "web_sql")
  
      @web_sql.setter
      def web_sql(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "web_sql", value)
  
  
  @pulumi.input_type
  class MdbMysqlClusterBackupWindowStartArgs:
      def __init__(__self__, *,
                   hours: Optional[pulumi.Input[int]] = None,
                   minutes: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] hours: The hour at which backup will be started.
          :param pulumi.Input[int] minutes: The minute at which backup will be started.
          """
          if hours is not None:
              pulumi.set(__self__, "hours", hours)
          if minutes is not None:
              pulumi.set(__self__, "minutes", minutes)
  
      @property
      @pulumi.getter
      def hours(self) -> Optional[pulumi.Input[int]]:
          """
          The hour at which backup will be started.
          """
          return pulumi.get(self, "hours")
  
      @hours.setter
      def hours(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "hours", value)
  
      @property
      @pulumi.getter
      def minutes(self) -> Optional[pulumi.Input[int]]:
          """
          The minute at which backup will be started.
          """
          return pulumi.get(self, "minutes")
  
      @minutes.setter
      def minutes(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "minutes", value)
  
  
  @pulumi.input_type
  class MdbMysqlClusterDatabaseArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str]):
          """
          :param pulumi.Input[str] name: Host state name. It should be set for all hosts or unset for all hosts. This field can be used by another host, to select which host will be its replication source. Please refer to `replication_source_name` parameter.
          """
          pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          Host state name. It should be set for all hosts or unset for all hosts. This field can be used by another host, to select which host will be its replication source. Please refer to `replication_source_name` parameter.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class MdbMysqlClusterHostArgs:
      def __init__(__self__, *,
                   zone: pulumi.Input[str],
                   assign_public_ip: Optional[pulumi.Input[bool]] = None,
                   fqdn: Optional[pulumi.Input[str]] = None,
                   name: Optional[pulumi.Input[str]] = None,
                   replication_source: Optional[pulumi.Input[str]] = None,
                   replication_source_name: Optional[pulumi.Input[str]] = None,
                   subnet_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] zone: The availability zone where the MySQL host will be created.
          :param pulumi.Input[bool] assign_public_ip: Sets whether the host should get a public IP address. It can be changed on the fly only when `name` is set.
          :param pulumi.Input[str] fqdn: The fully qualified domain name of the host.
          :param pulumi.Input[str] name: Host state name. It should be set for all hosts or unset for all hosts. This field can be used by another host, to select which host will be its replication source. Please refer to `replication_source_name` parameter.
          :param pulumi.Input[str] replication_source: Host replication source (fqdn), when replication_source is empty then host is in HA group.
          :param pulumi.Input[str] replication_source_name: Host replication source name points to host's `name` from which this host should replicate. When not set then host in HA group. It works only when `name` is set.
          :param pulumi.Input[str] subnet_id: The ID of the subnet, to which the host belongs. The subnet must be a part of the network to which the cluster belongs.
          """
          pulumi.set(__self__, "zone", zone)
          if assign_public_ip is not None:
              pulumi.set(__self__, "assign_public_ip", assign_public_ip)
          if fqdn is not None:
              pulumi.set(__self__, "fqdn", fqdn)
          if name is not None:
              pulumi.set(__self__, "name", name)
          if replication_source is not None:
              pulumi.set(__self__, "replication_source", replication_source)
          if replication_source_name is not None:
              pulumi.set(__self__, "replication_source_name", replication_source_name)
          if subnet_id is not None:
              pulumi.set(__self__, "subnet_id", subnet_id)
  
      @property
      @pulumi.getter
      def zone(self) -> pulumi.Input[str]:
          """
          The availability zone where the MySQL host will be created.
          """
          return pulumi.get(self, "zone")
  
      @zone.setter
      def zone(self, value: pulumi.Input[str]):
          pulumi.set(self, "zone", value)
  
      @property
      @pulumi.getter(name="assignPublicIp")
      def assign_public_ip(self) -> Optional[pulumi.Input[bool]]:
          """
          Sets whether the host should get a public IP address. It can be changed on the fly only when `name` is set.
          """
          return pulumi.get(self, "assign_public_ip")
  
      @assign_public_ip.setter
      def assign_public_ip(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "assign_public_ip", value)
  
      @property
      @pulumi.getter
      def fqdn(self) -> Optional[pulumi.Input[str]]:
          """
          The fully qualified domain name of the host.
          """
          return pulumi.get(self, "fqdn")
  
      @fqdn.setter
      def fqdn(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "fqdn", value)
  
      @property
      @pulumi.getter
      def name(self) -> Optional[pulumi.Input[str]]:
          """
          Host state name. It should be set for all hosts or unset for all hosts. This field can be used by another host, to select which host will be its replication source. Please refer to `replication_source_name` parameter.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter(name="replicationSource")
      def replication_source(self) -> Optional[pulumi.Input[str]]:
          """
          Host replication source (fqdn), when replication_source is empty then host is in HA group.
          """
          return pulumi.get(self, "replication_source")
  
      @replication_source.setter
      def replication_source(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "replication_source", value)
  
      @property
      @pulumi.getter(name="replicationSourceName")
      def replication_source_name(self) -> Optional[pulumi.Input[str]]:
          """
          Host replication source name points to host's `name` from which this host should replicate. When not set then host in HA group. It works only when `name` is set.
          """
          return pulumi.get(self, "replication_source_name")
  
      @replication_source_name.setter
      def replication_source_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "replication_source_name", value)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> Optional[pulumi.Input[str]]:
          """
          The ID of the subnet, to which the host belongs. The subnet must be a part of the network to which the cluster belongs.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "subnet_id", value)
  
  
  @pulumi.input_type
  class MdbMysqlClusterMaintenanceWindowArgs:
      def __init__(__self__, *,
                   type: pulumi.Input[str],
                   day: Optional[pulumi.Input[str]] = None,
                   hour: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] type: Type of maintenance window. Can be either `ANYTIME` or `WEEKLY`. A day and hour of window need to be specified with weekly window.
          :param pulumi.Input[str] day: Day of the week (in `DDD` format). Allowed values: "MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN"
          :param pulumi.Input[int] hour: Hour of the day in UTC (in `HH` format). Allowed value is between 0 and 23.
          """
          pulumi.set(__self__, "type", type)
          if day is not None:
              pulumi.set(__self__, "day", day)
          if hour is not None:
              pulumi.set(__self__, "hour", hour)
  
      @property
      @pulumi.getter
      def type(self) -> pulumi.Input[str]:
          """
          Type of maintenance window. Can be either `ANYTIME` or `WEEKLY`. A day and hour of window need to be specified with weekly window.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: pulumi.Input[str]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter
      def day(self) -> Optional[pulumi.Input[str]]:
          """
          Day of the week (in `DDD` format). Allowed values: "MON", "TUE", "WED", "THU", "FRI", "SAT", "SUN"
          """
          return pulumi.get(self, "day")
  
      @day.setter
      def day(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "day", value)
  
      @property
      @pulumi.getter
      def hour(self) -> Optional[pulumi.Input[int]]:
          """
          Hour of the day in UTC (in `HH` format). Allowed value is between 0 and 23.
          """
          return pulumi.get(self, "hour")
  
      @hour.setter
      def hour(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "hour", value)
  
  
  @pulumi.input_type
  class MdbMysqlClusterResourcesArgs:
      def __init__(__self__, *,
                   disk_size: pulumi.Input[int],
                   disk_type_id: pulumi.Input[str],
                   resource_preset_id: pulumi.Input[str]):
          """
          :param pulumi.Input[int] disk_size: Volume of the storage available to a MySQL host, in gigabytes.
          :param pulumi.Input[str] disk_type_id: Type of the storage of MySQL hosts.
          """
          pulumi.set(__self__, "disk_size", disk_size)
          pulumi.set(__self__, "disk_type_id", disk_type_id)
          pulumi.set(__self__, "resource_preset_id", resource_preset_id)
  
      @property
      @pulumi.getter(name="diskSize")
      def disk_size(self) -> pulumi.Input[int]:
          """
          Volume of the storage available to a MySQL host, in gigabytes.
          """
          return pulumi.get(self, "disk_size")
  
      @disk_size.setter
      def disk_size(self, value: pulumi.Input[int]):
          pulumi.set(self, "disk_size", value)
  
      @property
      @pulumi.getter(name="diskTypeId")
      def disk_type_id(self) -> pulumi.Input[str]:
          """
          Type of the storage of MySQL hosts.
          """
          return pulumi.get(self, "disk_type_id")
  
      @disk_type_id.setter
      def disk_type_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "disk_type_id", value)
  
      @property
      @pulumi.getter(name="resourcePresetId")
      def resource_preset_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "resource_preset_id")
  
      @resource_preset_id.setter
      def resource_preset_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "resource_preset_id", value)
  
  
  @pulumi.input_type
  class MdbMysqlClusterRestoreArgs:
      def __init__(__self__, *,
                   backup_id: pulumi.Input[str],
                   time: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] backup_id: Backup ID. The cluster will be created from the specified backup. [How to get a list of MySQL backups](https://cloud.yandex.com/docs/managed-mysql/operations/cluster-backups).
          :param pulumi.Input[str] time: Timestamp of the moment to which the MySQL cluster should be restored. (Format: "2006-01-02T15:04:05" - UTC). When not set, current time is used.
          """
          pulumi.set(__self__, "backup_id", backup_id)
          if time is not None:
              pulumi.set(__self__, "time", time)
  
      @property
      @pulumi.getter(name="backupId")
      def backup_id(self) -> pulumi.Input[str]:
          """
          Backup ID. The cluster will be created from the specified backup. [How to get a list of MySQL backups](https://cloud.yandex.com/docs/managed-mysql/operations/cluster-backups).
          """
          return pulumi.get(self, "backup_id")
  
      @backup_id.setter
      def backup_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "backup_id", value)
  
      @property
      @pulumi.getter
      def time(self) -> Optional[pulumi.Input[str]]:
          """
          Timestamp of the moment to which the MySQL cluster should be restored. (Format: "2006-01-02T15:04:05" - UTC). When not set, current time is used.
          """
          return pulumi.get(self, "time")
  
      @time.setter
      def time(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "time", value)
  
  
  @pulumi.input_type
  class MdbMysqlClusterUserArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   password: pulumi.Input[str],
                   authentication_plugin: Optional[pulumi.Input[str]] = None,
                   connection_limits: Optional[pulumi.Input['MdbMysqlClusterUserConnectionLimitsArgs']] = None,
                   global_permissions: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   permissions: Optional[pulumi.Input[Sequence[pulumi.Input['MdbMysqlClusterUserPermissionArgs']]]] = None):
          """
          :param pulumi.Input[str] name: Host state name. It should be set for all hosts or unset for all hosts. This field can be used by another host, to select which host will be its replication source. Please refer to `replication_source_name` parameter.
          :param pulumi.Input[str] password: The password of the user.
          :param pulumi.Input[str] authentication_plugin: Authentication plugin. Allowed values: `MYSQL_NATIVE_PASSWORD`, `CACHING_SHA2_PASSWORD`, `SHA256_PASSWORD` (for version 5.7 `MYSQL_NATIVE_PASSWORD`, `SHA256_PASSWORD`)
          :param pulumi.Input['MdbMysqlClusterUserConnectionLimitsArgs'] connection_limits: User's connection limits. The structure is documented below.
                 If the attribute is not specified there will be no changes.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] global_permissions: List user's global permissions     
                 Allowed permissions:  `REPLICATION_CLIENT`, `REPLICATION_SLAVE`, `PROCESS` for clear list use empty list.
                 If the attribute is not specified there will be no changes.
          :param pulumi.Input[Sequence[pulumi.Input['MdbMysqlClusterUserPermissionArgs']]] permissions: Set of permissions granted to the user. The structure is documented below.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "password", password)
          if authentication_plugin is not None:
              pulumi.set(__self__, "authentication_plugin", authentication_plugin)
          if connection_limits is not None:
              pulumi.set(__self__, "connection_limits", connection_limits)
          if global_permissions is not None:
              pulumi.set(__self__, "global_permissions", global_permissions)
          if permissions is not None:
              pulumi.set(__self__, "permissions", permissions)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          Host state name. It should be set for all hosts or unset for all hosts. This field can be used by another host, to select which host will be its replication source. Please refer to `replication_source_name` parameter.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def password(self) -> pulumi.Input[str]:
          """
          The password of the user.
          """
          return pulumi.get(self, "password")
  
      @password.setter
      def password(self, value: pulumi.Input[str]):
          pulumi.set(self, "password", value)
  
      @property
      @pulumi.getter(name="authenticationPlugin")
      def authentication_plugin(self) -> Optional[pulumi.Input[str]]:
          """
          Authentication plugin. Allowed values: `MYSQL_NATIVE_PASSWORD`, `CACHING_SHA2_PASSWORD`, `SHA256_PASSWORD` (for version 5.7 `MYSQL_NATIVE_PASSWORD`, `SHA256_PASSWORD`)
          """
          return pulumi.get(self, "authentication_plugin")
  
      @authentication_plugin.setter
      def authentication_plugin(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "authentication_plugin", value)
  
      @property
      @pulumi.getter(name="connectionLimits")
      def connection_limits(self) -> Optional[pulumi.Input['MdbMysqlClusterUserConnectionLimitsArgs']]:
          """
          User's connection limits. The structure is documented below.
          If the attribute is not specified there will be no changes.
          """
          return pulumi.get(self, "connection_limits")
  
      @connection_limits.setter
      def connection_limits(self, value: Optional[pulumi.Input['MdbMysqlClusterUserConnectionLimitsArgs']]):
          pulumi.set(self, "connection_limits", value)
  
      @property
      @pulumi.getter(name="globalPermissions")
      def global_permissions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List user's global permissions     
          Allowed permissions:  `REPLICATION_CLIENT`, `REPLICATION_SLAVE`, `PROCESS` for clear list use empty list.
          If the attribute is not specified there will be no changes.
          """
          return pulumi.get(self, "global_permissions")
  
      @global_permissions.setter
      def global_permissions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "global_permissions", value)
  
      @property
      @pulumi.getter
      def permissions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MdbMysqlClusterUserPermissionArgs']]]]:
          """
          Set of permissions granted to the user. The structure is documented below.
          """
          return pulumi.get(self, "permissions")
  
      @permissions.setter
      def permissions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MdbMysqlClusterUserPermissionArgs']]]]):
          pulumi.set(self, "permissions", value)
  
  
  @pulumi.input_type
  class MdbMysqlClusterUserConnectionLimitsArgs:
      def __init__(__self__, *,
                   max_connections_per_hour: Optional[pulumi.Input[int]] = None,
                   max_questions_per_hour: Optional[pulumi.Input[int]] = None,
                   max_updates_per_hour: Optional[pulumi.Input[int]] = None,
                   max_user_connections: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] max_connections_per_hour: Max connections per hour.
          :param pulumi.Input[int] max_questions_per_hour: Max questions per hour.
          :param pulumi.Input[int] max_updates_per_hour: Max updates per hour.
          :param pulumi.Input[int] max_user_connections: Max user connections.
          """
          if max_connections_per_hour is not None:
              pulumi.set(__self__, "max_connections_per_hour", max_connections_per_hour)
          if max_questions_per_hour is not None:
              pulumi.set(__self__, "max_questions_per_hour", max_questions_per_hour)
          if max_updates_per_hour is not None:
              pulumi.set(__self__, "max_updates_per_hour", max_updates_per_hour)
          if max_user_connections is not None:
              pulumi.set(__self__, "max_user_connections", max_user_connections)
  
      @property
      @pulumi.getter(name="maxConnectionsPerHour")
      def max_connections_per_hour(self) -> Optional[pulumi.Input[int]]:
          """
          Max connections per hour.
          """
          return pulumi.get(self, "max_connections_per_hour")
  
      @max_connections_per_hour.setter
      def max_connections_per_hour(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_connections_per_hour", value)
  
      @property
      @pulumi.getter(name="maxQuestionsPerHour")
      def max_questions_per_hour(self) -> Optional[pulumi.Input[int]]:
          """
          Max questions per hour.
          """
          return pulumi.get(self, "max_questions_per_hour")
  
      @max_questions_per_hour.setter
      def max_questions_per_hour(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_questions_per_hour", value)
  
      @property
      @pulumi.getter(name="maxUpdatesPerHour")
      def max_updates_per_hour(self) -> Optional[pulumi.Input[int]]:
          """
          Max updates per hour.
          """
          return pulumi.get(self, "max_updates_per_hour")
  
      @max_updates_per_hour.setter
      def max_updates_per_hour(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_updates_per_hour", value)
  
      @property
      @pulumi.getter(name="maxUserConnections")
      def max_user_connections(self) -> Optional[pulumi.Input[int]]:
          """
          Max user connections.
          """
          return pulumi.get(self, "max_user_connections")
  
      @max_user_connections.setter
      def max_user_connections(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_user_connections", value)
  
  
  @pulumi.input_type
  class MdbMysqlClusterUserPermissionArgs:
      def __init__(__self__, *,
                   database_name: pulumi.Input[str],
                   roles: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          :param pulumi.Input[str] database_name: The name of the database that the permission grants access to.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] roles: List user's roles in the database.
                 Allowed roles: `ALL`,`ALTER`,`ALTER_ROUTINE`,`CREATE`,`CREATE_ROUTINE`,`CREATE_TEMPORARY_TABLES`,
                 `CREATE_VIEW`,`DELETE`,`DROP`,`EVENT`,`EXECUTE`,`INDEX`,`INSERT`,`LOCK_TABLES`,`SELECT`,`SHOW_VIEW`,`TRIGGER`,`UPDATE`.
          """
          pulumi.set(__self__, "database_name", database_name)
          if roles is not None:
              pulumi.set(__self__, "roles", roles)
  
      @property
      @pulumi.getter(name="databaseName")
      def database_name(self) -> pulumi.Input[str]:
          """
          The name of the database that the permission grants access to.
          """
          return pulumi.get(self, "database_name")
  
      @database_name.setter
      def database_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "database_name", value)
  
      @property
      @pulumi.getter
      def roles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List user's roles in the database.
          Allowed roles: `ALL`,`ALTER`,`ALTER_ROUTINE`,`CREATE`,`CREATE_ROUTINE`,`CREATE_TEMPORARY_TABLES`,
          `CREATE_VIEW`,`DELETE`,`DROP`,`EVENT`,`EXECUTE`,`INDEX`,`INSERT`,`LOCK_TABLES`,`SELECT`,`SHOW_VIEW`,`TRIGGER`,`UPDATE`.
          """
          return pulumi.get(self, "roles")
  
      @roles.setter
      def roles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "roles", value)
  
  
  @pulumi.input_type
  class MdbRedisClusterConfigArgs:
      def __init__(__self__, *,
                   password: pulumi.Input[str],
                   version: pulumi.Input[str],
                   databases: Optional[pulumi.Input[int]] = None,
                   maxmemory_policy: Optional[pulumi.Input[str]] = None,
                   notify_keyspace_events: Optional[pulumi.Input[str]] = None,
                   slowlog_log_slower_than: Optional[pulumi.Input[int]] = None,
                   slowlog_max_len: Optional[pulumi.Input[int]] = None,
                   timeout: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] password: Password for the Redis cluster.
          :param pulumi.Input[str] version: Version of Redis (5.0, 6.0 or 6.2).
          :param pulumi.Input[int] databases: Number of databases (changing requires redis-server restart).
          :param pulumi.Input[str] maxmemory_policy: Redis key eviction policy for a dataset that reaches maximum memory.
                 Can be any of the listed in [the official RedisDB documentation](https://docs.redislabs.com/latest/rs/administering/database-operations/eviction-policy/).
          :param pulumi.Input[str] notify_keyspace_events: Select the events that Redis will notify among a set of classes.
          :param pulumi.Input[int] slowlog_log_slower_than: Log slow queries below this number in microseconds.
          :param pulumi.Input[int] slowlog_max_len: Slow queries log length.
          :param pulumi.Input[int] timeout: Close the connection after a client is idle for N seconds.
          """
          pulumi.set(__self__, "password", password)
          pulumi.set(__self__, "version", version)
          if databases is not None:
              pulumi.set(__self__, "databases", databases)
          if maxmemory_policy is not None:
              pulumi.set(__self__, "maxmemory_policy", maxmemory_policy)
          if notify_keyspace_events is not None:
              pulumi.set(__self__, "notify_keyspace_events", notify_keyspace_events)
          if slowlog_log_slower_than is not None:
              pulumi.set(__self__, "slowlog_log_slower_than", slowlog_log_slower_than)
          if slowlog_max_len is not None:
              pulumi.set(__self__, "slowlog_max_len", slowlog_max_len)
          if timeout is not None:
              pulumi.set(__self__, "timeout", timeout)
  
      @property
      @pulumi.getter
      def password(self) -> pulumi.Input[str]:
          """
          Password for the Redis cluster.
          """
          return pulumi.get(self, "password")
  
      @password.setter
      def password(self, value: pulumi.Input[str]):
          pulumi.set(self, "password", value)
  
      @property
      @pulumi.getter
      def version(self) -> pulumi.Input[str]:
          """
          Version of Redis (5.0, 6.0 or 6.2).
          """
          return pulumi.get(self, "version")
  
      @version.setter
      def version(self, value: pulumi.Input[str]):
          pulumi.set(self, "version", value)
  
      @property
      @pulumi.getter
      def databases(self) -> Optional[pulumi.Input[int]]:
          """
          Number of databases (changing requires redis-server restart).
          """
          return pulumi.get(self, "databases")
  
      @databases.setter
      def databases(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "databases", value)
  
      @property
      @pulumi.getter(name="maxmemoryPolicy")
      def maxmemory_policy(self) -> Optional[pulumi.Input[str]]:
          """
          Redis key eviction policy for a dataset that reaches maximum memory.
          Can be any of the listed in [the official RedisDB documentation](https://docs.redislabs.com/latest/rs/administering/database-operations/eviction-policy/).
          """
          return pulumi.get(self, "maxmemory_policy")
  
      @maxmemory_policy.setter
      def maxmemory_policy(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "maxmemory_policy", value)
  
      @property
      @pulumi.getter(name="notifyKeyspaceEvents")
      def notify_keyspace_events(self) -> Optional[pulumi.Input[str]]:
          """
          Select the events that Redis will notify among a set of classes.
          """
          return pulumi.get(self, "notify_keyspace_events")
  
      @notify_keyspace_events.setter
      def notify_keyspace_events(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "notify_keyspace_events", value)
  
      @property
      @pulumi.getter(name="slowlogLogSlowerThan")
      def slowlog_log_slower_than(self) -> Optional[pulumi.Input[int]]:
          """
          Log slow queries below this number in microseconds.
          """
          return pulumi.get(self, "slowlog_log_slower_than")
  
      @slowlog_log_slower_than.setter
      def slowlog_log_slower_than(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "slowlog_log_slower_than", value)
  
      @property
      @pulumi.getter(name="slowlogMaxLen")
      def slowlog_max_len(self) -> Optional[pulumi.Input[int]]:
          """
          Slow queries log length.
          """
          return pulumi.get(self, "slowlog_max_len")
  
      @slowlog_max_len.setter
      def slowlog_max_len(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "slowlog_max_len", value)
  
      @property
      @pulumi.getter
      def timeout(self) -> Optional[pulumi.Input[int]]:
          """
          Close the connection after a client is idle for N seconds.
          """
          return pulumi.get(self, "timeout")
  
      @timeout.setter
      def timeout(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "timeout", value)
  
  
  @pulumi.input_type
  class MdbRedisClusterHostArgs:
      def __init__(__self__, *,
                   zone: pulumi.Input[str],
                   fqdn: Optional[pulumi.Input[str]] = None,
                   shard_name: Optional[pulumi.Input[str]] = None,
                   subnet_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] zone: The availability zone where the Redis host will be created.
                 For more information see [the official documentation](https://cloud.yandex.com/docs/overview/concepts/geo-scope).
          :param pulumi.Input[str] fqdn: The fully qualified domain name of the host.
          :param pulumi.Input[str] shard_name: The name of the shard to which the host belongs.
          :param pulumi.Input[str] subnet_id: The ID of the subnet, to which the host belongs. The subnet must
                 be a part of the network to which the cluster belongs.
          """
          pulumi.set(__self__, "zone", zone)
          if fqdn is not None:
              pulumi.set(__self__, "fqdn", fqdn)
          if shard_name is not None:
              pulumi.set(__self__, "shard_name", shard_name)
          if subnet_id is not None:
              pulumi.set(__self__, "subnet_id", subnet_id)
  
      @property
      @pulumi.getter
      def zone(self) -> pulumi.Input[str]:
          """
          The availability zone where the Redis host will be created.
          For more information see [the official documentation](https://cloud.yandex.com/docs/overview/concepts/geo-scope).
          """
          return pulumi.get(self, "zone")
  
      @zone.setter
      def zone(self, value: pulumi.Input[str]):
          pulumi.set(self, "zone", value)
  
      @property
      @pulumi.getter
      def fqdn(self) -> Optional[pulumi.Input[str]]:
          """
          The fully qualified domain name of the host.
          """
          return pulumi.get(self, "fqdn")
  
      @fqdn.setter
      def fqdn(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "fqdn", value)
  
      @property
      @pulumi.getter(name="shardName")
      def shard_name(self) -> Optional[pulumi.Input[str]]:
          """
          The name of the shard to which the host belongs.
          """
          return pulumi.get(self, "shard_name")
  
      @shard_name.setter
      def shard_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "shard_name", value)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> Optional[pulumi.Input[str]]:
          """
          The ID of the subnet, to which the host belongs. The subnet must
          be a part of the network to which the cluster belongs.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "subnet_id", value)
  
  
  @pulumi.input_type
  class MdbRedisClusterMaintenanceWindowArgs:
      def __init__(__self__, *,
                   type: pulumi.Input[str],
                   day: Optional[pulumi.Input[str]] = None,
                   hour: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] type: Type of maintenance window. Can be either `ANYTIME` or `WEEKLY`. A day and hour of window need to be specified with weekly window.
          :param pulumi.Input[str] day: Day of week for maintenance window if window type is weekly. Possible values: `MON`, `TUE`, `WED`, `THU`, `FRI`, `SAT`, `SUN`.
          :param pulumi.Input[int] hour: Hour of day in UTC time zone (1-24) for maintenance window if window type is weekly.
          """
          pulumi.set(__self__, "type", type)
          if day is not None:
              pulumi.set(__self__, "day", day)
          if hour is not None:
              pulumi.set(__self__, "hour", hour)
  
      @property
      @pulumi.getter
      def type(self) -> pulumi.Input[str]:
          """
          Type of maintenance window. Can be either `ANYTIME` or `WEEKLY`. A day and hour of window need to be specified with weekly window.
          """
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: pulumi.Input[str]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter
      def day(self) -> Optional[pulumi.Input[str]]:
          """
          Day of week for maintenance window if window type is weekly. Possible values: `MON`, `TUE`, `WED`, `THU`, `FRI`, `SAT`, `SUN`.
          """
          return pulumi.get(self, "day")
  
      @day.setter
      def day(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "day", value)
  
      @property
      @pulumi.getter
      def hour(self) -> Optional[pulumi.Input[int]]:
          """
          Hour of day in UTC time zone (1-24) for maintenance window if window type is weekly.
          """
          return pulumi.get(self, "hour")
  
      @hour.setter
      def hour(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "hour", value)
  
  
  @pulumi.input_type
  class MdbRedisClusterResourcesArgs:
      def __init__(__self__, *,
                   disk_size: pulumi.Input[int],
                   resource_preset_id: pulumi.Input[str],
                   disk_type_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[int] disk_size: Volume of the storage available to a host, in gigabytes.
          :param pulumi.Input[str] disk_type_id: Type of the storage of Redis hosts - environment default is used if missing.
          """
          pulumi.set(__self__, "disk_size", disk_size)
          pulumi.set(__self__, "resource_preset_id", resource_preset_id)
          if disk_type_id is not None:
              pulumi.set(__self__, "disk_type_id", disk_type_id)
  
      @property
      @pulumi.getter(name="diskSize")
      def disk_size(self) -> pulumi.Input[int]:
          """
          Volume of the storage available to a host, in gigabytes.
          """
          return pulumi.get(self, "disk_size")
  
      @disk_size.setter
      def disk_size(self, value: pulumi.Input[int]):
          pulumi.set(self, "disk_size", value)
  
      @property
      @pulumi.getter(name="resourcePresetId")
      def resource_preset_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "resource_preset_id")
  
      @resource_preset_id.setter
      def resource_preset_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "resource_preset_id", value)
  
      @property
      @pulumi.getter(name="diskTypeId")
      def disk_type_id(self) -> Optional[pulumi.Input[str]]:
          """
          Type of the storage of Redis hosts - environment default is used if missing.
          """
          return pulumi.get(self, "disk_type_id")
  
      @disk_type_id.setter
      def disk_type_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "disk_type_id", value)
  
  
  @pulumi.input_type
  class MdbSqlServerClusterBackupWindowStartArgs:
      def __init__(__self__, *,
                   hours: Optional[pulumi.Input[int]] = None,
                   minutes: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] hours: The hour at which backup will be started.
          :param pulumi.Input[int] minutes: The minute at which backup will be started.
          """
          if hours is not None:
              pulumi.set(__self__, "hours", hours)
          if minutes is not None:
              pulumi.set(__self__, "minutes", minutes)
  
      @property
      @pulumi.getter
      def hours(self) -> Optional[pulumi.Input[int]]:
          """
          The hour at which backup will be started.
          """
          return pulumi.get(self, "hours")
  
      @hours.setter
      def hours(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "hours", value)
  
      @property
      @pulumi.getter
      def minutes(self) -> Optional[pulumi.Input[int]]:
          """
          The minute at which backup will be started.
          """
          return pulumi.get(self, "minutes")
  
      @minutes.setter
      def minutes(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "minutes", value)
  
  
  @pulumi.input_type
  class MdbSqlServerClusterDatabaseArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str]):
          """
          :param pulumi.Input[str] name: The name of the database.
          """
          pulumi.set(__self__, "name", name)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          The name of the database.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
  
  @pulumi.input_type
  class MdbSqlServerClusterHostArgs:
      def __init__(__self__, *,
                   zone: pulumi.Input[str],
                   assign_public_ip: Optional[pulumi.Input[bool]] = None,
                   fqdn: Optional[pulumi.Input[str]] = None,
                   subnet_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] zone: The availability zone where the SQLServer host will be created.
          :param pulumi.Input[bool] assign_public_ip: Sets whether the host should get a public IP address on creation. Changing this parameter for an existing host is not supported at the moment
          :param pulumi.Input[str] fqdn: The fully qualified domain name of the host.
          :param pulumi.Input[str] subnet_id: The ID of the subnet, to which the host belongs. The subnet must be a part of the network to which the cluster belongs.
          """
          pulumi.set(__self__, "zone", zone)
          if assign_public_ip is not None:
              pulumi.set(__self__, "assign_public_ip", assign_public_ip)
          if fqdn is not None:
              pulumi.set(__self__, "fqdn", fqdn)
          if subnet_id is not None:
              pulumi.set(__self__, "subnet_id", subnet_id)
  
      @property
      @pulumi.getter
      def zone(self) -> pulumi.Input[str]:
          """
          The availability zone where the SQLServer host will be created.
          """
          return pulumi.get(self, "zone")
  
      @zone.setter
      def zone(self, value: pulumi.Input[str]):
          pulumi.set(self, "zone", value)
  
      @property
      @pulumi.getter(name="assignPublicIp")
      def assign_public_ip(self) -> Optional[pulumi.Input[bool]]:
          """
          Sets whether the host should get a public IP address on creation. Changing this parameter for an existing host is not supported at the moment
          """
          return pulumi.get(self, "assign_public_ip")
  
      @assign_public_ip.setter
      def assign_public_ip(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "assign_public_ip", value)
  
      @property
      @pulumi.getter
      def fqdn(self) -> Optional[pulumi.Input[str]]:
          """
          The fully qualified domain name of the host.
          """
          return pulumi.get(self, "fqdn")
  
      @fqdn.setter
      def fqdn(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "fqdn", value)
  
      @property
      @pulumi.getter(name="subnetId")
      def subnet_id(self) -> Optional[pulumi.Input[str]]:
          """
          The ID of the subnet, to which the host belongs. The subnet must be a part of the network to which the cluster belongs.
          """
          return pulumi.get(self, "subnet_id")
  
      @subnet_id.setter
      def subnet_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "subnet_id", value)
  
  
  @pulumi.input_type
  class MdbSqlServerClusterResourcesArgs:
      def __init__(__self__, *,
                   disk_size: pulumi.Input[int],
                   disk_type_id: pulumi.Input[str],
                   resource_preset_id: pulumi.Input[str]):
          """
          :param pulumi.Input[int] disk_size: Volume of the storage available to a SQLServer host, in gigabytes.
          :param pulumi.Input[str] disk_type_id: Type of the storage of SQLServer hosts.
          """
          pulumi.set(__self__, "disk_size", disk_size)
          pulumi.set(__self__, "disk_type_id", disk_type_id)
          pulumi.set(__self__, "resource_preset_id", resource_preset_id)
  
      @property
      @pulumi.getter(name="diskSize")
      def disk_size(self) -> pulumi.Input[int]:
          """
          Volume of the storage available to a SQLServer host, in gigabytes.
          """
          return pulumi.get(self, "disk_size")
  
      @disk_size.setter
      def disk_size(self, value: pulumi.Input[int]):
          pulumi.set(self, "disk_size", value)
  
      @property
      @pulumi.getter(name="diskTypeId")
      def disk_type_id(self) -> pulumi.Input[str]:
          """
          Type of the storage of SQLServer hosts.
          """
          return pulumi.get(self, "disk_type_id")
  
      @disk_type_id.setter
      def disk_type_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "disk_type_id", value)
  
      @property
      @pulumi.getter(name="resourcePresetId")
      def resource_preset_id(self) -> pulumi.Input[str]:
          return pulumi.get(self, "resource_preset_id")
  
      @resource_preset_id.setter
      def resource_preset_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "resource_preset_id", value)
  
  
  @pulumi.input_type
  class MdbSqlServerClusterUserArgs:
      def __init__(__self__, *,
                   name: pulumi.Input[str],
                   password: pulumi.Input[str],
                   permissions: Optional[pulumi.Input[Sequence[pulumi.Input['MdbSqlServerClusterUserPermissionArgs']]]] = None):
          """
          :param pulumi.Input[str] name: The name of the database.
          :param pulumi.Input[str] password: The password of the user.
          :param pulumi.Input[Sequence[pulumi.Input['MdbSqlServerClusterUserPermissionArgs']]] permissions: Set of permissions granted to the user. The structure is documented below.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "password", password)
          if permissions is not None:
              pulumi.set(__self__, "permissions", permissions)
  
      @property
      @pulumi.getter
      def name(self) -> pulumi.Input[str]:
          """
          The name of the database.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: pulumi.Input[str]):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def password(self) -> pulumi.Input[str]:
          """
          The password of the user.
          """
          return pulumi.get(self, "password")
  
      @password.setter
      def password(self, value: pulumi.Input[str]):
          pulumi.set(self, "password", value)
  
      @property
      @pulumi.getter
      def permissions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MdbSqlServerClusterUserPermissionArgs']]]]:
          """
          Set of permissions granted to the user. The structure is documented below.
          """
          return pulumi.get(self, "permissions")
  
      @permissions.setter
      def permissions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MdbSqlServerClusterUserPermissionArgs']]]]):
          pulumi.set(self, "permissions", value)
  
  
  @pulumi.input_type
  class MdbSqlServerClusterUserPermissionArgs:
      def __init__(__self__, *,
                   database_name: pulumi.Input[str],
                   roles: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          :param pulumi.Input[str] database_name: The name of the database that the permission grants access to.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] roles: List user's roles in the database.
                 Allowed roles: `OWNER`, `SECURITYADMIN`, `ACCESSADMIN`, `BACKUPOPERATOR`, `DDLADMIN`, `DATAWRITER`, `DATAREADER`, `DENYDATAWRITER`, `DENYDATAREADER`.
          """
          pulumi.set(__self__, "database_name", database_name)
          if roles is not None:
              pulumi.set(__self__, "roles", roles)
  
      @property
      @pulumi.getter(name="databaseName")
      def database_name(self) -> pulumi.Input[str]:
          """
          The name of the database that the permission grants access to.
          """
          return pulumi.get(self, "database_name")
  
      @database_name.setter
      def database_name(self, value: pulumi.Input[str]):
          pulumi.set(self, "database_name", value)
  
      @property
      @pulumi.getter
      def roles(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          List user's roles in the database.
          Allowed roles: `OWNER`, `SECURITYADMIN`, `ACCESSADMIN`, `BACKUPOPERATOR`, `DDLADMIN`, `DATAWRITER`, `DATAREADER`, `DENYDATAWRITER`, `DENYDATAREADER`.
          """
          return pulumi.get(self, "roles")
  
      @roles.setter
      def roles(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "roles", value)
  
  
  @pulumi.input_type
  class StorageBucketCorsRuleArgs:
      def __init__(__self__, *,
                   allowed_methods: pulumi.Input[Sequence[pulumi.Input[str]]],
                   allowed_origins: pulumi.Input[Sequence[pulumi.Input[str]]],
                   allowed_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   expose_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   max_age_seconds: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_methods: Specifies which methods are allowed. Can be `GET`, `PUT`, `POST`, `DELETE` or `HEAD`.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_origins: Specifies which origins are allowed.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_headers: Specifies which headers are allowed.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] expose_headers: Specifies expose header in the response.
          :param pulumi.Input[int] max_age_seconds: Specifies time in seconds that browser can cache the response for a preflight request.
          """
          pulumi.set(__self__, "allowed_methods", allowed_methods)
          pulumi.set(__self__, "allowed_origins", allowed_origins)
          if allowed_headers is not None:
              pulumi.set(__self__, "allowed_headers", allowed_headers)
          if expose_headers is not None:
              pulumi.set(__self__, "expose_headers", expose_headers)
          if max_age_seconds is not None:
              pulumi.set(__self__, "max_age_seconds", max_age_seconds)
  
      @property
      @pulumi.getter(name="allowedMethods")
      def allowed_methods(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          """
          Specifies which methods are allowed. Can be `GET`, `PUT`, `POST`, `DELETE` or `HEAD`.
          """
          return pulumi.get(self, "allowed_methods")
  
      @allowed_methods.setter
      def allowed_methods(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "allowed_methods", value)
  
      @property
      @pulumi.getter(name="allowedOrigins")
      def allowed_origins(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          """
          Specifies which origins are allowed.
          """
          return pulumi.get(self, "allowed_origins")
  
      @allowed_origins.setter
      def allowed_origins(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "allowed_origins", value)
  
      @property
      @pulumi.getter(name="allowedHeaders")
      def allowed_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          Specifies which headers are allowed.
          """
          return pulumi.get(self, "allowed_headers")
  
      @allowed_headers.setter
      def allowed_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "allowed_headers", value)
  
      @property
      @pulumi.getter(name="exposeHeaders")
      def expose_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          Specifies expose header in the response.
          """
          return pulumi.get(self, "expose_headers")
  
      @expose_headers.setter
      def expose_headers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "expose_headers", value)
  
      @property
      @pulumi.getter(name="maxAgeSeconds")
      def max_age_seconds(self) -> Optional[pulumi.Input[int]]:
          """
          Specifies time in seconds that browser can cache the response for a preflight request.
          """
          return pulumi.get(self, "max_age_seconds")
  
      @max_age_seconds.setter
      def max_age_seconds(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "max_age_seconds", value)
  
  
  @pulumi.input_type
  class StorageBucketGrantArgs:
      def __init__(__self__, *,
                   permissions: pulumi.Input[Sequence[pulumi.Input[str]]],
                   type: pulumi.Input[str],
                   id: Optional[pulumi.Input[str]] = None,
                   uri: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] id: Unique identifier for the rule. Must be less than or equal to 255 characters in length.
          """
          pulumi.set(__self__, "permissions", permissions)
          pulumi.set(__self__, "type", type)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if uri is not None:
              pulumi.set(__self__, "uri", uri)
  
      @property
      @pulumi.getter
      def permissions(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
          return pulumi.get(self, "permissions")
  
      @permissions.setter
      def permissions(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
          pulumi.set(self, "permissions", value)
  
      @property
      @pulumi.getter
      def type(self) -> pulumi.Input[str]:
          return pulumi.get(self, "type")
  
      @type.setter
      def type(self, value: pulumi.Input[str]):
          pulumi.set(self, "type", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Unique identifier for the rule. Must be less than or equal to 255 characters in length.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def uri(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "uri")
  
      @uri.setter
      def uri(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "uri", value)
  
  
  @pulumi.input_type
  class StorageBucketLifecycleRuleArgs:
      def __init__(__self__, *,
                   enabled: pulumi.Input[bool],
                   abort_incomplete_multipart_upload_days: Optional[pulumi.Input[int]] = None,
                   expiration: Optional[pulumi.Input['StorageBucketLifecycleRuleExpirationArgs']] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   noncurrent_version_expiration: Optional[pulumi.Input['StorageBucketLifecycleRuleNoncurrentVersionExpirationArgs']] = None,
                   noncurrent_version_transitions: Optional[pulumi.Input[Sequence[pulumi.Input['StorageBucketLifecycleRuleNoncurrentVersionTransitionArgs']]]] = None,
                   prefix: Optional[pulumi.Input[str]] = None,
                   transitions: Optional[pulumi.Input[Sequence[pulumi.Input['StorageBucketLifecycleRuleTransitionArgs']]]] = None):
          """
          :param pulumi.Input[bool] enabled: Specifies lifecycle rule status.
          :param pulumi.Input[int] abort_incomplete_multipart_upload_days: Specifies the number of days after initiating a multipart upload when the multipart upload must be completed.
          :param pulumi.Input['StorageBucketLifecycleRuleExpirationArgs'] expiration: Specifies a period in the object's expire (documented below).
          :param pulumi.Input[str] id: Unique identifier for the rule. Must be less than or equal to 255 characters in length.
          :param pulumi.Input['StorageBucketLifecycleRuleNoncurrentVersionExpirationArgs'] noncurrent_version_expiration: Specifies when noncurrent object versions expire (documented below).
          :param pulumi.Input[Sequence[pulumi.Input['StorageBucketLifecycleRuleNoncurrentVersionTransitionArgs']]] noncurrent_version_transitions: Specifies when noncurrent object versions transitions (documented below).
          :param pulumi.Input[str] prefix: Object key prefix identifying one or more objects to which the rule applies.
          :param pulumi.Input[Sequence[pulumi.Input['StorageBucketLifecycleRuleTransitionArgs']]] transitions: Specifies a period in the object's transitions (documented below).
          """
          pulumi.set(__self__, "enabled", enabled)
          if abort_incomplete_multipart_upload_days is not None:
              pulumi.set(__self__, "abort_incomplete_multipart_upload_days", abort_incomplete_multipart_upload_days)
          if expiration is not None:
              pulumi.set(__self__, "expiration", expiration)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if noncurrent_version_expiration is not None:
              pulumi.set(__self__, "noncurrent_version_expiration", noncurrent_version_expiration)
          if noncurrent_version_transitions is not None:
              pulumi.set(__self__, "noncurrent_version_transitions", noncurrent_version_transitions)
          if prefix is not None:
              pulumi.set(__self__, "prefix", prefix)
          if transitions is not None:
              pulumi.set(__self__, "transitions", transitions)
  
      @property
      @pulumi.getter
      def enabled(self) -> pulumi.Input[bool]:
          """
          Specifies lifecycle rule status.
          """
          return pulumi.get(self, "enabled")
  
      @enabled.setter
      def enabled(self, value: pulumi.Input[bool]):
          pulumi.set(self, "enabled", value)
  
      @property
      @pulumi.getter(name="abortIncompleteMultipartUploadDays")
      def abort_incomplete_multipart_upload_days(self) -> Optional[pulumi.Input[int]]:
          """
          Specifies the number of days after initiating a multipart upload when the multipart upload must be completed.
          """
          return pulumi.get(self, "abort_incomplete_multipart_upload_days")
  
      @abort_incomplete_multipart_upload_days.setter
      def abort_incomplete_multipart_upload_days(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "abort_incomplete_multipart_upload_days", value)
  
      @property
      @pulumi.getter
      def expiration(self) -> Optional[pulumi.Input['StorageBucketLifecycleRuleExpirationArgs']]:
          """
          Specifies a period in the object's expire (documented below).
          """
          return pulumi.get(self, "expiration")
  
      @expiration.setter
      def expiration(self, value: Optional[pulumi.Input['StorageBucketLifecycleRuleExpirationArgs']]):
          pulumi.set(self, "expiration", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Unique identifier for the rule. Must be less than or equal to 255 characters in length.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter(name="noncurrentVersionExpiration")
      def noncurrent_version_expiration(self) -> Optional[pulumi.Input['StorageBucketLifecycleRuleNoncurrentVersionExpirationArgs']]:
          """
          Specifies when noncurrent object versions expire (documented below).
          """
          return pulumi.get(self, "noncurrent_version_expiration")
  
      @noncurrent_version_expiration.setter
      def noncurrent_version_expiration(self, value: Optional[pulumi.Input['StorageBucketLifecycleRuleNoncurrentVersionExpirationArgs']]):
          pulumi.set(self, "noncurrent_version_expiration", value)
  
      @property
      @pulumi.getter(name="noncurrentVersionTransitions")
      def noncurrent_version_transitions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageBucketLifecycleRuleNoncurrentVersionTransitionArgs']]]]:
          """
          Specifies when noncurrent object versions transitions (documented below).
          """
          return pulumi.get(self, "noncurrent_version_transitions")
  
      @noncurrent_version_transitions.setter
      def noncurrent_version_transitions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageBucketLifecycleRuleNoncurrentVersionTransitionArgs']]]]):
          pulumi.set(self, "noncurrent_version_transitions", value)
  
      @property
      @pulumi.getter
      def prefix(self) -> Optional[pulumi.Input[str]]:
          """
          Object key prefix identifying one or more objects to which the rule applies.
          """
          return pulumi.get(self, "prefix")
  
      @prefix.setter
      def prefix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "prefix", value)
  
      @property
      @pulumi.getter
      def transitions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['StorageBucketLifecycleRuleTransitionArgs']]]]:
          """
          Specifies a period in the object's transitions (documented below).
          """
          return pulumi.get(self, "transitions")
  
      @transitions.setter
      def transitions(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['StorageBucketLifecycleRuleTransitionArgs']]]]):
          pulumi.set(self, "transitions", value)
  
  
  @pulumi.input_type
  class StorageBucketLifecycleRuleExpirationArgs:
      def __init__(__self__, *,
                   date: Optional[pulumi.Input[str]] = None,
                   days: Optional[pulumi.Input[int]] = None,
                   expired_object_delete_marker: Optional[pulumi.Input[bool]] = None):
          """
          :param pulumi.Input[str] date: Specifies the date after which you want the corresponding action to take effect.
          :param pulumi.Input[int] days: Specifies the number of days after object creation when the specific rule action takes effect.
          :param pulumi.Input[bool] expired_object_delete_marker: On a versioned bucket (versioning-enabled or versioning-suspended bucket), you can add this element in the lifecycle configuration to direct Object Storage to delete expired object delete markers.
          """
          if date is not None:
              pulumi.set(__self__, "date", date)
          if days is not None:
              pulumi.set(__self__, "days", days)
          if expired_object_delete_marker is not None:
              pulumi.set(__self__, "expired_object_delete_marker", expired_object_delete_marker)
  
      @property
      @pulumi.getter
      def date(self) -> Optional[pulumi.Input[str]]:
          """
          Specifies the date after which you want the corresponding action to take effect.
          """
          return pulumi.get(self, "date")
  
      @date.setter
      def date(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "date", value)
  
      @property
      @pulumi.getter
      def days(self) -> Optional[pulumi.Input[int]]:
          """
          Specifies the number of days after object creation when the specific rule action takes effect.
          """
          return pulumi.get(self, "days")
  
      @days.setter
      def days(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "days", value)
  
      @property
      @pulumi.getter(name="expiredObjectDeleteMarker")
      def expired_object_delete_marker(self) -> Optional[pulumi.Input[bool]]:
          """
          On a versioned bucket (versioning-enabled or versioning-suspended bucket), you can add this element in the lifecycle configuration to direct Object Storage to delete expired object delete markers.
          """
          return pulumi.get(self, "expired_object_delete_marker")
  
      @expired_object_delete_marker.setter
      def expired_object_delete_marker(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "expired_object_delete_marker", value)
  
  
  @pulumi.input_type
  class StorageBucketLifecycleRuleNoncurrentVersionExpirationArgs:
      def __init__(__self__, *,
                   days: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[int] days: Specifies the number of days noncurrent object versions expire.
          """
          if days is not None:
              pulumi.set(__self__, "days", days)
  
      @property
      @pulumi.getter
      def days(self) -> Optional[pulumi.Input[int]]:
          """
          Specifies the number of days noncurrent object versions expire.
          """
          return pulumi.get(self, "days")
  
      @days.setter
      def days(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "days", value)
  
  
  @pulumi.input_type
  class StorageBucketLifecycleRuleNoncurrentVersionTransitionArgs:
      def __init__(__self__, *,
                   storage_class: pulumi.Input[str],
                   days: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] storage_class: Specifies the storage class to which you want the noncurrent object versions to transition. Can only be `COLD` or `STANDARD_IA`.
          :param pulumi.Input[int] days: Specifies the number of days noncurrent object versions transition.
          """
          pulumi.set(__self__, "storage_class", storage_class)
          if days is not None:
              pulumi.set(__self__, "days", days)
  
      @property
      @pulumi.getter(name="storageClass")
      def storage_class(self) -> pulumi.Input[str]:
          """
          Specifies the storage class to which you want the noncurrent object versions to transition. Can only be `COLD` or `STANDARD_IA`.
          """
          return pulumi.get(self, "storage_class")
  
      @storage_class.setter
      def storage_class(self, value: pulumi.Input[str]):
          pulumi.set(self, "storage_class", value)
  
      @property
      @pulumi.getter
      def days(self) -> Optional[pulumi.Input[int]]:
          """
          Specifies the number of days noncurrent object versions transition.
          """
          return pulumi.get(self, "days")
  
      @days.setter
      def days(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "days", value)
  
  
  @pulumi.input_type
  class StorageBucketLifecycleRuleTransitionArgs:
      def __init__(__self__, *,
                   storage_class: pulumi.Input[str],
                   date: Optional[pulumi.Input[str]] = None,
                   days: Optional[pulumi.Input[int]] = None):
          """
          :param pulumi.Input[str] storage_class: Specifies the storage class to which you want the object to transition. Can only be `COLD` or `STANDARD_IA`.
          :param pulumi.Input[str] date: Specifies the date after which you want the corresponding action to take effect.
          :param pulumi.Input[int] days: Specifies the number of days after object creation when the specific rule action takes effect.
          """
          pulumi.set(__self__, "storage_class", storage_class)
          if date is not None:
              pulumi.set(__self__, "date", date)
          if days is not None:
              pulumi.set(__self__, "days", days)
  
      @property
      @pulumi.getter(name="storageClass")
      def storage_class(self) -> pulumi.Input[str]:
          """
          Specifies the storage class to which you want the object to transition. Can only be `COLD` or `STANDARD_IA`.
          """
          return pulumi.get(self, "storage_class")
  
      @storage_class.setter
      def storage_class(self, value: pulumi.Input[str]):
          pulumi.set(self, "storage_class", value)
  
      @property
      @pulumi.getter
      def date(self) -> Optional[pulumi.Input[str]]:
          """
          Specifies the date after which you want the corresponding action to take effect.
          """
          return pulumi.get(self, "date")
  
      @date.setter
      def date(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "date", value)
  
      @property
      @pulumi.getter
      def days(self) -> Optional[pulumi.Input[int]]:
          """
          Specifies the number of days after object creation when the specific rule action takes effect.
          """
          return pulumi.get(self, "days")
  
      @days.setter
      def days(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "days", value)
  
  
  @pulumi.input_type
  class StorageBucketLoggingArgs:
      def __init__(__self__, *,
                   target_bucket: pulumi.Input[str],
                   target_prefix: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] target_bucket: The name of the bucket that will receive the log objects.
          :param pulumi.Input[str] target_prefix: To specify a key prefix for log objects.
          """
          pulumi.set(__self__, "target_bucket", target_bucket)
          if target_prefix is not None:
              pulumi.set(__self__, "target_prefix", target_prefix)
  
      @property
      @pulumi.getter(name="targetBucket")
      def target_bucket(self) -> pulumi.Input[str]:
          """
          The name of the bucket that will receive the log objects.
          """
          return pulumi.get(self, "target_bucket")
  
      @target_bucket.setter
      def target_bucket(self, value: pulumi.Input[str]):
          pulumi.set(self, "target_bucket", value)
  
      @property
      @pulumi.getter(name="targetPrefix")
      def target_prefix(self) -> Optional[pulumi.Input[str]]:
          """
          To specify a key prefix for log objects.
          """
          return pulumi.get(self, "target_prefix")
  
      @target_prefix.setter
      def target_prefix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "target_prefix", value)
  
  
  @pulumi.input_type
  class StorageBucketServerSideEncryptionConfigurationArgs:
      def __init__(__self__, *,
                   rule: pulumi.Input['StorageBucketServerSideEncryptionConfigurationRuleArgs']):
          """
          :param pulumi.Input['StorageBucketServerSideEncryptionConfigurationRuleArgs'] rule: A single object for server-side encryption by default configuration. (documented below)
          """
          pulumi.set(__self__, "rule", rule)
  
      @property
      @pulumi.getter
      def rule(self) -> pulumi.Input['StorageBucketServerSideEncryptionConfigurationRuleArgs']:
          """
          A single object for server-side encryption by default configuration. (documented below)
          """
          return pulumi.get(self, "rule")
  
      @rule.setter
      def rule(self, value: pulumi.Input['StorageBucketServerSideEncryptionConfigurationRuleArgs']):
          pulumi.set(self, "rule", value)
  
  
  @pulumi.input_type
  class StorageBucketServerSideEncryptionConfigurationRuleArgs:
      def __init__(__self__, *,
                   apply_server_side_encryption_by_default: pulumi.Input['StorageBucketServerSideEncryptionConfigurationRuleApplyServerSideEncryptionByDefaultArgs']):
          """
          :param pulumi.Input['StorageBucketServerSideEncryptionConfigurationRuleApplyServerSideEncryptionByDefaultArgs'] apply_server_side_encryption_by_default: A single object for setting server-side encryption by default. (documented below)
          """
          pulumi.set(__self__, "apply_server_side_encryption_by_default", apply_server_side_encryption_by_default)
  
      @property
      @pulumi.getter(name="applyServerSideEncryptionByDefault")
      def apply_server_side_encryption_by_default(self) -> pulumi.Input['StorageBucketServerSideEncryptionConfigurationRuleApplyServerSideEncryptionByDefaultArgs']:
          """
          A single object for setting server-side encryption by default. (documented below)
          """
          return pulumi.get(self, "apply_server_side_encryption_by_default")
  
      @apply_server_side_encryption_by_default.setter
      def apply_server_side_encryption_by_default(self, value: pulumi.Input['StorageBucketServerSideEncryptionConfigurationRuleApplyServerSideEncryptionByDefaultArgs']):
          pulumi.set(self, "apply_server_side_encryption_by_default", value)
  
  
  @pulumi.input_type
  class StorageBucketServerSideEncryptionConfigurationRuleApplyServerSideEncryptionByDefaultArgs:
      def __init__(__self__, *,
                   kms_master_key_id: pulumi.Input[str],
                   sse_algorithm: pulumi.Input[str]):
          """
          :param pulumi.Input[str] kms_master_key_id: The KMS master key ID used for the SSE-KMS encryption.
          :param pulumi.Input[str] sse_algorithm: The server-side encryption algorithm to use. Single valid value is `aws:kms`
          """
          pulumi.set(__self__, "kms_master_key_id", kms_master_key_id)
          pulumi.set(__self__, "sse_algorithm", sse_algorithm)
  
      @property
      @pulumi.getter(name="kmsMasterKeyId")
      def kms_master_key_id(self) -> pulumi.Input[str]:
          """
          The KMS master key ID used for the SSE-KMS encryption.
          """
          return pulumi.get(self, "kms_master_key_id")
  
      @kms_master_key_id.setter
      def kms_master_key_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "kms_master_key_id", value)
  
      @property
      @pulumi.getter(name="sseAlgorithm")
      def sse_algorithm(self) -> pulumi.Input[str]:
          """
          The server-side encryption algorithm to use. Single valid value is `aws:kms`
          """
          return pulumi.get(self, "sse_algorithm")
  
      @sse_algorithm.setter
      def sse_algorithm(self, value: pulumi.Input[str]):
          pulumi.set(self, "sse_algorithm", value)
  
  
  @pulumi.input_type
  class StorageBucketVersioningArgs:
      def __init__(__self__, *,
                   enabled: Optional[pulumi.Input[bool]] = None):
          """
          :param pulumi.Input[bool] enabled: Enable versioning. Once you version-enable a bucket, it can never return to an unversioned state. You can, however, suspend versioning on that bucket.
          """
          if enabled is not None:
              pulumi.set(__self__, "enabled", enabled)
  
      @property
      @pulumi.getter
      def enabled(self) -> Optional[pulumi.Input[bool]]:
          """
          Enable versioning. Once you version-enable a bucket, it can never return to an unversioned state. You can, however, suspend versioning on that bucket.
          """
          return pulumi.get(self, "enabled")
  
      @enabled.setter
      def enabled(self, value: Optional[pulumi.Input[bool]]):
          pulumi.set(self, "enabled", value)
  
  
  @pulumi.input_type
  class StorageBucketWebsiteArgs:
      def __init__(__self__, *,
                   error_document: Optional[pulumi.Input[str]] = None,
                   index_document: Optional[pulumi.Input[str]] = None,
                   redirect_all_requests_to: Optional[pulumi.Input[str]] = None,
                   routing_rules: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] error_document: An absolute path to the document to return in case of a 4XX error.
          :param pulumi.Input[str] index_document: Storage returns this index document when requests are made to the root domain or any of the subfolders.
          :param pulumi.Input[str] redirect_all_requests_to: A hostname to redirect all website requests for this bucket to. Hostname can optionally be prefixed with a protocol (`http://` or `https://`) to use when redirecting requests. The default is the protocol that is used in the original request.
          :param pulumi.Input[str] routing_rules: A json array containing [routing rules](https://cloud.yandex.com/docs/storage/s3/api-ref/hosting/upload#request-scheme) describing redirect behavior and when redirects are applied.
          """
          if error_document is not None:
              pulumi.set(__self__, "error_document", error_document)
          if index_document is not None:
              pulumi.set(__self__, "index_document", index_document)
          if redirect_all_requests_to is not None:
              pulumi.set(__self__, "redirect_all_requests_to", redirect_all_requests_to)
          if routing_rules is not None:
              pulumi.set(__self__, "routing_rules", routing_rules)
  
      @property
      @pulumi.getter(name="errorDocument")
      def error_document(self) -> Optional[pulumi.Input[str]]:
          """
          An absolute path to the document to return in case of a 4XX error.
          """
          return pulumi.get(self, "error_document")
  
      @error_document.setter
      def error_document(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "error_document", value)
  
      @property
      @pulumi.getter(name="indexDocument")
      def index_document(self) -> Optional[pulumi.Input[str]]:
          """
          Storage returns this index document when requests are made to the root domain or any of the subfolders.
          """
          return pulumi.get(self, "index_document")
  
      @index_document.setter
      def index_document(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "index_document", value)
  
      @property
      @pulumi.getter(name="redirectAllRequestsTo")
      def redirect_all_requests_to(self) -> Optional[pulumi.Input[str]]:
          """
          A hostname to redirect all website requests for this bucket to. Hostname can optionally be prefixed with a protocol (`http://` or `https://`) to use when redirecting requests. The default is the protocol that is used in the original request.
          """
          return pulumi.get(self, "redirect_all_requests_to")
  
      @redirect_all_requests_to.setter
      def redirect_all_requests_to(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "redirect_all_requests_to", value)
  
      @property
      @pulumi.getter(name="routingRules")
      def routing_rules(self) -> Optional[pulumi.Input[str]]:
          """
          A json array containing [routing rules](https://cloud.yandex.com/docs/storage/s3/api-ref/hosting/upload#request-scheme) describing redirect behavior and when redirects are applied.
          """
          return pulumi.get(self, "routing_rules")
  
      @routing_rules.setter
      def routing_rules(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "routing_rules", value)
  
  
  @pulumi.input_type
  class VpcAddressExternalIpv4AddressArgs:
      def __init__(__self__, *,
                   address: Optional[pulumi.Input[str]] = None,
                   ddos_protection_provider: Optional[pulumi.Input[str]] = None,
                   outgoing_smtp_capability: Optional[pulumi.Input[str]] = None,
                   zone_id: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] address: - Desired IP.
          :param pulumi.Input[str] ddos_protection_provider: Enable DDOS protection. Possible values are: "qrator"
          :param pulumi.Input[str] outgoing_smtp_capability: Wanted outgoing smtp capability.
          :param pulumi.Input[str] zone_id: - Zone for allocating address.
          """
          if address is not None:
              pulumi.set(__self__, "address", address)
          if ddos_protection_provider is not None:
              pulumi.set(__self__, "ddos_protection_provider", ddos_protection_provider)
          if outgoing_smtp_capability is not None:
              pulumi.set(__self__, "outgoing_smtp_capability", outgoing_smtp_capability)
          if zone_id is not None:
              pulumi.set(__self__, "zone_id", zone_id)
  
      @property
      @pulumi.getter
      def address(self) -> Optional[pulumi.Input[str]]:
          """
          - Desired IP.
          """
          return pulumi.get(self, "address")
  
      @address.setter
      def address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "address", value)
  
      @property
      @pulumi.getter(name="ddosProtectionProvider")
      def ddos_protection_provider(self) -> Optional[pulumi.Input[str]]:
          """
          Enable DDOS protection. Possible values are: "qrator"
          """
          return pulumi.get(self, "ddos_protection_provider")
  
      @ddos_protection_provider.setter
      def ddos_protection_provider(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "ddos_protection_provider", value)
  
      @property
      @pulumi.getter(name="outgoingSmtpCapability")
      def outgoing_smtp_capability(self) -> Optional[pulumi.Input[str]]:
          """
          Wanted outgoing smtp capability.
          """
          return pulumi.get(self, "outgoing_smtp_capability")
  
      @outgoing_smtp_capability.setter
      def outgoing_smtp_capability(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "outgoing_smtp_capability", value)
  
      @property
      @pulumi.getter(name="zoneId")
      def zone_id(self) -> Optional[pulumi.Input[str]]:
          """
          - Zone for allocating address.
          """
          return pulumi.get(self, "zone_id")
  
      @zone_id.setter
      def zone_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "zone_id", value)
  
  
  @pulumi.input_type
  class VpcDefaultSecurityGroupEgressArgs:
      def __init__(__self__, *,
                   protocol: pulumi.Input[str],
                   description: Optional[pulumi.Input[str]] = None,
                   from_port: Optional[pulumi.Input[int]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   port: Optional[pulumi.Input[int]] = None,
                   predefined_target: Optional[pulumi.Input[str]] = None,
                   security_group_id: Optional[pulumi.Input[str]] = None,
                   to_port: Optional[pulumi.Input[int]] = None,
                   v4_cidr_blocks: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   v6_cidr_blocks: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          :param pulumi.Input[str] description: Description of the security group.
          :param pulumi.Input[str] id: Id of the security group.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: Labels to assign to this security group.
          """
          pulumi.set(__self__, "protocol", protocol)
          if description is not None:
              pulumi.set(__self__, "description", description)
          if from_port is not None:
              pulumi.set(__self__, "from_port", from_port)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if labels is not None:
              pulumi.set(__self__, "labels", labels)
          if port is not None:
              pulumi.set(__self__, "port", port)
          if predefined_target is not None:
              pulumi.set(__self__, "predefined_target", predefined_target)
          if security_group_id is not None:
              pulumi.set(__self__, "security_group_id", security_group_id)
          if to_port is not None:
              pulumi.set(__self__, "to_port", to_port)
          if v4_cidr_blocks is not None:
              pulumi.set(__self__, "v4_cidr_blocks", v4_cidr_blocks)
          if v6_cidr_blocks is not None:
              pulumi.set(__self__, "v6_cidr_blocks", v6_cidr_blocks)
  
      @property
      @pulumi.getter
      def protocol(self) -> pulumi.Input[str]:
          return pulumi.get(self, "protocol")
  
      @protocol.setter
      def protocol(self, value: pulumi.Input[str]):
          pulumi.set(self, "protocol", value)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[pulumi.Input[str]]:
          """
          Description of the security group.
          """
          return pulumi.get(self, "description")
  
      @description.setter
      def description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "description", value)
  
      @property
      @pulumi.getter(name="fromPort")
      def from_port(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "from_port")
  
      @from_port.setter
      def from_port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "from_port", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Id of the security group.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Labels to assign to this security group.
          """
          return pulumi.get(self, "labels")
  
      @labels.setter
      def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "labels", value)
  
      @property
      @pulumi.getter
      def port(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "port", value)
  
      @property
      @pulumi.getter(name="predefinedTarget")
      def predefined_target(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "predefined_target")
  
      @predefined_target.setter
      def predefined_target(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "predefined_target", value)
  
      @property
      @pulumi.getter(name="securityGroupId")
      def security_group_id(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "security_group_id")
  
      @security_group_id.setter
      def security_group_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "security_group_id", value)
  
      @property
      @pulumi.getter(name="toPort")
      def to_port(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "to_port")
  
      @to_port.setter
      def to_port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "to_port", value)
  
      @property
      @pulumi.getter(name="v4CidrBlocks")
      def v4_cidr_blocks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          return pulumi.get(self, "v4_cidr_blocks")
  
      @v4_cidr_blocks.setter
      def v4_cidr_blocks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "v4_cidr_blocks", value)
  
      @property
      @pulumi.getter(name="v6CidrBlocks")
      def v6_cidr_blocks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          return pulumi.get(self, "v6_cidr_blocks")
  
      @v6_cidr_blocks.setter
      def v6_cidr_blocks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "v6_cidr_blocks", value)
  
  
  @pulumi.input_type
  class VpcDefaultSecurityGroupIngressArgs:
      def __init__(__self__, *,
                   protocol: pulumi.Input[str],
                   description: Optional[pulumi.Input[str]] = None,
                   from_port: Optional[pulumi.Input[int]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   port: Optional[pulumi.Input[int]] = None,
                   predefined_target: Optional[pulumi.Input[str]] = None,
                   security_group_id: Optional[pulumi.Input[str]] = None,
                   to_port: Optional[pulumi.Input[int]] = None,
                   v4_cidr_blocks: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   v6_cidr_blocks: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          :param pulumi.Input[str] description: Description of the security group.
          :param pulumi.Input[str] id: Id of the security group.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: Labels to assign to this security group.
          """
          pulumi.set(__self__, "protocol", protocol)
          if description is not None:
              pulumi.set(__self__, "description", description)
          if from_port is not None:
              pulumi.set(__self__, "from_port", from_port)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if labels is not None:
              pulumi.set(__self__, "labels", labels)
          if port is not None:
              pulumi.set(__self__, "port", port)
          if predefined_target is not None:
              pulumi.set(__self__, "predefined_target", predefined_target)
          if security_group_id is not None:
              pulumi.set(__self__, "security_group_id", security_group_id)
          if to_port is not None:
              pulumi.set(__self__, "to_port", to_port)
          if v4_cidr_blocks is not None:
              pulumi.set(__self__, "v4_cidr_blocks", v4_cidr_blocks)
          if v6_cidr_blocks is not None:
              pulumi.set(__self__, "v6_cidr_blocks", v6_cidr_blocks)
  
      @property
      @pulumi.getter
      def protocol(self) -> pulumi.Input[str]:
          return pulumi.get(self, "protocol")
  
      @protocol.setter
      def protocol(self, value: pulumi.Input[str]):
          pulumi.set(self, "protocol", value)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[pulumi.Input[str]]:
          """
          Description of the security group.
          """
          return pulumi.get(self, "description")
  
      @description.setter
      def description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "description", value)
  
      @property
      @pulumi.getter(name="fromPort")
      def from_port(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "from_port")
  
      @from_port.setter
      def from_port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "from_port", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Id of the security group.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Labels to assign to this security group.
          """
          return pulumi.get(self, "labels")
  
      @labels.setter
      def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "labels", value)
  
      @property
      @pulumi.getter
      def port(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "port", value)
  
      @property
      @pulumi.getter(name="predefinedTarget")
      def predefined_target(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "predefined_target")
  
      @predefined_target.setter
      def predefined_target(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "predefined_target", value)
  
      @property
      @pulumi.getter(name="securityGroupId")
      def security_group_id(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "security_group_id")
  
      @security_group_id.setter
      def security_group_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "security_group_id", value)
  
      @property
      @pulumi.getter(name="toPort")
      def to_port(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "to_port")
  
      @to_port.setter
      def to_port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "to_port", value)
  
      @property
      @pulumi.getter(name="v4CidrBlocks")
      def v4_cidr_blocks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          return pulumi.get(self, "v4_cidr_blocks")
  
      @v4_cidr_blocks.setter
      def v4_cidr_blocks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "v4_cidr_blocks", value)
  
      @property
      @pulumi.getter(name="v6CidrBlocks")
      def v6_cidr_blocks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          return pulumi.get(self, "v6_cidr_blocks")
  
      @v6_cidr_blocks.setter
      def v6_cidr_blocks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "v6_cidr_blocks", value)
  
  
  @pulumi.input_type
  class VpcRouteTableStaticRouteArgs:
      def __init__(__self__, *,
                   destination_prefix: Optional[pulumi.Input[str]] = None,
                   next_hop_address: Optional[pulumi.Input[str]] = None):
          """
          :param pulumi.Input[str] destination_prefix: Route prefix in CIDR notation.
          :param pulumi.Input[str] next_hop_address: Address of the next hop.
          """
          if destination_prefix is not None:
              pulumi.set(__self__, "destination_prefix", destination_prefix)
          if next_hop_address is not None:
              pulumi.set(__self__, "next_hop_address", next_hop_address)
  
      @property
      @pulumi.getter(name="destinationPrefix")
      def destination_prefix(self) -> Optional[pulumi.Input[str]]:
          """
          Route prefix in CIDR notation.
          """
          return pulumi.get(self, "destination_prefix")
  
      @destination_prefix.setter
      def destination_prefix(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "destination_prefix", value)
  
      @property
      @pulumi.getter(name="nextHopAddress")
      def next_hop_address(self) -> Optional[pulumi.Input[str]]:
          """
          Address of the next hop.
          """
          return pulumi.get(self, "next_hop_address")
  
      @next_hop_address.setter
      def next_hop_address(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "next_hop_address", value)
  
  
  @pulumi.input_type
  class VpcSecurityGroupEgressArgs:
      def __init__(__self__, *,
                   protocol: pulumi.Input[str],
                   description: Optional[pulumi.Input[str]] = None,
                   from_port: Optional[pulumi.Input[int]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   port: Optional[pulumi.Input[int]] = None,
                   predefined_target: Optional[pulumi.Input[str]] = None,
                   security_group_id: Optional[pulumi.Input[str]] = None,
                   to_port: Optional[pulumi.Input[int]] = None,
                   v4_cidr_blocks: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   v6_cidr_blocks: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          :param pulumi.Input[str] description: Description of the security group.
          :param pulumi.Input[str] id: Id of the rule.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: Labels to assign to this security group.
          """
          pulumi.set(__self__, "protocol", protocol)
          if description is not None:
              pulumi.set(__self__, "description", description)
          if from_port is not None:
              pulumi.set(__self__, "from_port", from_port)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if labels is not None:
              pulumi.set(__self__, "labels", labels)
          if port is not None:
              pulumi.set(__self__, "port", port)
          if predefined_target is not None:
              pulumi.set(__self__, "predefined_target", predefined_target)
          if security_group_id is not None:
              pulumi.set(__self__, "security_group_id", security_group_id)
          if to_port is not None:
              pulumi.set(__self__, "to_port", to_port)
          if v4_cidr_blocks is not None:
              pulumi.set(__self__, "v4_cidr_blocks", v4_cidr_blocks)
          if v6_cidr_blocks is not None:
              pulumi.set(__self__, "v6_cidr_blocks", v6_cidr_blocks)
  
      @property
      @pulumi.getter
      def protocol(self) -> pulumi.Input[str]:
          return pulumi.get(self, "protocol")
  
      @protocol.setter
      def protocol(self, value: pulumi.Input[str]):
          pulumi.set(self, "protocol", value)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[pulumi.Input[str]]:
          """
          Description of the security group.
          """
          return pulumi.get(self, "description")
  
      @description.setter
      def description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "description", value)
  
      @property
      @pulumi.getter(name="fromPort")
      def from_port(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "from_port")
  
      @from_port.setter
      def from_port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "from_port", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Id of the rule.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Labels to assign to this security group.
          """
          return pulumi.get(self, "labels")
  
      @labels.setter
      def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "labels", value)
  
      @property
      @pulumi.getter
      def port(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "port", value)
  
      @property
      @pulumi.getter(name="predefinedTarget")
      def predefined_target(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "predefined_target")
  
      @predefined_target.setter
      def predefined_target(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "predefined_target", value)
  
      @property
      @pulumi.getter(name="securityGroupId")
      def security_group_id(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "security_group_id")
  
      @security_group_id.setter
      def security_group_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "security_group_id", value)
  
      @property
      @pulumi.getter(name="toPort")
      def to_port(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "to_port")
  
      @to_port.setter
      def to_port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "to_port", value)
  
      @property
      @pulumi.getter(name="v4CidrBlocks")
      def v4_cidr_blocks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          return pulumi.get(self, "v4_cidr_blocks")
  
      @v4_cidr_blocks.setter
      def v4_cidr_blocks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "v4_cidr_blocks", value)
  
      @property
      @pulumi.getter(name="v6CidrBlocks")
      def v6_cidr_blocks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          return pulumi.get(self, "v6_cidr_blocks")
  
      @v6_cidr_blocks.setter
      def v6_cidr_blocks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "v6_cidr_blocks", value)
  
  
  @pulumi.input_type
  class VpcSecurityGroupIngressArgs:
      def __init__(__self__, *,
                   protocol: pulumi.Input[str],
                   description: Optional[pulumi.Input[str]] = None,
                   from_port: Optional[pulumi.Input[int]] = None,
                   id: Optional[pulumi.Input[str]] = None,
                   labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                   port: Optional[pulumi.Input[int]] = None,
                   predefined_target: Optional[pulumi.Input[str]] = None,
                   security_group_id: Optional[pulumi.Input[str]] = None,
                   to_port: Optional[pulumi.Input[int]] = None,
                   v4_cidr_blocks: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   v6_cidr_blocks: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          :param pulumi.Input[str] description: Description of the security group.
          :param pulumi.Input[str] id: Id of the rule.
          :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: Labels to assign to this security group.
          """
          pulumi.set(__self__, "protocol", protocol)
          if description is not None:
              pulumi.set(__self__, "description", description)
          if from_port is not None:
              pulumi.set(__self__, "from_port", from_port)
          if id is not None:
              pulumi.set(__self__, "id", id)
          if labels is not None:
              pulumi.set(__self__, "labels", labels)
          if port is not None:
              pulumi.set(__self__, "port", port)
          if predefined_target is not None:
              pulumi.set(__self__, "predefined_target", predefined_target)
          if security_group_id is not None:
              pulumi.set(__self__, "security_group_id", security_group_id)
          if to_port is not None:
              pulumi.set(__self__, "to_port", to_port)
          if v4_cidr_blocks is not None:
              pulumi.set(__self__, "v4_cidr_blocks", v4_cidr_blocks)
          if v6_cidr_blocks is not None:
              pulumi.set(__self__, "v6_cidr_blocks", v6_cidr_blocks)
  
      @property
      @pulumi.getter
      def protocol(self) -> pulumi.Input[str]:
          return pulumi.get(self, "protocol")
  
      @protocol.setter
      def protocol(self, value: pulumi.Input[str]):
          pulumi.set(self, "protocol", value)
  
      @property
      @pulumi.getter
      def description(self) -> Optional[pulumi.Input[str]]:
          """
          Description of the security group.
          """
          return pulumi.get(self, "description")
  
      @description.setter
      def description(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "description", value)
  
      @property
      @pulumi.getter(name="fromPort")
      def from_port(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "from_port")
  
      @from_port.setter
      def from_port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "from_port", value)
  
      @property
      @pulumi.getter
      def id(self) -> Optional[pulumi.Input[str]]:
          """
          Id of the rule.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "id", value)
  
      @property
      @pulumi.getter
      def labels(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
          """
          Labels to assign to this security group.
          """
          return pulumi.get(self, "labels")
  
      @labels.setter
      def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
          pulumi.set(self, "labels", value)
  
      @property
      @pulumi.getter
      def port(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "port", value)
  
      @property
      @pulumi.getter(name="predefinedTarget")
      def predefined_target(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "predefined_target")
  
      @predefined_target.setter
      def predefined_target(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "predefined_target", value)
  
      @property
      @pulumi.getter(name="securityGroupId")
      def security_group_id(self) -> Optional[pulumi.Input[str]]:
          return pulumi.get(self, "security_group_id")
  
      @security_group_id.setter
      def security_group_id(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "security_group_id", value)
  
      @property
      @pulumi.getter(name="toPort")
      def to_port(self) -> Optional[pulumi.Input[int]]:
          return pulumi.get(self, "to_port")
  
      @to_port.setter
      def to_port(self, value: Optional[pulumi.Input[int]]):
          pulumi.set(self, "to_port", value)
  
      @property
      @pulumi.getter(name="v4CidrBlocks")
      def v4_cidr_blocks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          return pulumi.get(self, "v4_cidr_blocks")
  
      @v4_cidr_blocks.setter
      def v4_cidr_blocks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "v4_cidr_blocks", value)
  
      @property
      @pulumi.getter(name="v6CidrBlocks")
      def v6_cidr_blocks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          return pulumi.get(self, "v6_cidr_blocks")
  
      @v6_cidr_blocks.setter
      def v6_cidr_blocks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "v6_cidr_blocks", value)
  
  
  @pulumi.input_type
  class VpcSubnetDhcpOptionsArgs:
      def __init__(__self__, *,
                   domain_name: Optional[pulumi.Input[str]] = None,
                   domain_name_servers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                   ntp_servers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
          """
          :param pulumi.Input[str] domain_name: Domain name.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] domain_name_servers: Domain name server IP addresses.
          :param pulumi.Input[Sequence[pulumi.Input[str]]] ntp_servers: NTP server IP addresses.
          """
          if domain_name is not None:
              pulumi.set(__self__, "domain_name", domain_name)
          if domain_name_servers is not None:
              pulumi.set(__self__, "domain_name_servers", domain_name_servers)
          if ntp_servers is not None:
              pulumi.set(__self__, "ntp_servers", ntp_servers)
  
      @property
      @pulumi.getter(name="domainName")
      def domain_name(self) -> Optional[pulumi.Input[str]]:
          """
          Domain name.
          """
          return pulumi.get(self, "domain_name")
  
      @domain_name.setter
      def domain_name(self, value: Optional[pulumi.Input[str]]):
          pulumi.set(self, "domain_name", value)
  
      @property
      @pulumi.getter(name="domainNameServers")
      def domain_name_servers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          Domain name server IP addresses.
          """
          return pulumi.get(self, "domain_name_servers")
  
      @domain_name_servers.setter
      def domain_name_servers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "domain_name_servers", value)
  
      @property
      @pulumi.getter(name="ntpServers")
      def ntp_servers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
          """
          NTP server IP addresses.
          """
          return pulumi.get(self, "ntp_servers")
  
      @ntp_servers.setter
      def ntp_servers(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
          pulumi.set(self, "ntp_servers", value)
  
  
  @pulumi.input_type
  class YdbDatabaseDedicatedLocationArgs:
      def __init__(__self__, *,
                   region: Optional[pulumi.Input['YdbDatabaseDedicatedLocationRegionArgs']] = None):
          """
          :param pulumi.Input['YdbDatabaseDedicatedLocationRegionArgs'] region: Region for the Yandex Database cluster.
                 The structure is documented below.
          """
          if region is not None:
              pulumi.set(__self__, "region", region)
  
      @property
      @pulumi.getter
      def region(self) -> Optional[pulumi.Input['YdbDatabaseDedicatedLocationRegionArgs']]:
          """
          Region for the Yandex Database cluster.
          The structure is documented below.
          """
          return pulumi.get(self, "region")
  
      @region.setter
      def region(self, value: Optional[pulumi.Input['YdbDatabaseDedicatedLocationRegionArgs']]):
          pulumi.set(self, "region", value)
  
  
  @pulumi.input_type
  class YdbDatabaseDedicatedLocationRegionArgs:
      def __init__(__self__, *,
                   id: pulumi.Input[str]):
          """
          :param pulumi.Input[str] id: Region ID for the Yandex Database cluster.
          """
          pulumi.set(__self__, "id", id)
  
      @property
      @pulumi.getter
      def id(self) -> pulumi.Input[str]:
          """
          Region ID for the Yandex Database cluster.
          """
          return pulumi.get(self, "id")
  
      @id.setter
      def id(self, value: pulumi.Input[str]):
          pulumi.set(self, "id", value)
  
  
  @pulumi.input_type
  class YdbDatabaseDedicatedScalePolicyArgs:
      def __init__(__self__, *,
                   fixed_scale: pulumi.Input['YdbDatabaseDedicatedScalePolicyFixedScaleArgs']):
          """
          :param pulumi.Input['YdbDatabaseDedicatedScalePolicyFixedScaleArgs'] fixed_scale: Fixed scaling policy for the Yandex Database cluster.
                 The structure is documented below.
          """
          pulumi.set(__self__, "fixed_scale", fixed_scale)
  
      @property
      @pulumi.getter(name="fixedScale")
      def fixed_scale(self) -> pulumi.Input['YdbDatabaseDedicatedScalePolicyFixedScaleArgs']:
          """
          Fixed scaling policy for the Yandex Database cluster.
          The structure is documented below.
          """
          return pulumi.get(self, "fixed_scale")
  
      @fixed_scale.setter
      def fixed_scale(self, value: pulumi.Input['YdbDatabaseDedicatedScalePolicyFixedScaleArgs']):
          pulumi.set(self, "fixed_scale", value)
  
  
  @pulumi.input_type
  class YdbDatabaseDedicatedScalePolicyFixedScaleArgs:
      def __init__(__self__, *,
                   size: pulumi.Input[int]):
          """
          :param pulumi.Input[int] size: Number of instances for the Yandex Database cluster.
          """
          pulumi.set(__self__, "size", size)
  
      @property
      @pulumi.getter
      def size(self) -> pulumi.Input[int]:
          """
          Number of instances for the Yandex Database cluster.
          """
          return pulumi.get(self, "size")
  
      @size.setter
      def size(self, value: pulumi.Input[int]):
          pulumi.set(self, "size", value)
  
  
  @pulumi.input_type
  class YdbDatabaseDedicatedStorageConfigArgs:
      def __init__(__self__, *,
                   group_count: pulumi.Input[int],
                   storage_type_id: pulumi.Input[str]):
          """
          :param pulumi.Input[int] group_count: Amount of storage groups of selected type for the Yandex Database cluster.
          :param pulumi.Input[str] storage_type_id: Storage type ID for the Yandex Database cluster.
                 Available presets can be obtained via `yc ydb storage-type list` command.
          """
          pulumi.set(__self__, "group_count", group_count)
          pulumi.set(__self__, "storage_type_id", storage_type_id)
  
      @property
      @pulumi.getter(name="groupCount")
      def group_count(self) -> pulumi.Input[int]:
          """
          Amount of storage groups of selected type for the Yandex Database cluster.
          """
          return pulumi.get(self, "group_count")
  
      @group_count.setter
      def group_count(self, value: pulumi.Input[int]):
          pulumi.set(self, "group_count", value)
  
      @property
      @pulumi.getter(name="storageTypeId")
      def storage_type_id(self) -> pulumi.Input[str]:
          """
          Storage type ID for the Yandex Database cluster.
          Available presets can be obtained via `yc ydb storage-type list` command.
          """
          return pulumi.get(self, "storage_type_id")
  
      @storage_type_id.setter
      def storage_type_id(self, value: pulumi.Input[str]):
          pulumi.set(self, "storage_type_id", value)
  
  
  @pulumi.input_type
  class GetAlbBackendGroupGrpcBackendArgs:
      def __init__(__self__, *,
                   healthcheck: 'GetAlbBackendGroupGrpcBackendHealthcheckArgs',
                   load_balancing_config: 'GetAlbBackendGroupGrpcBackendLoadBalancingConfigArgs',
                   name: str,
                   port: int,
                   target_group_ids: Sequence[str],
                   tls: 'GetAlbBackendGroupGrpcBackendTlsArgs',
                   weight: int):
          """
          :param 'GetAlbBackendGroupGrpcBackendHealthcheckArgs' healthcheck: Healthcheck specification that will be used by this backend. Structure is documented below.
          :param 'GetAlbBackendGroupGrpcBackendLoadBalancingConfigArgs' load_balancing_config: Load Balancing Config specification that will be used by this backend. Structure is documented below.
          :param str name: - Name of the Backend Group.
          :param int port: Port for incoming traffic.
          :param Sequence[str] target_group_ids: References target groups for the backend.
          :param 'GetAlbBackendGroupGrpcBackendTlsArgs' tls: Tls specification that will be used by this backend. Structure is documented below.
          :param int weight: Weight of the backend. Traffic will be split between backends of the same BackendGroup according to their weights.
          """
          pulumi.set(__self__, "healthcheck", healthcheck)
          pulumi.set(__self__, "load_balancing_config", load_balancing_config)
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "port", port)
          pulumi.set(__self__, "target_group_ids", target_group_ids)
          pulumi.set(__self__, "tls", tls)
          pulumi.set(__self__, "weight", weight)
  
      @property
      @pulumi.getter
      def healthcheck(self) -> 'GetAlbBackendGroupGrpcBackendHealthcheckArgs':
          """
          Healthcheck specification that will be used by this backend. Structure is documented below.
          """
          return pulumi.get(self, "healthcheck")
  
      @healthcheck.setter
      def healthcheck(self, value: 'GetAlbBackendGroupGrpcBackendHealthcheckArgs'):
          pulumi.set(self, "healthcheck", value)
  
      @property
      @pulumi.getter(name="loadBalancingConfig")
      def load_balancing_config(self) -> 'GetAlbBackendGroupGrpcBackendLoadBalancingConfigArgs':
          """
          Load Balancing Config specification that will be used by this backend. Structure is documented below.
          """
          return pulumi.get(self, "load_balancing_config")
  
      @load_balancing_config.setter
      def load_balancing_config(self, value: 'GetAlbBackendGroupGrpcBackendLoadBalancingConfigArgs'):
          pulumi.set(self, "load_balancing_config", value)
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          - Name of the Backend Group.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: str):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def port(self) -> int:
          """
          Port for incoming traffic.
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: int):
          pulumi.set(self, "port", value)
  
      @property
      @pulumi.getter(name="targetGroupIds")
      def target_group_ids(self) -> Sequence[str]:
          """
          References target groups for the backend.
          """
          return pulumi.get(self, "target_group_ids")
  
      @target_group_ids.setter
      def target_group_ids(self, value: Sequence[str]):
          pulumi.set(self, "target_group_ids", value)
  
      @property
      @pulumi.getter
      def tls(self) -> 'GetAlbBackendGroupGrpcBackendTlsArgs':
          """
          Tls specification that will be used by this backend. Structure is documented below.
          """
          return pulumi.get(self, "tls")
  
      @tls.setter
      def tls(self, value: 'GetAlbBackendGroupGrpcBackendTlsArgs'):
          pulumi.set(self, "tls", value)
  
      @property
      @pulumi.getter
      def weight(self) -> int:
          """
          Weight of the backend. Traffic will be split between backends of the same BackendGroup according to their weights.
          """
          return pulumi.get(self, "weight")
  
      @weight.setter
      def weight(self, value: int):
          pulumi.set(self, "weight", value)
  
  
  @pulumi.input_type
  class GetAlbBackendGroupGrpcBackendHealthcheckArgs:
      def __init__(__self__, *,
                   grpc_healthcheck: 'GetAlbBackendGroupGrpcBackendHealthcheckGrpcHealthcheckArgs',
                   healthcheck_port: int,
                   healthy_threshold: int,
                   http_healthcheck: 'GetAlbBackendGroupGrpcBackendHealthcheckHttpHealthcheckArgs',
                   interval: str,
                   interval_jitter_percent: float,
                   stream_healthcheck: 'GetAlbBackendGroupGrpcBackendHealthcheckStreamHealthcheckArgs',
                   timeout: str,
                   unhealthy_threshold: int):
          """
          :param 'GetAlbBackendGroupGrpcBackendHealthcheckGrpcHealthcheckArgs' grpc_healthcheck: Grpc Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          :param int healthcheck_port: Optional alternative port for health checking.
          :param int healthy_threshold: Number of consecutive successful health checks required to promote endpoint into the healthy state. 0 means 1. Note that during startup, only a single successful health check is required to mark a host healthy.
          :param 'GetAlbBackendGroupGrpcBackendHealthcheckHttpHealthcheckArgs' http_healthcheck: Http Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          :param str interval: Interval between health checks.
          :param float interval_jitter_percent: An optional jitter amount as a percentage of interval. If specified, during every interval value of (interval_ms * interval_jitter_percent / 100) will be added to the wait time.
          :param 'GetAlbBackendGroupGrpcBackendHealthcheckStreamHealthcheckArgs' stream_healthcheck: Stream Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          :param str timeout: Time to wait for a health check response.
          :param int unhealthy_threshold: Number of consecutive failed health checks required to demote endpoint into the unhealthy state. 0 means 1. Note that for HTTP health checks, a single 503 immediately makes endpoint unhealthy.
          """
          pulumi.set(__self__, "grpc_healthcheck", grpc_healthcheck)
          pulumi.set(__self__, "healthcheck_port", healthcheck_port)
          pulumi.set(__self__, "healthy_threshold", healthy_threshold)
          pulumi.set(__self__, "http_healthcheck", http_healthcheck)
          pulumi.set(__self__, "interval", interval)
          pulumi.set(__self__, "interval_jitter_percent", interval_jitter_percent)
          pulumi.set(__self__, "stream_healthcheck", stream_healthcheck)
          pulumi.set(__self__, "timeout", timeout)
          pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
  
      @property
      @pulumi.getter(name="grpcHealthcheck")
      def grpc_healthcheck(self) -> 'GetAlbBackendGroupGrpcBackendHealthcheckGrpcHealthcheckArgs':
          """
          Grpc Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          """
          return pulumi.get(self, "grpc_healthcheck")
  
      @grpc_healthcheck.setter
      def grpc_healthcheck(self, value: 'GetAlbBackendGroupGrpcBackendHealthcheckGrpcHealthcheckArgs'):
          pulumi.set(self, "grpc_healthcheck", value)
  
      @property
      @pulumi.getter(name="healthcheckPort")
      def healthcheck_port(self) -> int:
          """
          Optional alternative port for health checking.
          """
          return pulumi.get(self, "healthcheck_port")
  
      @healthcheck_port.setter
      def healthcheck_port(self, value: int):
          pulumi.set(self, "healthcheck_port", value)
  
      @property
      @pulumi.getter(name="healthyThreshold")
      def healthy_threshold(self) -> int:
          """
          Number of consecutive successful health checks required to promote endpoint into the healthy state. 0 means 1. Note that during startup, only a single successful health check is required to mark a host healthy.
          """
          return pulumi.get(self, "healthy_threshold")
  
      @healthy_threshold.setter
      def healthy_threshold(self, value: int):
          pulumi.set(self, "healthy_threshold", value)
  
      @property
      @pulumi.getter(name="httpHealthcheck")
      def http_healthcheck(self) -> 'GetAlbBackendGroupGrpcBackendHealthcheckHttpHealthcheckArgs':
          """
          Http Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          """
          return pulumi.get(self, "http_healthcheck")
  
      @http_healthcheck.setter
      def http_healthcheck(self, value: 'GetAlbBackendGroupGrpcBackendHealthcheckHttpHealthcheckArgs'):
          pulumi.set(self, "http_healthcheck", value)
  
      @property
      @pulumi.getter
      def interval(self) -> str:
          """
          Interval between health checks.
          """
          return pulumi.get(self, "interval")
  
      @interval.setter
      def interval(self, value: str):
          pulumi.set(self, "interval", value)
  
      @property
      @pulumi.getter(name="intervalJitterPercent")
      def interval_jitter_percent(self) -> float:
          """
          An optional jitter amount as a percentage of interval. If specified, during every interval value of (interval_ms * interval_jitter_percent / 100) will be added to the wait time.
          """
          return pulumi.get(self, "interval_jitter_percent")
  
      @interval_jitter_percent.setter
      def interval_jitter_percent(self, value: float):
          pulumi.set(self, "interval_jitter_percent", value)
  
      @property
      @pulumi.getter(name="streamHealthcheck")
      def stream_healthcheck(self) -> 'GetAlbBackendGroupGrpcBackendHealthcheckStreamHealthcheckArgs':
          """
          Stream Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          """
          return pulumi.get(self, "stream_healthcheck")
  
      @stream_healthcheck.setter
      def stream_healthcheck(self, value: 'GetAlbBackendGroupGrpcBackendHealthcheckStreamHealthcheckArgs'):
          pulumi.set(self, "stream_healthcheck", value)
  
      @property
      @pulumi.getter
      def timeout(self) -> str:
          """
          Time to wait for a health check response.
          """
          return pulumi.get(self, "timeout")
  
      @timeout.setter
      def timeout(self, value: str):
          pulumi.set(self, "timeout", value)
  
      @property
      @pulumi.getter(name="unhealthyThreshold")
      def unhealthy_threshold(self) -> int:
          """
          Number of consecutive failed health checks required to demote endpoint into the unhealthy state. 0 means 1. Note that for HTTP health checks, a single 503 immediately makes endpoint unhealthy.
          """
          return pulumi.get(self, "unhealthy_threshold")
  
      @unhealthy_threshold.setter
      def unhealthy_threshold(self, value: int):
          pulumi.set(self, "unhealthy_threshold", value)
  
  
  @pulumi.input_type
  class GetAlbBackendGroupGrpcBackendHealthcheckGrpcHealthcheckArgs:
      def __init__(__self__, *,
                   service_name: str):
          """
          :param str service_name: Optional service name for grpc.health.v1.HealthCheckRequest message.
          """
          pulumi.set(__self__, "service_name", service_name)
  
      @property
      @pulumi.getter(name="serviceName")
      def service_name(self) -> str:
          """
          Optional service name for grpc.health.v1.HealthCheckRequest message.
          """
          return pulumi.get(self, "service_name")
  
      @service_name.setter
      def service_name(self, value: str):
          pulumi.set(self, "service_name", value)
  
  
  @pulumi.input_type
  class GetAlbBackendGroupGrpcBackendHealthcheckHttpHealthcheckArgs:
      def __init__(__self__, *,
                   host: str,
                   http2: bool,
                   path: str):
          """
          :param str host: Optional "Host" HTTP header value.
          :param bool http2: If set, health checks will use HTTP2.
          :param str path: HTTP path.
          """
          pulumi.set(__self__, "host", host)
          pulumi.set(__self__, "http2", http2)
          pulumi.set(__self__, "path", path)
  
      @property
      @pulumi.getter
      def host(self) -> str:
          """
          Optional "Host" HTTP header value.
          """
          return pulumi.get(self, "host")
  
      @host.setter
      def host(self, value: str):
          pulumi.set(self, "host", value)
  
      @property
      @pulumi.getter
      def http2(self) -> bool:
          """
          If set, health checks will use HTTP2.
          """
          return pulumi.get(self, "http2")
  
      @http2.setter
      def http2(self, value: bool):
          pulumi.set(self, "http2", value)
  
      @property
      @pulumi.getter
      def path(self) -> str:
          """
          HTTP path.
          """
          return pulumi.get(self, "path")
  
      @path.setter
      def path(self, value: str):
          pulumi.set(self, "path", value)
  
  
  @pulumi.input_type
  class GetAlbBackendGroupGrpcBackendHealthcheckStreamHealthcheckArgs:
      def __init__(__self__, *,
                   receive: str,
                   send: str):
          """
          :param str receive: Optional text to search in reply.
          :param str send: Optional message to send. If empty, it's a connect-only health check.
          """
          pulumi.set(__self__, "receive", receive)
          pulumi.set(__self__, "send", send)
  
      @property
      @pulumi.getter
      def receive(self) -> str:
          """
          Optional text to search in reply.
          """
          return pulumi.get(self, "receive")
  
      @receive.setter
      def receive(self, value: str):
          pulumi.set(self, "receive", value)
  
      @property
      @pulumi.getter
      def send(self) -> str:
          """
          Optional message to send. If empty, it's a connect-only health check.
          """
          return pulumi.get(self, "send")
  
      @send.setter
      def send(self, value: str):
          pulumi.set(self, "send", value)
  
  
  @pulumi.input_type
  class GetAlbBackendGroupGrpcBackendLoadBalancingConfigArgs:
      def __init__(__self__, *,
                   locality_aware_routing_percent: int,
                   panic_threshold: int,
                   strict_locality: bool):
          """
          :param int locality_aware_routing_percent: Percent of traffic to be sent to the same availability zone. The rest will be equally divided between other zones.
          :param int panic_threshold: If percentage of healthy hosts in the backend is lower than panic_threshold, traffic will be routed to all backends no matter what the health status is. This helps to avoid healthy backends overloading  when everything is bad. Zero means no panic threshold.
          :param bool strict_locality: If set, will route requests only to the same availability zone. Balancer won't know about endpoints in other zones.
          """
          pulumi.set(__self__, "locality_aware_routing_percent", locality_aware_routing_percent)
          pulumi.set(__self__, "panic_threshold", panic_threshold)
          pulumi.set(__self__, "strict_locality", strict_locality)
  
      @property
      @pulumi.getter(name="localityAwareRoutingPercent")
      def locality_aware_routing_percent(self) -> int:
          """
          Percent of traffic to be sent to the same availability zone. The rest will be equally divided between other zones.
          """
          return pulumi.get(self, "locality_aware_routing_percent")
  
      @locality_aware_routing_percent.setter
      def locality_aware_routing_percent(self, value: int):
          pulumi.set(self, "locality_aware_routing_percent", value)
  
      @property
      @pulumi.getter(name="panicThreshold")
      def panic_threshold(self) -> int:
          """
          If percentage of healthy hosts in the backend is lower than panic_threshold, traffic will be routed to all backends no matter what the health status is. This helps to avoid healthy backends overloading  when everything is bad. Zero means no panic threshold.
          """
          return pulumi.get(self, "panic_threshold")
  
      @panic_threshold.setter
      def panic_threshold(self, value: int):
          pulumi.set(self, "panic_threshold", value)
  
      @property
      @pulumi.getter(name="strictLocality")
      def strict_locality(self) -> bool:
          """
          If set, will route requests only to the same availability zone. Balancer won't know about endpoints in other zones.
          """
          return pulumi.get(self, "strict_locality")
  
      @strict_locality.setter
      def strict_locality(self, value: bool):
          pulumi.set(self, "strict_locality", value)
  
  
  @pulumi.input_type
  class GetAlbBackendGroupGrpcBackendTlsArgs:
      def __init__(__self__, *,
                   sni: str,
                   validation_context: 'GetAlbBackendGroupGrpcBackendTlsValidationContextArgs'):
          """
          :param str sni: [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication) string for TLS connections.
                 * `validation_context.0.trusted_ca_id` - Trusted CA certificate ID in the Certificate Manager.
                 * `validation_context.0.trusted_ca_bytes` - PEM-encoded trusted CA certificate chain.
          """
          pulumi.set(__self__, "sni", sni)
          pulumi.set(__self__, "validation_context", validation_context)
  
      @property
      @pulumi.getter
      def sni(self) -> str:
          """
          [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication) string for TLS connections.
          * `validation_context.0.trusted_ca_id` - Trusted CA certificate ID in the Certificate Manager.
          * `validation_context.0.trusted_ca_bytes` - PEM-encoded trusted CA certificate chain.
          """
          return pulumi.get(self, "sni")
  
      @sni.setter
      def sni(self, value: str):
          pulumi.set(self, "sni", value)
  
      @property
      @pulumi.getter(name="validationContext")
      def validation_context(self) -> 'GetAlbBackendGroupGrpcBackendTlsValidationContextArgs':
          return pulumi.get(self, "validation_context")
  
      @validation_context.setter
      def validation_context(self, value: 'GetAlbBackendGroupGrpcBackendTlsValidationContextArgs'):
          pulumi.set(self, "validation_context", value)
  
  
  @pulumi.input_type
  class GetAlbBackendGroupGrpcBackendTlsValidationContextArgs:
      def __init__(__self__, *,
                   trusted_ca_bytes: str,
                   trusted_ca_id: str):
          pulumi.set(__self__, "trusted_ca_bytes", trusted_ca_bytes)
          pulumi.set(__self__, "trusted_ca_id", trusted_ca_id)
  
      @property
      @pulumi.getter(name="trustedCaBytes")
      def trusted_ca_bytes(self) -> str:
          return pulumi.get(self, "trusted_ca_bytes")
  
      @trusted_ca_bytes.setter
      def trusted_ca_bytes(self, value: str):
          pulumi.set(self, "trusted_ca_bytes", value)
  
      @property
      @pulumi.getter(name="trustedCaId")
      def trusted_ca_id(self) -> str:
          return pulumi.get(self, "trusted_ca_id")
  
      @trusted_ca_id.setter
      def trusted_ca_id(self, value: str):
          pulumi.set(self, "trusted_ca_id", value)
  
  
  @pulumi.input_type
  class GetAlbBackendGroupHttpBackendArgs:
      def __init__(__self__, *,
                   healthcheck: 'GetAlbBackendGroupHttpBackendHealthcheckArgs',
                   http2: bool,
                   load_balancing_config: 'GetAlbBackendGroupHttpBackendLoadBalancingConfigArgs',
                   name: str,
                   port: int,
                   target_group_ids: Sequence[str],
                   tls: 'GetAlbBackendGroupHttpBackendTlsArgs',
                   weight: int):
          """
          :param 'GetAlbBackendGroupHttpBackendHealthcheckArgs' healthcheck: Healthcheck specification that will be used by this backend. Structure is documented below.
          :param bool http2: If set, health checks will use HTTP2.
          :param 'GetAlbBackendGroupHttpBackendLoadBalancingConfigArgs' load_balancing_config: Load Balancing Config specification that will be used by this backend. Structure is documented below.
          :param str name: - Name of the Backend Group.
          :param int port: Port for incoming traffic.
          :param Sequence[str] target_group_ids: References target groups for the backend.
          :param 'GetAlbBackendGroupHttpBackendTlsArgs' tls: Tls specification that will be used by this backend. Structure is documented below.
          :param int weight: Weight of the backend. Traffic will be split between backends of the same BackendGroup according to their weights.
          """
          pulumi.set(__self__, "healthcheck", healthcheck)
          pulumi.set(__self__, "http2", http2)
          pulumi.set(__self__, "load_balancing_config", load_balancing_config)
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "port", port)
          pulumi.set(__self__, "target_group_ids", target_group_ids)
          pulumi.set(__self__, "tls", tls)
          pulumi.set(__self__, "weight", weight)
  
      @property
      @pulumi.getter
      def healthcheck(self) -> 'GetAlbBackendGroupHttpBackendHealthcheckArgs':
          """
          Healthcheck specification that will be used by this backend. Structure is documented below.
          """
          return pulumi.get(self, "healthcheck")
  
      @healthcheck.setter
      def healthcheck(self, value: 'GetAlbBackendGroupHttpBackendHealthcheckArgs'):
          pulumi.set(self, "healthcheck", value)
  
      @property
      @pulumi.getter
      def http2(self) -> bool:
          """
          If set, health checks will use HTTP2.
          """
          return pulumi.get(self, "http2")
  
      @http2.setter
      def http2(self, value: bool):
          pulumi.set(self, "http2", value)
  
      @property
      @pulumi.getter(name="loadBalancingConfig")
      def load_balancing_config(self) -> 'GetAlbBackendGroupHttpBackendLoadBalancingConfigArgs':
          """
          Load Balancing Config specification that will be used by this backend. Structure is documented below.
          """
          return pulumi.get(self, "load_balancing_config")
  
      @load_balancing_config.setter
      def load_balancing_config(self, value: 'GetAlbBackendGroupHttpBackendLoadBalancingConfigArgs'):
          pulumi.set(self, "load_balancing_config", value)
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          - Name of the Backend Group.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: str):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def port(self) -> int:
          """
          Port for incoming traffic.
          """
          return pulumi.get(self, "port")
  
      @port.setter
      def port(self, value: int):
          pulumi.set(self, "port", value)
  
      @property
      @pulumi.getter(name="targetGroupIds")
      def target_group_ids(self) -> Sequence[str]:
          """
          References target groups for the backend.
          """
          return pulumi.get(self, "target_group_ids")
  
      @target_group_ids.setter
      def target_group_ids(self, value: Sequence[str]):
          pulumi.set(self, "target_group_ids", value)
  
      @property
      @pulumi.getter
      def tls(self) -> 'GetAlbBackendGroupHttpBackendTlsArgs':
          """
          Tls specification that will be used by this backend. Structure is documented below.
          """
          return pulumi.get(self, "tls")
  
      @tls.setter
      def tls(self, value: 'GetAlbBackendGroupHttpBackendTlsArgs'):
          pulumi.set(self, "tls", value)
  
      @property
      @pulumi.getter
      def weight(self) -> int:
          """
          Weight of the backend. Traffic will be split between backends of the same BackendGroup according to their weights.
          """
          return pulumi.get(self, "weight")
  
      @weight.setter
      def weight(self, value: int):
          pulumi.set(self, "weight", value)
  
  
  @pulumi.input_type
  class GetAlbBackendGroupHttpBackendHealthcheckArgs:
      def __init__(__self__, *,
                   grpc_healthcheck: 'GetAlbBackendGroupHttpBackendHealthcheckGrpcHealthcheckArgs',
                   healthcheck_port: int,
                   healthy_threshold: int,
                   http_healthcheck: 'GetAlbBackendGroupHttpBackendHealthcheckHttpHealthcheckArgs',
                   interval: str,
                   interval_jitter_percent: float,
                   stream_healthcheck: 'GetAlbBackendGroupHttpBackendHealthcheckStreamHealthcheckArgs',
                   timeout: str,
                   unhealthy_threshold: int):
          """
          :param 'GetAlbBackendGroupHttpBackendHealthcheckGrpcHealthcheckArgs' grpc_healthcheck: Grpc Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          :param int healthcheck_port: Optional alternative port for health checking.
          :param int healthy_threshold: Number of consecutive successful health checks required to promote endpoint into the healthy state. 0 means 1. Note that during startup, only a single successful health check is required to mark a host healthy.
          :param 'GetAlbBackendGroupHttpBackendHealthcheckHttpHealthcheckArgs' http_healthcheck: Http Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          :param str interval: Interval between health checks.
          :param float interval_jitter_percent: An optional jitter amount as a percentage of interval. If specified, during every interval value of (interval_ms * interval_jitter_percent / 100) will be added to the wait time.
          :param 'GetAlbBackendGroupHttpBackendHealthcheckStreamHealthcheckArgs' stream_healthcheck: Stream Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          :param str timeout: Time to wait for a health check response.
          :param int unhealthy_threshold: Number of consecutive failed health checks required to demote endpoint into the unhealthy state. 0 means 1. Note that for HTTP health checks, a single 503 immediately makes endpoint unhealthy.
          """
          pulumi.set(__self__, "grpc_healthcheck", grpc_healthcheck)
          pulumi.set(__self__, "healthcheck_port", healthcheck_port)
          pulumi.set(__self__, "healthy_threshold", healthy_threshold)
          pulumi.set(__self__, "http_healthcheck", http_healthcheck)
          pulumi.set(__self__, "interval", interval)
          pulumi.set(__self__, "interval_jitter_percent", interval_jitter_percent)
          pulumi.set(__self__, "stream_healthcheck", stream_healthcheck)
          pulumi.set(__self__, "timeout", timeout)
          pulumi.set(__self__, "unhealthy_threshold", unhealthy_threshold)
  
      @property
      @pulumi.getter(name="grpcHealthcheck")
      def grpc_healthcheck(self) -> 'GetAlbBackendGroupHttpBackendHealthcheckGrpcHealthcheckArgs':
          """
          Grpc Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          """
          return pulumi.get(self, "grpc_healthcheck")
  
      @grpc_healthcheck.setter
      def grpc_healthcheck(self, value: 'GetAlbBackendGroupHttpBackendHealthcheckGrpcHealthcheckArgs'):
          pulumi.set(self, "grpc_healthcheck", value)
  
      @property
      @pulumi.getter(name="healthcheckPort")
      def healthcheck_port(self) -> int:
          """
          Optional alternative port for health checking.
          """
          return pulumi.get(self, "healthcheck_port")
  
      @healthcheck_port.setter
      def healthcheck_port(self, value: int):
          pulumi.set(self, "healthcheck_port", value)
  
      @property
      @pulumi.getter(name="healthyThreshold")
      def healthy_threshold(self) -> int:
          """
          Number of consecutive successful health checks required to promote endpoint into the healthy state. 0 means 1. Note that during startup, only a single successful health check is required to mark a host healthy.
          """
          return pulumi.get(self, "healthy_threshold")
  
      @healthy_threshold.setter
      def healthy_threshold(self, value: int):
          pulumi.set(self, "healthy_threshold", value)
  
      @property
      @pulumi.getter(name="httpHealthcheck")
      def http_healthcheck(self) -> 'GetAlbBackendGroupHttpBackendHealthcheckHttpHealthcheckArgs':
          """
          Http Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          """
          return pulumi.get(self, "http_healthcheck")
  
      @http_healthcheck.setter
      def http_healthcheck(self, value: 'GetAlbBackendGroupHttpBackendHealthcheckHttpHealthcheckArgs'):
          pulumi.set(self, "http_healthcheck", value)
  
      @property
      @pulumi.getter
      def interval(self) -> str:
          """
          Interval between health checks.
          """
          return pulumi.get(self, "interval")
  
      @interval.setter
      def interval(self, value: str):
          pulumi.set(self, "interval", value)
  
      @property
      @pulumi.getter(name="intervalJitterPercent")
      def interval_jitter_percent(self) -> float:
          """
          An optional jitter amount as a percentage of interval. If specified, during every interval value of (interval_ms * interval_jitter_percent / 100) will be added to the wait time.
          """
          return pulumi.get(self, "interval_jitter_percent")
  
      @interval_jitter_percent.setter
      def interval_jitter_percent(self, value: float):
          pulumi.set(self, "interval_jitter_percent", value)
  
      @property
      @pulumi.getter(name="streamHealthcheck")
      def stream_healthcheck(self) -> 'GetAlbBackendGroupHttpBackendHealthcheckStreamHealthcheckArgs':
          """
          Stream Healthcheck specification that will be used by this healthcheck. Structure is documented below.
          """
          return pulumi.get(self, "stream_healthcheck")
  
      @stream_healthcheck.setter
      def stream_healthcheck(self, value: 'GetAlbBackendGroupHttpBackendHealthcheckStreamHealthcheckArgs'):
          pulumi.set(self, "stream_healthcheck", value)
  
      @property
      @pulumi.getter
      def timeout(self) -> str:
          """
          Time to wait for a health check response.
          """
          return pulumi.get(self, "timeout")
  
      @timeout.setter
      def timeout(self, value: str):
          pulumi.set(self, "timeout", value)
  
      @property
      @pulumi.getter(name="unhealthyThreshold")
      def unhealthy_threshold(self) -> int:
          """
          Number of consecutive failed health checks required to demote endpoint into the unhealthy state. 0 means 1. Note that for HTTP health checks, a single 503 immediately makes endpoint unhealthy.
          """
          return pulumi.get(self, "unhealthy_threshold")
  
      @unhealthy_threshold.setter
      def unhealthy_threshold(self, value: int):
          pulumi.set(self, "unhealthy_threshold", value)
  
  
  @pulumi.input_type
  class GetAlbBackendGroupHttpBackendHealthcheckGrpcHealthcheckArgs:
      def __init__(__self__, *,
                   service_name: str):
          """
          :param str service_name: Optional service name for grpc.health.v1.HealthCheckRequest message.
          """
          pulumi.set(__self__, "service_name", service_name)
  
      @property
      @pulumi.getter(name="serviceName")
      def service_name(self) -> str:
          """
          Optional service name for grpc.health.v1.HealthCheckRequest message.
          """
          return pulumi.get(self, "service_name")
  
      @service_name.setter
      def service_name(self, value: str):
          pulumi.set(self, "service_name", value)
  
  
  @pulumi.input_type
  class GetAlbBackendGroupHttpBackendHealthcheckHttpHealthcheckArgs:
      def __init__(__self__, *,
                   host: str,
                   http2: bool,
                   path: str):
          """
          :param str host: Optional "Host" HTTP header value.
          :param bool http2: If set, health checks will use HTTP2.
          :param str path: HTTP path.
          """
          pulumi.set(__self__, "host", host)
          pulumi.set(__self__, "http2", http2)
          pulumi.set(__self__, "path", path)
  
      @property
      @pulumi.getter
      def host(self) -> str:
          """
          Optional "Host" HTTP header value.
          """
          return pulumi.get(self, "host")
  
      @host.setter
      def host(self, value: str):
          pulumi.set(self, "host", value)
  
      @property
      @pulumi.getter
      def http2(self) -> bool:
          """
          If set, health checks will use HTTP2.
          """
          return pulumi.get(self, "http2")
  
      @http2.setter
      def http2(self, value: bool):
          pulumi.set(self, "http2", value)
  
      @property
      @pulumi.getter
      def path(self) -> str:
          """
          HTTP path.
          """
          return pulumi.get(self, "path")
  
      @path.setter
      def path(self, value: str):
          pulumi.set(self, "path", value)
  
  
  @pulumi.input_type
  class GetAlbBackendGroupHttpBackendHealthcheckStreamHealthcheckArgs:
      def __init__(__self__, *,
                   receive: str,
                   send: str):
          """
          :param str receive: Optional text to search in reply.
          :param str send: Optional message to send. If empty, it's a connect-only health check.
          """
          pulumi.set(__self__, "receive", receive)
          pulumi.set(__self__, "send", send)
  
      @property
      @pulumi.getter
      def receive(self) -> str:
          """
          Optional text to search in reply.
          """
          return pulumi.get(self, "receive")
  
      @receive.setter
      def receive(self, value: str):
          pulumi.set(self, "receive", value)
  
      @property
      @pulumi.getter
      def send(self) -> str:
          """
          Optional message to send. If empty, it's a connect-only health check.
          """
          return pulumi.get(self, "send")
  
      @send.setter
      def send(self, value: str):
          pulumi.set(self, "send", value)
  
  
  @pulumi.input_type
  class GetAlbBackendGroupHttpBackendLoadBalancingConfigArgs:
      def __init__(__self__, *,
                   locality_aware_routing_percent: int,
                   panic_threshold: int,
                   strict_locality: bool):
          """
          :param int locality_aware_routing_percent: Percent of traffic to be sent to the same availability zone. The rest will be equally divided between other zones.
          :param int panic_threshold: If percentage of healthy hosts in the backend is lower than panic_threshold, traffic will be routed to all backends no matter what the health status is. This helps to avoid healthy backends overloading  when everything is bad. Zero means no panic threshold.
          :param bool strict_locality: If set, will route requests only to the same availability zone. Balancer won't know about endpoints in other zones.
          """
          pulumi.set(__self__, "locality_aware_routing_percent", locality_aware_routing_percent)
          pulumi.set(__self__, "panic_threshold", panic_threshold)
          pulumi.set(__self__, "strict_locality", strict_locality)
  
      @property
      @pulumi.getter(name="localityAwareRoutingPercent")
      def locality_aware_routing_percent(self) -> int:
          """
          Percent of traffic to be sent to the same availability zone. The rest will be equally divided between other zones.
          """
          return pulumi.get(self, "locality_aware_routing_percent")
  
      @locality_aware_routing_percent.setter
      def locality_aware_routing_percent(self, value: int):
          pulumi.set(self, "locality_aware_routing_percent", value)
  
      @property
      @pulumi.getter(name="panicThreshold")
      def panic_threshold(self) -> int:
          """
          If percentage of healthy hosts in the backend is lower than panic_threshold, traffic will be routed to all backends no matter what the health status is. This helps to avoid healthy backends overloading  when everything is bad. Zero means no panic threshold.
          """
          return pulumi.get(self, "panic_threshold")
  
      @panic_threshold.setter
      def panic_threshold(self, value: int):
          pulumi.set(self, "panic_threshold", value)
  
      @property
      @pulumi.getter(name="strictLocality")
      def strict_locality(self) -> bool:
          """
          If set, will route requests only to the same availability zone. Balancer won't know about endpoints in other zones.
          """
          return pulumi.get(self, "strict_locality")
  
      @strict_locality.setter
      def strict_locality(self, value: bool):
          pulumi.set(self, "strict_locality", value)
  
  
  @pulumi.input_type
  class GetAlbBackendGroupHttpBackendTlsArgs:
      def __init__(__self__, *,
                   sni: str,
                   validation_context: 'GetAlbBackendGroupHttpBackendTlsValidationContextArgs'):
          """
          :param str sni: [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication) string for TLS connections.
                 * `validation_context.0.trusted_ca_id` - Trusted CA certificate ID in the Certificate Manager.
                 * `validation_context.0.trusted_ca_bytes` - PEM-encoded trusted CA certificate chain.
          """
          pulumi.set(__self__, "sni", sni)
          pulumi.set(__self__, "validation_context", validation_context)
  
      @property
      @pulumi.getter
      def sni(self) -> str:
          """
          [SNI](https://en.wikipedia.org/wiki/Server_Name_Indication) string for TLS connections.
          * `validation_context.0.trusted_ca_id` - Trusted CA certificate ID in the Certificate Manager.
          * `validation_context.0.trusted_ca_bytes` - PEM-encoded trusted CA certificate chain.
          """
          return pulumi.get(self, "sni")
  
      @sni.setter
      def sni(self, value: str):
          pulumi.set(self, "sni", value)
  
      @property
      @pulumi.getter(name="validationContext")
      def validation_context(self) -> 'GetAlbBackendGroupHttpBackendTlsValidationContextArgs':
          return pulumi.get(self, "validation_context")
  
      @validation_context.setter
      def validation_context(self, value: 'GetAlbBackendGroupHttpBackendTlsValidationContextArgs'):
          pulumi.set(self, "validation_context", value)
  
  
  @pulumi.input_type
  class GetAlbBackendGroupHttpBackendTlsValidationContextArgs:
      def __init__(__self__, *,
                   trusted_ca_bytes: str,
                   trusted_ca_id: str):
          pulumi.set(__self__, "trusted_ca_bytes", trusted_ca_bytes)
          pulumi.set(__self__, "trusted_ca_id", trusted_ca_id)
  
      @property
      @pulumi.getter(name="trustedCaBytes")
      def trusted_ca_bytes(self) -> str:
          return pulumi.get(self, "trusted_ca_bytes")
  
      @trusted_ca_bytes.setter
      def trusted_ca_bytes(self, value: str):
          pulumi.set(self, "trusted_ca_bytes", value)
  
      @property
      @pulumi.getter(name="trustedCaId")
      def trusted_ca_id(self) -> str:
          return pulumi.get(self, "trusted_ca_id")
  
      @trusted_ca_id.setter
      def trusted_ca_id(self, value: str):
          pulumi.set(self, "trusted_ca_id", value)
  
  
  @pulumi.input_type
  class GetComputeDiskDiskPlacementPolicyArgs:
      def __init__(__self__, *,
                   disk_placement_group_id: str):
          pulumi.set(__self__, "disk_placement_group_id", disk_placement_group_id)
  
      @property
      @pulumi.getter(name="diskPlacementGroupId")
      def disk_placement_group_id(self) -> str:
          return pulumi.get(self, "disk_placement_group_id")
  
      @disk_placement_group_id.setter
      def disk_placement_group_id(self, value: str):
          pulumi.set(self, "disk_placement_group_id", value)
  
  
  @pulumi.input_type
  class GetComputeInstancePlacementPolicyArgs:
      def __init__(__self__, *,
                   placement_group_id: str):
          pulumi.set(__self__, "placement_group_id", placement_group_id)
  
      @property
      @pulumi.getter(name="placementGroupId")
      def placement_group_id(self) -> str:
          return pulumi.get(self, "placement_group_id")
  
      @placement_group_id.setter
      def placement_group_id(self, value: str):
          pulumi.set(self, "placement_group_id", value)
  
  
  @pulumi.input_type
  class GetComputeInstanceSchedulingPolicyArgs:
      def __init__(__self__, *,
                   preemptible: Optional[bool] = None):
          """
          :param bool preemptible: (Optional) Specifies if the instance is preemptible. Defaults to false.
          """
          if preemptible is not None:
              pulumi.set(__self__, "preemptible", preemptible)
  
      @property
      @pulumi.getter
      def preemptible(self) -> Optional[bool]:
          """
          (Optional) Specifies if the instance is preemptible. Defaults to false.
          """
          return pulumi.get(self, "preemptible")
  
      @preemptible.setter
      def preemptible(self, value: Optional[bool]):
          pulumi.set(self, "preemptible", value)
  
  
  @pulumi.input_type
  class GetFunctionScalingPolicyPolicyArgs:
      def __init__(__self__, *,
                   tag: str,
                   zone_instances_limit: Optional[int] = None,
                   zone_requests_limit: Optional[int] = None):
          pulumi.set(__self__, "tag", tag)
          if zone_instances_limit is not None:
              pulumi.set(__self__, "zone_instances_limit", zone_instances_limit)
          if zone_requests_limit is not None:
              pulumi.set(__self__, "zone_requests_limit", zone_requests_limit)
  
      @property
      @pulumi.getter
      def tag(self) -> str:
          return pulumi.get(self, "tag")
  
      @tag.setter
      def tag(self, value: str):
          pulumi.set(self, "tag", value)
  
      @property
      @pulumi.getter(name="zoneInstancesLimit")
      def zone_instances_limit(self) -> Optional[int]:
          return pulumi.get(self, "zone_instances_limit")
  
      @zone_instances_limit.setter
      def zone_instances_limit(self, value: Optional[int]):
          pulumi.set(self, "zone_instances_limit", value)
  
      @property
      @pulumi.getter(name="zoneRequestsLimit")
      def zone_requests_limit(self) -> Optional[int]:
          return pulumi.get(self, "zone_requests_limit")
  
      @zone_requests_limit.setter
      def zone_requests_limit(self, value: Optional[int]):
          pulumi.set(self, "zone_requests_limit", value)
  
  
  @pulumi.input_type
  class GetIamPolicyBindingArgs:
      def __init__(__self__, *,
                   members: Sequence[str],
                   role: str):
          """
          :param Sequence[str] members: An array of identities that will be granted the privilege in the `role`.
                 Each entry can have one of the following values:
                 * **userAccount:{user_id}**: A unique user ID that represents a specific Yandex account.
                 * **serviceAccount:{service_account_id}**: A unique service account ID.
          :param str role: The role/permission that will be granted to the members.
                 See the [IAM Roles] documentation for a complete list of roles.
          """
          pulumi.set(__self__, "members", members)
          pulumi.set(__self__, "role", role)
  
      @property
      @pulumi.getter
      def members(self) -> Sequence[str]:
          """
          An array of identities that will be granted the privilege in the `role`.
          Each entry can have one of the following values:
          * **userAccount:{user_id}**: A unique user ID that represents a specific Yandex account.
          * **serviceAccount:{service_account_id}**: A unique service account ID.
          """
          return pulumi.get(self, "members")
  
      @members.setter
      def members(self, value: Sequence[str]):
          pulumi.set(self, "members", value)
  
      @property
      @pulumi.getter
      def role(self) -> str:
          """
          The role/permission that will be granted to the members.
          See the [IAM Roles] documentation for a complete list of roles.
          """
          return pulumi.get(self, "role")
  
      @role.setter
      def role(self, value: str):
          pulumi.set(self, "role", value)
  
  
  @pulumi.input_type
  class GetMdbClickhouseClusterCloudStorageArgs:
      def __init__(__self__, *,
                   enabled: bool):
          """
          :param bool enabled: (Required) Whether to use Yandex Object Storage for storing ClickHouse data. Can be either `true` or `false`.
          """
          pulumi.set(__self__, "enabled", enabled)
  
      @property
      @pulumi.getter
      def enabled(self) -> bool:
          """
          (Required) Whether to use Yandex Object Storage for storing ClickHouse data. Can be either `true` or `false`.
          """
          return pulumi.get(self, "enabled")
  
      @enabled.setter
      def enabled(self, value: bool):
          pulumi.set(self, "enabled", value)
  
  
  @pulumi.input_type
  class GetMdbKafkaClusterConfigArgs:
      def __init__(__self__, *,
                   kafka: 'GetMdbKafkaClusterConfigKafkaArgs',
                   version: str,
                   zones: Sequence[str],
                   zookeeper: 'GetMdbKafkaClusterConfigZookeeperArgs',
                   assign_public_ip: Optional[bool] = None,
                   brokers_count: Optional[int] = None,
                   schema_registry: Optional[bool] = None,
                   unmanaged_topics: Optional[bool] = None):
          """
          :param 'GetMdbKafkaClusterConfigKafkaArgs' kafka: (Optional) Configuration of the Kafka subcluster. The structure is documented below.
          :param str version: (Required) Version of the Kafka server software.
          :param Sequence[str] zones: (Optional) List of availability zones.
          :param 'GetMdbKafkaClusterConfigZookeeperArgs' zookeeper: (Optional) Configuration of the ZooKeeper subcluster. The structure is documented below.
          :param bool assign_public_ip: The flag that defines whether a public IP address is assigned to the node.
          :param int brokers_count: (Optional) Count of brokers per availability zone.
          :param bool schema_registry: (Optional) Enables managed schema registry on cluster. Can be either `true` or `false`.
          :param bool unmanaged_topics: (Optional) Allows to use Kafka AdminAPI to manage topics. Can be either `true` or `false`.
          """
          pulumi.set(__self__, "kafka", kafka)
          pulumi.set(__self__, "version", version)
          pulumi.set(__self__, "zones", zones)
          pulumi.set(__self__, "zookeeper", zookeeper)
          if assign_public_ip is not None:
              pulumi.set(__self__, "assign_public_ip", assign_public_ip)
          if brokers_count is not None:
              pulumi.set(__self__, "brokers_count", brokers_count)
          if schema_registry is not None:
              pulumi.set(__self__, "schema_registry", schema_registry)
          if unmanaged_topics is not None:
              pulumi.set(__self__, "unmanaged_topics", unmanaged_topics)
  
      @property
      @pulumi.getter
      def kafka(self) -> 'GetMdbKafkaClusterConfigKafkaArgs':
          """
          (Optional) Configuration of the Kafka subcluster. The structure is documented below.
          """
          return pulumi.get(self, "kafka")
  
      @kafka.setter
      def kafka(self, value: 'GetMdbKafkaClusterConfigKafkaArgs'):
          pulumi.set(self, "kafka", value)
  
      @property
      @pulumi.getter
      def version(self) -> str:
          """
          (Required) Version of the Kafka server software.
          """
          return pulumi.get(self, "version")
  
      @version.setter
      def version(self, value: str):
          pulumi.set(self, "version", value)
  
      @property
      @pulumi.getter
      def zones(self) -> Sequence[str]:
          """
          (Optional) List of availability zones.
          """
          return pulumi.get(self, "zones")
  
      @zones.setter
      def zones(self, value: Sequence[str]):
          pulumi.set(self, "zones", value)
  
      @property
      @pulumi.getter
      def zookeeper(self) -> 'GetMdbKafkaClusterConfigZookeeperArgs':
          """
          (Optional) Configuration of the ZooKeeper subcluster. The structure is documented below.
          """
          return pulumi.get(self, "zookeeper")
  
      @zookeeper.setter
      def zookeeper(self, value: 'GetMdbKafkaClusterConfigZookeeperArgs'):
          pulumi.set(self, "zookeeper", value)
  
      @property
      @pulumi.getter(name="assignPublicIp")
      def assign_public_ip(self) -> Optional[bool]:
          """
          The flag that defines whether a public IP address is assigned to the node.
          """
          return pulumi.get(self, "assign_public_ip")
  
      @assign_public_ip.setter
      def assign_public_ip(self, value: Optional[bool]):
          pulumi.set(self, "assign_public_ip", value)
  
      @property
      @pulumi.getter(name="brokersCount")
      def brokers_count(self) -> Optional[int]:
          """
          (Optional) Count of brokers per availability zone.
          """
          return pulumi.get(self, "brokers_count")
  
      @brokers_count.setter
      def brokers_count(self, value: Optional[int]):
          pulumi.set(self, "brokers_count", value)
  
      @property
      @pulumi.getter(name="schemaRegistry")
      def schema_registry(self) -> Optional[bool]:
          """
          (Optional) Enables managed schema registry on cluster. Can be either `true` or `false`.
          """
          return pulumi.get(self, "schema_registry")
  
      @schema_registry.setter
      def schema_registry(self, value: Optional[bool]):
          pulumi.set(self, "schema_registry", value)
  
      @property
      @pulumi.getter(name="unmanagedTopics")
      def unmanaged_topics(self) -> Optional[bool]:
          """
          (Optional) Allows to use Kafka AdminAPI to manage topics. Can be either `true` or `false`.
          """
          return pulumi.get(self, "unmanaged_topics")
  
      @unmanaged_topics.setter
      def unmanaged_topics(self, value: Optional[bool]):
          pulumi.set(self, "unmanaged_topics", value)
  
  
  @pulumi.input_type
  class GetMdbKafkaClusterConfigKafkaArgs:
      def __init__(__self__, *,
                   resources: 'GetMdbKafkaClusterConfigKafkaResourcesArgs',
                   kafka_config: Optional['GetMdbKafkaClusterConfigKafkaKafkaConfigArgs'] = None):
          """
          :param 'GetMdbKafkaClusterConfigKafkaResourcesArgs' resources: (Optional) Resources allocated to hosts of the ZooKeeper subcluster. The structure is documented below.
          :param 'GetMdbKafkaClusterConfigKafkaKafkaConfigArgs' kafka_config: (Optional) User-defined settings for the Kafka cluster. The structure is documented below.
          """
          pulumi.set(__self__, "resources", resources)
          if kafka_config is not None:
              pulumi.set(__self__, "kafka_config", kafka_config)
  
      @property
      @pulumi.getter
      def resources(self) -> 'GetMdbKafkaClusterConfigKafkaResourcesArgs':
          """
          (Optional) Resources allocated to hosts of the ZooKeeper subcluster. The structure is documented below.
          """
          return pulumi.get(self, "resources")
  
      @resources.setter
      def resources(self, value: 'GetMdbKafkaClusterConfigKafkaResourcesArgs'):
          pulumi.set(self, "resources", value)
  
      @property
      @pulumi.getter(name="kafkaConfig")
      def kafka_config(self) -> Optional['GetMdbKafkaClusterConfigKafkaKafkaConfigArgs']:
          """
          (Optional) User-defined settings for the Kafka cluster. The structure is documented below.
          """
          return pulumi.get(self, "kafka_config")
  
      @kafka_config.setter
      def kafka_config(self, value: Optional['GetMdbKafkaClusterConfigKafkaKafkaConfigArgs']):
          pulumi.set(self, "kafka_config", value)
  
  
  @pulumi.input_type
  class GetMdbKafkaClusterConfigKafkaKafkaConfigArgs:
      def __init__(__self__, *,
                   auto_create_topics_enable: Optional[bool] = None,
                   compression_type: Optional[str] = None,
                   default_replication_factor: Optional[str] = None,
                   log_flush_interval_messages: Optional[str] = None,
                   log_flush_interval_ms: Optional[str] = None,
                   log_flush_scheduler_interval_ms: Optional[str] = None,
                   log_preallocate: Optional[bool] = None,
                   log_retention_bytes: Optional[str] = None,
                   log_retention_hours: Optional[str] = None,
                   log_retention_minutes: Optional[str] = None,
                   log_retention_ms: Optional[str] = None,
                   log_segment_bytes: Optional[str] = None,
                   num_partitions: Optional[str] = None,
                   socket_receive_buffer_bytes: Optional[str] = None,
                   socket_send_buffer_bytes: Optional[str] = None):
          if auto_create_topics_enable is not None:
              pulumi.set(__self__, "auto_create_topics_enable", auto_create_topics_enable)
          if compression_type is not None:
              pulumi.set(__self__, "compression_type", compression_type)
          if default_replication_factor is not None:
              pulumi.set(__self__, "default_replication_factor", default_replication_factor)
          if log_flush_interval_messages is not None:
              pulumi.set(__self__, "log_flush_interval_messages", log_flush_interval_messages)
          if log_flush_interval_ms is not None:
              pulumi.set(__self__, "log_flush_interval_ms", log_flush_interval_ms)
          if log_flush_scheduler_interval_ms is not None:
              pulumi.set(__self__, "log_flush_scheduler_interval_ms", log_flush_scheduler_interval_ms)
          if log_preallocate is not None:
              pulumi.set(__self__, "log_preallocate", log_preallocate)
          if log_retention_bytes is not None:
              pulumi.set(__self__, "log_retention_bytes", log_retention_bytes)
          if log_retention_hours is not None:
              pulumi.set(__self__, "log_retention_hours", log_retention_hours)
          if log_retention_minutes is not None:
              pulumi.set(__self__, "log_retention_minutes", log_retention_minutes)
          if log_retention_ms is not None:
              pulumi.set(__self__, "log_retention_ms", log_retention_ms)
          if log_segment_bytes is not None:
              pulumi.set(__self__, "log_segment_bytes", log_segment_bytes)
          if num_partitions is not None:
              pulumi.set(__self__, "num_partitions", num_partitions)
          if socket_receive_buffer_bytes is not None:
              pulumi.set(__self__, "socket_receive_buffer_bytes", socket_receive_buffer_bytes)
          if socket_send_buffer_bytes is not None:
              pulumi.set(__self__, "socket_send_buffer_bytes", socket_send_buffer_bytes)
  
      @property
      @pulumi.getter(name="autoCreateTopicsEnable")
      def auto_create_topics_enable(self) -> Optional[bool]:
          return pulumi.get(self, "auto_create_topics_enable")
  
      @auto_create_topics_enable.setter
      def auto_create_topics_enable(self, value: Optional[bool]):
          pulumi.set(self, "auto_create_topics_enable", value)
  
      @property
      @pulumi.getter(name="compressionType")
      def compression_type(self) -> Optional[str]:
          return pulumi.get(self, "compression_type")
  
      @compression_type.setter
      def compression_type(self, value: Optional[str]):
          pulumi.set(self, "compression_type", value)
  
      @property
      @pulumi.getter(name="defaultReplicationFactor")
      def default_replication_factor(self) -> Optional[str]:
          return pulumi.get(self, "default_replication_factor")
  
      @default_replication_factor.setter
      def default_replication_factor(self, value: Optional[str]):
          pulumi.set(self, "default_replication_factor", value)
  
      @property
      @pulumi.getter(name="logFlushIntervalMessages")
      def log_flush_interval_messages(self) -> Optional[str]:
          return pulumi.get(self, "log_flush_interval_messages")
  
      @log_flush_interval_messages.setter
      def log_flush_interval_messages(self, value: Optional[str]):
          pulumi.set(self, "log_flush_interval_messages", value)
  
      @property
      @pulumi.getter(name="logFlushIntervalMs")
      def log_flush_interval_ms(self) -> Optional[str]:
          return pulumi.get(self, "log_flush_interval_ms")
  
      @log_flush_interval_ms.setter
      def log_flush_interval_ms(self, value: Optional[str]):
          pulumi.set(self, "log_flush_interval_ms", value)
  
      @property
      @pulumi.getter(name="logFlushSchedulerIntervalMs")
      def log_flush_scheduler_interval_ms(self) -> Optional[str]:
          return pulumi.get(self, "log_flush_scheduler_interval_ms")
  
      @log_flush_scheduler_interval_ms.setter
      def log_flush_scheduler_interval_ms(self, value: Optional[str]):
          pulumi.set(self, "log_flush_scheduler_interval_ms", value)
  
      @property
      @pulumi.getter(name="logPreallocate")
      def log_preallocate(self) -> Optional[bool]:
          return pulumi.get(self, "log_preallocate")
  
      @log_preallocate.setter
      def log_preallocate(self, value: Optional[bool]):
          pulumi.set(self, "log_preallocate", value)
  
      @property
      @pulumi.getter(name="logRetentionBytes")
      def log_retention_bytes(self) -> Optional[str]:
          return pulumi.get(self, "log_retention_bytes")
  
      @log_retention_bytes.setter
      def log_retention_bytes(self, value: Optional[str]):
          pulumi.set(self, "log_retention_bytes", value)
  
      @property
      @pulumi.getter(name="logRetentionHours")
      def log_retention_hours(self) -> Optional[str]:
          return pulumi.get(self, "log_retention_hours")
  
      @log_retention_hours.setter
      def log_retention_hours(self, value: Optional[str]):
          pulumi.set(self, "log_retention_hours", value)
  
      @property
      @pulumi.getter(name="logRetentionMinutes")
      def log_retention_minutes(self) -> Optional[str]:
          return pulumi.get(self, "log_retention_minutes")
  
      @log_retention_minutes.setter
      def log_retention_minutes(self, value: Optional[str]):
          pulumi.set(self, "log_retention_minutes", value)
  
      @property
      @pulumi.getter(name="logRetentionMs")
      def log_retention_ms(self) -> Optional[str]:
          return pulumi.get(self, "log_retention_ms")
  
      @log_retention_ms.setter
      def log_retention_ms(self, value: Optional[str]):
          pulumi.set(self, "log_retention_ms", value)
  
      @property
      @pulumi.getter(name="logSegmentBytes")
      def log_segment_bytes(self) -> Optional[str]:
          return pulumi.get(self, "log_segment_bytes")
  
      @log_segment_bytes.setter
      def log_segment_bytes(self, value: Optional[str]):
          pulumi.set(self, "log_segment_bytes", value)
  
      @property
      @pulumi.getter(name="numPartitions")
      def num_partitions(self) -> Optional[str]:
          return pulumi.get(self, "num_partitions")
  
      @num_partitions.setter
      def num_partitions(self, value: Optional[str]):
          pulumi.set(self, "num_partitions", value)
  
      @property
      @pulumi.getter(name="socketReceiveBufferBytes")
      def socket_receive_buffer_bytes(self) -> Optional[str]:
          return pulumi.get(self, "socket_receive_buffer_bytes")
  
      @socket_receive_buffer_bytes.setter
      def socket_receive_buffer_bytes(self, value: Optional[str]):
          pulumi.set(self, "socket_receive_buffer_bytes", value)
  
      @property
      @pulumi.getter(name="socketSendBufferBytes")
      def socket_send_buffer_bytes(self) -> Optional[str]:
          return pulumi.get(self, "socket_send_buffer_bytes")
  
      @socket_send_buffer_bytes.setter
      def socket_send_buffer_bytes(self, value: Optional[str]):
          pulumi.set(self, "socket_send_buffer_bytes", value)
  
  
  @pulumi.input_type
  class GetMdbKafkaClusterConfigKafkaResourcesArgs:
      def __init__(__self__, *,
                   disk_size: int,
                   disk_type_id: str,
                   resource_preset_id: str):
          """
          :param int disk_size: (Optional) Volume of the storage available to a ZooKeeper host, in gigabytes.
          :param str disk_type_id: (Optional) Type of the storage of ZooKeeper hosts.
                 For more information see [the official documentation](https://cloud.yandex.com/docs/managed-kafka/concepts/storage).
          """
          pulumi.set(__self__, "disk_size", disk_size)
          pulumi.set(__self__, "disk_type_id", disk_type_id)
          pulumi.set(__self__, "resource_preset_id", resource_preset_id)
  
      @property
      @pulumi.getter(name="diskSize")
      def disk_size(self) -> int:
          """
          (Optional) Volume of the storage available to a ZooKeeper host, in gigabytes.
          """
          return pulumi.get(self, "disk_size")
  
      @disk_size.setter
      def disk_size(self, value: int):
          pulumi.set(self, "disk_size", value)
  
      @property
      @pulumi.getter(name="diskTypeId")
      def disk_type_id(self) -> str:
          """
          (Optional) Type of the storage of ZooKeeper hosts.
          For more information see [the official documentation](https://cloud.yandex.com/docs/managed-kafka/concepts/storage).
          """
          return pulumi.get(self, "disk_type_id")
  
      @disk_type_id.setter
      def disk_type_id(self, value: str):
          pulumi.set(self, "disk_type_id", value)
  
      @property
      @pulumi.getter(name="resourcePresetId")
      def resource_preset_id(self) -> str:
          return pulumi.get(self, "resource_preset_id")
  
      @resource_preset_id.setter
      def resource_preset_id(self, value: str):
          pulumi.set(self, "resource_preset_id", value)
  
  
  @pulumi.input_type
  class GetMdbKafkaClusterConfigZookeeperArgs:
      def __init__(__self__, *,
                   resources: 'GetMdbKafkaClusterConfigZookeeperResourcesArgs'):
          """
          :param 'GetMdbKafkaClusterConfigZookeeperResourcesArgs' resources: (Optional) Resources allocated to hosts of the ZooKeeper subcluster. The structure is documented below.
          """
          pulumi.set(__self__, "resources", resources)
  
      @property
      @pulumi.getter
      def resources(self) -> 'GetMdbKafkaClusterConfigZookeeperResourcesArgs':
          """
          (Optional) Resources allocated to hosts of the ZooKeeper subcluster. The structure is documented below.
          """
          return pulumi.get(self, "resources")
  
      @resources.setter
      def resources(self, value: 'GetMdbKafkaClusterConfigZookeeperResourcesArgs'):
          pulumi.set(self, "resources", value)
  
  
  @pulumi.input_type
  class GetMdbKafkaClusterConfigZookeeperResourcesArgs:
      def __init__(__self__, *,
                   disk_size: int,
                   disk_type_id: str,
                   resource_preset_id: str):
          """
          :param int disk_size: (Optional) Volume of the storage available to a ZooKeeper host, in gigabytes.
          :param str disk_type_id: (Optional) Type of the storage of ZooKeeper hosts.
                 For more information see [the official documentation](https://cloud.yandex.com/docs/managed-kafka/concepts/storage).
          """
          pulumi.set(__self__, "disk_size", disk_size)
          pulumi.set(__self__, "disk_type_id", disk_type_id)
          pulumi.set(__self__, "resource_preset_id", resource_preset_id)
  
      @property
      @pulumi.getter(name="diskSize")
      def disk_size(self) -> int:
          """
          (Optional) Volume of the storage available to a ZooKeeper host, in gigabytes.
          """
          return pulumi.get(self, "disk_size")
  
      @disk_size.setter
      def disk_size(self, value: int):
          pulumi.set(self, "disk_size", value)
  
      @property
      @pulumi.getter(name="diskTypeId")
      def disk_type_id(self) -> str:
          """
          (Optional) Type of the storage of ZooKeeper hosts.
          For more information see [the official documentation](https://cloud.yandex.com/docs/managed-kafka/concepts/storage).
          """
          return pulumi.get(self, "disk_type_id")
  
      @disk_type_id.setter
      def disk_type_id(self, value: str):
          pulumi.set(self, "disk_type_id", value)
  
      @property
      @pulumi.getter(name="resourcePresetId")
      def resource_preset_id(self) -> str:
          return pulumi.get(self, "resource_preset_id")
  
      @resource_preset_id.setter
      def resource_preset_id(self, value: str):
          pulumi.set(self, "resource_preset_id", value)
  
  
  @pulumi.input_type
  class GetMdbKafkaClusterTopicArgs:
      def __init__(__self__, *,
                   cluster_id: str,
                   name: str,
                   partitions: int,
                   replication_factor: int,
                   topic_config: Optional['GetMdbKafkaClusterTopicTopicConfigArgs'] = None):
          """
          :param str cluster_id: The ID of the Kafka cluster.
          :param str name: The name of the Kafka cluster.
          :param int partitions: (Required) The number of the topic's partitions.
          :param int replication_factor: (Required) Amount of data copies (replicas) for the topic in the cluster.
          :param 'GetMdbKafkaClusterTopicTopicConfigArgs' topic_config: (Required) User-defined settings for the topic. The structure is documented below.
          """
          pulumi.set(__self__, "cluster_id", cluster_id)
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "partitions", partitions)
          pulumi.set(__self__, "replication_factor", replication_factor)
          if topic_config is not None:
              pulumi.set(__self__, "topic_config", topic_config)
  
      @property
      @pulumi.getter(name="clusterId")
      def cluster_id(self) -> str:
          """
          The ID of the Kafka cluster.
          """
          return pulumi.get(self, "cluster_id")
  
      @cluster_id.setter
      def cluster_id(self, value: str):
          pulumi.set(self, "cluster_id", value)
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          The name of the Kafka cluster.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: str):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def partitions(self) -> int:
          """
          (Required) The number of the topic's partitions.
          """
          return pulumi.get(self, "partitions")
  
      @partitions.setter
      def partitions(self, value: int):
          pulumi.set(self, "partitions", value)
  
      @property
      @pulumi.getter(name="replicationFactor")
      def replication_factor(self) -> int:
          """
          (Required) Amount of data copies (replicas) for the topic in the cluster.
          """
          return pulumi.get(self, "replication_factor")
  
      @replication_factor.setter
      def replication_factor(self, value: int):
          pulumi.set(self, "replication_factor", value)
  
      @property
      @pulumi.getter(name="topicConfig")
      def topic_config(self) -> Optional['GetMdbKafkaClusterTopicTopicConfigArgs']:
          """
          (Required) User-defined settings for the topic. The structure is documented below.
          """
          return pulumi.get(self, "topic_config")
  
      @topic_config.setter
      def topic_config(self, value: Optional['GetMdbKafkaClusterTopicTopicConfigArgs']):
          pulumi.set(self, "topic_config", value)
  
  
  @pulumi.input_type
  class GetMdbKafkaClusterTopicTopicConfigArgs:
      def __init__(__self__, *,
                   cleanup_policy: Optional[str] = None,
                   compression_type: Optional[str] = None,
                   delete_retention_ms: Optional[str] = None,
                   file_delete_delay_ms: Optional[str] = None,
                   flush_messages: Optional[str] = None,
                   flush_ms: Optional[str] = None,
                   max_message_bytes: Optional[str] = None,
                   min_compaction_lag_ms: Optional[str] = None,
                   min_insync_replicas: Optional[str] = None,
                   preallocate: Optional[bool] = None,
                   retention_bytes: Optional[str] = None,
                   retention_ms: Optional[str] = None,
                   segment_bytes: Optional[str] = None):
          if cleanup_policy is not None:
              pulumi.set(__self__, "cleanup_policy", cleanup_policy)
          if compression_type is not None:
              pulumi.set(__self__, "compression_type", compression_type)
          if delete_retention_ms is not None:
              pulumi.set(__self__, "delete_retention_ms", delete_retention_ms)
          if file_delete_delay_ms is not None:
              pulumi.set(__self__, "file_delete_delay_ms", file_delete_delay_ms)
          if flush_messages is not None:
              pulumi.set(__self__, "flush_messages", flush_messages)
          if flush_ms is not None:
              pulumi.set(__self__, "flush_ms", flush_ms)
          if max_message_bytes is not None:
              pulumi.set(__self__, "max_message_bytes", max_message_bytes)
          if min_compaction_lag_ms is not None:
              pulumi.set(__self__, "min_compaction_lag_ms", min_compaction_lag_ms)
          if min_insync_replicas is not None:
              pulumi.set(__self__, "min_insync_replicas", min_insync_replicas)
          if preallocate is not None:
              pulumi.set(__self__, "preallocate", preallocate)
          if retention_bytes is not None:
              pulumi.set(__self__, "retention_bytes", retention_bytes)
          if retention_ms is not None:
              pulumi.set(__self__, "retention_ms", retention_ms)
          if segment_bytes is not None:
              pulumi.set(__self__, "segment_bytes", segment_bytes)
  
      @property
      @pulumi.getter(name="cleanupPolicy")
      def cleanup_policy(self) -> Optional[str]:
          return pulumi.get(self, "cleanup_policy")
  
      @cleanup_policy.setter
      def cleanup_policy(self, value: Optional[str]):
          pulumi.set(self, "cleanup_policy", value)
  
      @property
      @pulumi.getter(name="compressionType")
      def compression_type(self) -> Optional[str]:
          return pulumi.get(self, "compression_type")
  
      @compression_type.setter
      def compression_type(self, value: Optional[str]):
          pulumi.set(self, "compression_type", value)
  
      @property
      @pulumi.getter(name="deleteRetentionMs")
      def delete_retention_ms(self) -> Optional[str]:
          return pulumi.get(self, "delete_retention_ms")
  
      @delete_retention_ms.setter
      def delete_retention_ms(self, value: Optional[str]):
          pulumi.set(self, "delete_retention_ms", value)
  
      @property
      @pulumi.getter(name="fileDeleteDelayMs")
      def file_delete_delay_ms(self) -> Optional[str]:
          return pulumi.get(self, "file_delete_delay_ms")
  
      @file_delete_delay_ms.setter
      def file_delete_delay_ms(self, value: Optional[str]):
          pulumi.set(self, "file_delete_delay_ms", value)
  
      @property
      @pulumi.getter(name="flushMessages")
      def flush_messages(self) -> Optional[str]:
          return pulumi.get(self, "flush_messages")
  
      @flush_messages.setter
      def flush_messages(self, value: Optional[str]):
          pulumi.set(self, "flush_messages", value)
  
      @property
      @pulumi.getter(name="flushMs")
      def flush_ms(self) -> Optional[str]:
          return pulumi.get(self, "flush_ms")
  
      @flush_ms.setter
      def flush_ms(self, value: Optional[str]):
          pulumi.set(self, "flush_ms", value)
  
      @property
      @pulumi.getter(name="maxMessageBytes")
      def max_message_bytes(self) -> Optional[str]:
          return pulumi.get(self, "max_message_bytes")
  
      @max_message_bytes.setter
      def max_message_bytes(self, value: Optional[str]):
          pulumi.set(self, "max_message_bytes", value)
  
      @property
      @pulumi.getter(name="minCompactionLagMs")
      def min_compaction_lag_ms(self) -> Optional[str]:
          return pulumi.get(self, "min_compaction_lag_ms")
  
      @min_compaction_lag_ms.setter
      def min_compaction_lag_ms(self, value: Optional[str]):
          pulumi.set(self, "min_compaction_lag_ms", value)
  
      @property
      @pulumi.getter(name="minInsyncReplicas")
      def min_insync_replicas(self) -> Optional[str]:
          return pulumi.get(self, "min_insync_replicas")
  
      @min_insync_replicas.setter
      def min_insync_replicas(self, value: Optional[str]):
          pulumi.set(self, "min_insync_replicas", value)
  
      @property
      @pulumi.getter
      def preallocate(self) -> Optional[bool]:
          return pulumi.get(self, "preallocate")
  
      @preallocate.setter
      def preallocate(self, value: Optional[bool]):
          pulumi.set(self, "preallocate", value)
  
      @property
      @pulumi.getter(name="retentionBytes")
      def retention_bytes(self) -> Optional[str]:
          return pulumi.get(self, "retention_bytes")
  
      @retention_bytes.setter
      def retention_bytes(self, value: Optional[str]):
          pulumi.set(self, "retention_bytes", value)
  
      @property
      @pulumi.getter(name="retentionMs")
      def retention_ms(self) -> Optional[str]:
          return pulumi.get(self, "retention_ms")
  
      @retention_ms.setter
      def retention_ms(self, value: Optional[str]):
          pulumi.set(self, "retention_ms", value)
  
      @property
      @pulumi.getter(name="segmentBytes")
      def segment_bytes(self) -> Optional[str]:
          return pulumi.get(self, "segment_bytes")
  
      @segment_bytes.setter
      def segment_bytes(self, value: Optional[str]):
          pulumi.set(self, "segment_bytes", value)
  
  
  @pulumi.input_type
  class GetMdbKafkaClusterUserArgs:
      def __init__(__self__, *,
                   name: str,
                   password: str,
                   permissions: Optional[Sequence['GetMdbKafkaClusterUserPermissionArgs']] = None):
          """
          :param str name: The name of the Kafka cluster.
          :param str password: (Required) The password of the user.
          :param Sequence['GetMdbKafkaClusterUserPermissionArgs'] permissions: (Optional) Set of permissions granted to the user. The structure is documented below.
          """
          pulumi.set(__self__, "name", name)
          pulumi.set(__self__, "password", password)
          if permissions is not None:
              pulumi.set(__self__, "permissions", permissions)
  
      @property
      @pulumi.getter
      def name(self) -> str:
          """
          The name of the Kafka cluster.
          """
          return pulumi.get(self, "name")
  
      @name.setter
      def name(self, value: str):
          pulumi.set(self, "name", value)
  
      @property
      @pulumi.getter
      def password(self) -> str:
          """
          (Required) The password of the user.
          """
          return pulumi.get(self, "password")
  
      @password.setter
      def password(self, value: str):
          pulumi.set(self, "password", value)
  
      @property
      @pulumi.getter
      def permissions(self) -> Optional[Sequence['GetMdbKafkaClusterUserPermissionArgs']]:
          """
          (Optional) Set of permissions granted to the user. The structure is documented below.
          """
          return pulumi.get(self, "permissions")
  
      @permissions.setter
      def permissions(self, value: Optional[Sequence['GetMdbKafkaClusterUserPermissionArgs']]):
          pulumi.set(self, "permissions", value)
  
  
  @pulumi.input_type
  class GetMdbKafkaClusterUserPermissionArgs:
      def __init__(__self__, *,
                   role: str,
                   topic_name: str):
          """
          :param str role: Role of the host in the cluster.
          :param str topic_name: (Required) The name of the topic that the permission grants access to.
          """
          pulumi.set(__self__, "role", role)
          pulumi.set(__self__, "topic_name", topic_name)
  
      @property
      @pulumi.getter
      def role(self) -> str:
          """
          Role of the host in the cluster.
          """
          return pulumi.get(self, "role")
  
      @role.setter
      def role(self, value: str):
          pulumi.set(self, "role", value)
  
      @property
      @pulumi.getter(name="topicName")
      def topic_name(self) -> str:
          """
          (Required) The name of the topic that the permission grants access to.
          """
          return pulumi.get(self, "topic_name")
  
      @topic_name.setter
      def topic_name(self, value: str):
          pulumi.set(self, "topic_name", value)
  
  
  @pulumi.input_type
  class GetMdbMysqlClusterAccessArgs:
      def __init__(__self__, *,
                   data_lens: bool,
                   web_sql: bool):
          """
          :param bool data_lens: Allow access for [Yandex DataLens](https://cloud.yandex.com/services/datalens).
          :param bool web_sql: Allows access for [SQL queries in the management console](https://cloud.yandex.com/docs/managed-mysql/operations/web-sql-query).
          """
          pulumi.set(__self__, "data_lens", data_lens)
          pulumi.set(__self__, "web_sql", web_sql)
  
      @property
      @pulumi.getter(name="dataLens")
      def data_lens(self) -> bool:
          """
          Allow access for [Yandex DataLens](https://cloud.yandex.com/services/datalens).
          """
          return pulumi.get(self, "data_lens")
  
      @data_lens.setter
      def data_lens(self, value: bool):
          pulumi.set(self, "data_lens", value)
  
      @property
      @pulumi.getter(name="webSql")
      def web_sql(self) -> bool:
          """
          Allows access for [SQL queries in the management console](https://cloud.yandex.com/docs/managed-mysql/operations/web-sql-query).
          """
          return pulumi.get(self, "web_sql")
  
      @web_sql.setter
      def web_sql(self, value: bool):
          pulumi.set(self, "web_sql", value)
  
  
  