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

__all__ = [
    'AccountAuthenticationSamlFieldMappingArgs',
    'CassandraCassandraArgs',
    'CassandraCassandraUserConfigArgs',
    'CassandraCassandraUserConfigCassandraArgs',
    'CassandraCassandraUserConfigIpFilterObjectArgs',
    'CassandraCassandraUserConfigPrivateAccessArgs',
    'CassandraCassandraUserConfigPublicAccessArgs',
    'CassandraComponentArgs',
    'CassandraServiceIntegrationArgs',
    'CassandraTagArgs',
    'ClickhouseClickhouseArgs',
    'ClickhouseClickhouseUserConfigArgs',
    'ClickhouseClickhouseUserConfigIpFilterObjectArgs',
    'ClickhouseClickhouseUserConfigPrivateAccessArgs',
    'ClickhouseClickhouseUserConfigPrivatelinkAccessArgs',
    'ClickhouseClickhouseUserConfigPublicAccessArgs',
    'ClickhouseComponentArgs',
    'ClickhouseGrantPrivilegeGrantArgs',
    'ClickhouseGrantRoleGrantArgs',
    'ClickhouseServiceIntegrationArgs',
    'ClickhouseTagArgs',
    'FlinkApplicationVersionSinkArgs',
    'FlinkApplicationVersionSourceArgs',
    'FlinkComponentArgs',
    'FlinkFlinkArgs',
    'FlinkFlinkUserConfigArgs',
    'FlinkFlinkUserConfigIpFilterObjectArgs',
    'FlinkFlinkUserConfigPrivatelinkAccessArgs',
    'FlinkServiceIntegrationArgs',
    'FlinkTagArgs',
    'GrafanaComponentArgs',
    'GrafanaGrafanaArgs',
    'GrafanaGrafanaUserConfigArgs',
    'GrafanaGrafanaUserConfigAuthAzureadArgs',
    'GrafanaGrafanaUserConfigAuthGenericOauthArgs',
    'GrafanaGrafanaUserConfigAuthGithubArgs',
    'GrafanaGrafanaUserConfigAuthGitlabArgs',
    'GrafanaGrafanaUserConfigAuthGoogleArgs',
    'GrafanaGrafanaUserConfigDateFormatsArgs',
    'GrafanaGrafanaUserConfigExternalImageStorageArgs',
    'GrafanaGrafanaUserConfigIpFilterObjectArgs',
    'GrafanaGrafanaUserConfigPrivateAccessArgs',
    'GrafanaGrafanaUserConfigPrivatelinkAccessArgs',
    'GrafanaGrafanaUserConfigPublicAccessArgs',
    'GrafanaGrafanaUserConfigSmtpServerArgs',
    'GrafanaServiceIntegrationArgs',
    'GrafanaTagArgs',
    'InfluxDbComponentArgs',
    'InfluxDbInfluxdbArgs',
    'InfluxDbInfluxdbUserConfigArgs',
    'InfluxDbInfluxdbUserConfigInfluxdbArgs',
    'InfluxDbInfluxdbUserConfigIpFilterObjectArgs',
    'InfluxDbInfluxdbUserConfigPrivateAccessArgs',
    'InfluxDbInfluxdbUserConfigPrivatelinkAccessArgs',
    'InfluxDbInfluxdbUserConfigPublicAccessArgs',
    'InfluxDbServiceIntegrationArgs',
    'InfluxDbTagArgs',
    'KafkaComponentArgs',
    'KafkaConnectComponentArgs',
    'KafkaConnectKafkaConnectArgs',
    'KafkaConnectKafkaConnectUserConfigArgs',
    'KafkaConnectKafkaConnectUserConfigIpFilterObjectArgs',
    'KafkaConnectKafkaConnectUserConfigKafkaConnectArgs',
    'KafkaConnectKafkaConnectUserConfigPrivateAccessArgs',
    'KafkaConnectKafkaConnectUserConfigPrivatelinkAccessArgs',
    'KafkaConnectKafkaConnectUserConfigPublicAccessArgs',
    'KafkaConnectServiceIntegrationArgs',
    'KafkaConnectTagArgs',
    'KafkaConnectorTaskArgs',
    'KafkaKafkaArgs',
    'KafkaKafkaUserConfigArgs',
    'KafkaKafkaUserConfigIpFilterObjectArgs',
    'KafkaKafkaUserConfigKafkaArgs',
    'KafkaKafkaUserConfigKafkaAuthenticationMethodsArgs',
    'KafkaKafkaUserConfigKafkaConnectConfigArgs',
    'KafkaKafkaUserConfigKafkaRestConfigArgs',
    'KafkaKafkaUserConfigPrivateAccessArgs',
    'KafkaKafkaUserConfigPrivatelinkAccessArgs',
    'KafkaKafkaUserConfigPublicAccessArgs',
    'KafkaKafkaUserConfigSchemaRegistryConfigArgs',
    'KafkaMirrorMakerComponentArgs',
    'KafkaMirrorMakerKafkaMirrormakerArgs',
    'KafkaMirrorMakerKafkaMirrormakerUserConfigArgs',
    'KafkaMirrorMakerKafkaMirrormakerUserConfigIpFilterObjectArgs',
    'KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerArgs',
    'KafkaMirrorMakerServiceIntegrationArgs',
    'KafkaMirrorMakerTagArgs',
    'KafkaServiceIntegrationArgs',
    'KafkaTagArgs',
    'KafkaTopicConfigArgs',
    'KafkaTopicTagArgs',
    'M3AggregatorComponentArgs',
    'M3AggregatorM3aggregatorArgs',
    'M3AggregatorM3aggregatorUserConfigArgs',
    'M3AggregatorM3aggregatorUserConfigIpFilterObjectArgs',
    'M3AggregatorServiceIntegrationArgs',
    'M3AggregatorTagArgs',
    'M3DbComponentArgs',
    'M3DbM3dbArgs',
    'M3DbM3dbUserConfigArgs',
    'M3DbM3dbUserConfigIpFilterObjectArgs',
    'M3DbM3dbUserConfigLimitsArgs',
    'M3DbM3dbUserConfigM3Args',
    'M3DbM3dbUserConfigM3TagOptionsArgs',
    'M3DbM3dbUserConfigNamespaceArgs',
    'M3DbM3dbUserConfigNamespaceOptionsArgs',
    'M3DbM3dbUserConfigNamespaceOptionsRetentionOptionsArgs',
    'M3DbM3dbUserConfigPrivateAccessArgs',
    'M3DbM3dbUserConfigPublicAccessArgs',
    'M3DbM3dbUserConfigRulesArgs',
    'M3DbM3dbUserConfigRulesMappingArgs',
    'M3DbM3dbUserConfigRulesMappingNamespacesObjectArgs',
    'M3DbM3dbUserConfigRulesMappingTagArgs',
    'M3DbServiceIntegrationArgs',
    'M3DbTagArgs',
    'MySqlComponentArgs',
    'MySqlMysqlArgs',
    'MySqlMysqlUserConfigArgs',
    'MySqlMysqlUserConfigIpFilterObjectArgs',
    'MySqlMysqlUserConfigMigrationArgs',
    'MySqlMysqlUserConfigMysqlArgs',
    'MySqlMysqlUserConfigPrivateAccessArgs',
    'MySqlMysqlUserConfigPrivatelinkAccessArgs',
    'MySqlMysqlUserConfigPublicAccessArgs',
    'MySqlServiceIntegrationArgs',
    'MySqlTagArgs',
    'OpenSearchComponentArgs',
    'OpenSearchOpensearchArgs',
    'OpenSearchOpensearchUserConfigArgs',
    'OpenSearchOpensearchUserConfigIndexPatternArgs',
    'OpenSearchOpensearchUserConfigIndexTemplateArgs',
    'OpenSearchOpensearchUserConfigIpFilterObjectArgs',
    'OpenSearchOpensearchUserConfigOpenidArgs',
    'OpenSearchOpensearchUserConfigOpensearchArgs',
    'OpenSearchOpensearchUserConfigOpensearchDashboardsArgs',
    'OpenSearchOpensearchUserConfigPrivateAccessArgs',
    'OpenSearchOpensearchUserConfigPrivatelinkAccessArgs',
    'OpenSearchOpensearchUserConfigPublicAccessArgs',
    'OpenSearchOpensearchUserConfigSamlArgs',
    'OpenSearchServiceIntegrationArgs',
    'OpenSearchTagArgs',
    'OrganizationTimeoutsArgs',
    'PgComponentArgs',
    'PgPgArgs',
    'PgPgUserConfigArgs',
    'PgPgUserConfigIpFilterObjectArgs',
    'PgPgUserConfigMigrationArgs',
    'PgPgUserConfigPgArgs',
    'PgPgUserConfigPgbouncerArgs',
    'PgPgUserConfigPglookoutArgs',
    'PgPgUserConfigPrivateAccessArgs',
    'PgPgUserConfigPrivatelinkAccessArgs',
    'PgPgUserConfigPublicAccessArgs',
    'PgPgUserConfigTimescaledbArgs',
    'PgServiceIntegrationArgs',
    'PgTagArgs',
    'ProjectTagArgs',
    'RedisComponentArgs',
    'RedisRediArgs',
    'RedisRedisUserConfigArgs',
    'RedisRedisUserConfigIpFilterObjectArgs',
    'RedisRedisUserConfigMigrationArgs',
    'RedisRedisUserConfigPrivateAccessArgs',
    'RedisRedisUserConfigPrivatelinkAccessArgs',
    'RedisRedisUserConfigPublicAccessArgs',
    'RedisServiceIntegrationArgs',
    'RedisTagArgs',
    'ServiceIntegrationClickhouseKafkaUserConfigArgs',
    'ServiceIntegrationClickhouseKafkaUserConfigTableArgs',
    'ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs',
    'ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs',
    'ServiceIntegrationClickhousePostgresqlUserConfigArgs',
    'ServiceIntegrationClickhousePostgresqlUserConfigDatabaseArgs',
    'ServiceIntegrationDatadogUserConfigArgs',
    'ServiceIntegrationDatadogUserConfigDatadogTagArgs',
    'ServiceIntegrationDatadogUserConfigOpensearchArgs',
    'ServiceIntegrationDatadogUserConfigRedisArgs',
    'ServiceIntegrationEndpointDatadogUserConfigArgs',
    'ServiceIntegrationEndpointDatadogUserConfigDatadogTagArgs',
    'ServiceIntegrationEndpointExternalAwsCloudwatchLogsUserConfigArgs',
    'ServiceIntegrationEndpointExternalAwsCloudwatchMetricsUserConfigArgs',
    'ServiceIntegrationEndpointExternalElasticsearchLogsUserConfigArgs',
    'ServiceIntegrationEndpointExternalGoogleCloudLoggingUserConfigArgs',
    'ServiceIntegrationEndpointExternalKafkaUserConfigArgs',
    'ServiceIntegrationEndpointExternalOpensearchLogsUserConfigArgs',
    'ServiceIntegrationEndpointExternalSchemaRegistryUserConfigArgs',
    'ServiceIntegrationEndpointJolokiaUserConfigArgs',
    'ServiceIntegrationEndpointPrometheusUserConfigArgs',
    'ServiceIntegrationEndpointRsyslogUserConfigArgs',
    'ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigArgs',
    'ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricArgs',
    'ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricArgs',
    'ServiceIntegrationKafkaConnectUserConfigArgs',
    'ServiceIntegrationKafkaConnectUserConfigKafkaConnectArgs',
    'ServiceIntegrationKafkaLogsUserConfigArgs',
    'ServiceIntegrationKafkaMirrormakerUserConfigArgs',
    'ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgs',
    'ServiceIntegrationLogsUserConfigArgs',
    'ServiceIntegrationMetricsUserConfigArgs',
    'ServiceIntegrationMetricsUserConfigSourceMysqlArgs',
    'ServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgs',
]

@pulumi.input_type
class AccountAuthenticationSamlFieldMappingArgs:
    def __init__(__self__, *,
                 email: Optional[pulumi.Input[str]] = None,
                 first_name: Optional[pulumi.Input[str]] = None,
                 identity: Optional[pulumi.Input[str]] = None,
                 last_name: Optional[pulumi.Input[str]] = None,
                 real_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] email: Field name for user email
        :param pulumi.Input[str] first_name: Field name for user's first name
        :param pulumi.Input[str] identity: Field name for user's identity. This field must always exist in responses, and must be immutable and unique. Contents of this field are used to identify the user. Using user ID (such as unix user id) is highly recommended, as email address may change, requiring relinking user to Aiven user.
        :param pulumi.Input[str] last_name: Field name for user's last name
        :param pulumi.Input[str] real_name: Field name for user's full name. If specified, first*name and last*name mappings are ignored
        """
        if email is not None:
            pulumi.set(__self__, "email", email)
        if first_name is not None:
            pulumi.set(__self__, "first_name", first_name)
        if identity is not None:
            pulumi.set(__self__, "identity", identity)
        if last_name is not None:
            pulumi.set(__self__, "last_name", last_name)
        if real_name is not None:
            pulumi.set(__self__, "real_name", real_name)

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

    @email.setter
    def email(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "email", value)

    @property
    @pulumi.getter(name="firstName")
    def first_name(self) -> Optional[pulumi.Input[str]]:
        """
        Field name for user's first name
        """
        return pulumi.get(self, "first_name")

    @first_name.setter
    def first_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "first_name", value)

    @property
    @pulumi.getter
    def identity(self) -> Optional[pulumi.Input[str]]:
        """
        Field name for user's identity. This field must always exist in responses, and must be immutable and unique. Contents of this field are used to identify the user. Using user ID (such as unix user id) is highly recommended, as email address may change, requiring relinking user to Aiven user.
        """
        return pulumi.get(self, "identity")

    @identity.setter
    def identity(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "identity", value)

    @property
    @pulumi.getter(name="lastName")
    def last_name(self) -> Optional[pulumi.Input[str]]:
        """
        Field name for user's last name
        """
        return pulumi.get(self, "last_name")

    @last_name.setter
    def last_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "last_name", value)

    @property
    @pulumi.getter(name="realName")
    def real_name(self) -> Optional[pulumi.Input[str]]:
        """
        Field name for user's full name. If specified, first*name and last*name mappings are ignored
        """
        return pulumi.get(self, "real_name")

    @real_name.setter
    def real_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "real_name", value)


@pulumi.input_type
class CassandraCassandraArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class CassandraCassandraUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[str]] = None,
                 backup_hour: Optional[pulumi.Input[int]] = None,
                 backup_minute: Optional[pulumi.Input[int]] = None,
                 cassandra: Optional[pulumi.Input['CassandraCassandraUserConfigCassandraArgs']] = None,
                 cassandra_version: Optional[pulumi.Input[str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['CassandraCassandraUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 migrate_sstableloader: Optional[pulumi.Input[bool]] = None,
                 private_access: Optional[pulumi.Input['CassandraCassandraUserConfigPrivateAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[str]] = None,
                 public_access: Optional[pulumi.Input['CassandraCassandraUserConfigPublicAccessArgs']] = None,
                 service_to_fork_from: Optional[pulumi.Input[str]] = None,
                 service_to_join_with: Optional[pulumi.Input[str]] = None,
                 static_ips: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[int] backup_hour: The hour of day (in UTC) when backup for the service is started. New backup is only started if previous backup has already completed.
        :param pulumi.Input[int] backup_minute: The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed.
        :param pulumi.Input['CassandraCassandraUserConfigCassandraArgs'] cassandra: cassandra configuration values.
        :param pulumi.Input[str] cassandra_version: Cassandra major version.
        :param pulumi.Input[Sequence[pulumi.Input['CassandraCassandraUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input[bool] migrate_sstableloader: Sets the service into migration mode enabling the sstableloader utility to be used to upload Cassandra data files. Available only on service create.
        :param pulumi.Input['CassandraCassandraUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks.
        :param pulumi.Input[str] project_to_fork_from: Name of another project to fork a service from. This has effect only when a new service is being created.
        :param pulumi.Input['CassandraCassandraUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet.
        :param pulumi.Input[str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created.
        :param pulumi.Input[str] service_to_join_with: When bootstrapping, instead of creating a new Cassandra cluster try to join an existing one from another service. Can only be set on service creation.
        :param pulumi.Input[bool] static_ips: Use static public IP addresses.
        """
        if additional_backup_regions is not None:
            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
        if backup_hour is not None:
            pulumi.set(__self__, "backup_hour", backup_hour)
        if backup_minute is not None:
            pulumi.set(__self__, "backup_minute", backup_minute)
        if cassandra is not None:
            pulumi.set(__self__, "cassandra", cassandra)
        if cassandra_version is not None:
            pulumi.set(__self__, "cassandra_version", cassandra_version)
        if ip_filter_objects is not None:
            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
        if ip_filter_strings is not None:
            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
        if ip_filters is not None:
            warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        if migrate_sstableloader is not None:
            pulumi.set(__self__, "migrate_sstableloader", migrate_sstableloader)
        if private_access is not None:
            pulumi.set(__self__, "private_access", private_access)
        if project_to_fork_from is not None:
            pulumi.set(__self__, "project_to_fork_from", project_to_fork_from)
        if public_access is not None:
            pulumi.set(__self__, "public_access", public_access)
        if service_to_fork_from is not None:
            pulumi.set(__self__, "service_to_fork_from", service_to_fork_from)
        if service_to_join_with is not None:
            pulumi.set(__self__, "service_to_join_with", service_to_join_with)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)

    @property
    @pulumi.getter(name="additionalBackupRegions")
    def additional_backup_regions(self) -> Optional[pulumi.Input[str]]:
        """
        Additional Cloud Regions for Backup Replication.
        """
        return pulumi.get(self, "additional_backup_regions")

    @additional_backup_regions.setter
    def additional_backup_regions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @property
    @pulumi.getter(name="backupHour")
    def backup_hour(self) -> Optional[pulumi.Input[int]]:
        """
        The hour of day (in UTC) when backup for the service is started. New backup is only started if previous backup has already completed.
        """
        return pulumi.get(self, "backup_hour")

    @backup_hour.setter
    def backup_hour(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "backup_hour", value)

    @property
    @pulumi.getter(name="backupMinute")
    def backup_minute(self) -> Optional[pulumi.Input[int]]:
        """
        The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed.
        """
        return pulumi.get(self, "backup_minute")

    @backup_minute.setter
    def backup_minute(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "backup_minute", value)

    @property
    @pulumi.getter
    def cassandra(self) -> Optional[pulumi.Input['CassandraCassandraUserConfigCassandraArgs']]:
        """
        cassandra configuration values.
        """
        return pulumi.get(self, "cassandra")

    @cassandra.setter
    def cassandra(self, value: Optional[pulumi.Input['CassandraCassandraUserConfigCassandraArgs']]):
        pulumi.set(self, "cassandra", value)

    @property
    @pulumi.getter(name="cassandraVersion")
    def cassandra_version(self) -> Optional[pulumi.Input[str]]:
        """
        Cassandra major version.
        """
        return pulumi.get(self, "cassandra_version")

    @cassandra_version.setter
    def cassandra_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cassandra_version", value)

    @property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['CassandraCassandraUserConfigIpFilterObjectArgs']]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        return pulumi.get(self, "ip_filter_objects")

    @ip_filter_objects.setter
    def ip_filter_objects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['CassandraCassandraUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        return pulumi.get(self, "ip_filter_strings")

    @ip_filter_strings.setter
    def ip_filter_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @property
    @pulumi.getter(name="ipFilters")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
        pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")

        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filters", value)

    @property
    @pulumi.getter(name="migrateSstableloader")
    def migrate_sstableloader(self) -> Optional[pulumi.Input[bool]]:
        """
        Sets the service into migration mode enabling the sstableloader utility to be used to upload Cassandra data files. Available only on service create.
        """
        return pulumi.get(self, "migrate_sstableloader")

    @migrate_sstableloader.setter
    def migrate_sstableloader(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "migrate_sstableloader", value)

    @property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['CassandraCassandraUserConfigPrivateAccessArgs']]:
        """
        Allow access to selected service ports from private networks.
        """
        return pulumi.get(self, "private_access")

    @private_access.setter
    def private_access(self, value: Optional[pulumi.Input['CassandraCassandraUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @property
    @pulumi.getter(name="projectToForkFrom")
    def project_to_fork_from(self) -> Optional[pulumi.Input[str]]:
        """
        Name of another project to fork a service from. This has effect only when a new service is being created.
        """
        return pulumi.get(self, "project_to_fork_from")

    @project_to_fork_from.setter
    def project_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "project_to_fork_from", value)

    @property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['CassandraCassandraUserConfigPublicAccessArgs']]:
        """
        Allow access to selected service ports from the public Internet.
        """
        return pulumi.get(self, "public_access")

    @public_access.setter
    def public_access(self, value: Optional[pulumi.Input['CassandraCassandraUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

    @property
    @pulumi.getter(name="serviceToForkFrom")
    def service_to_fork_from(self) -> Optional[pulumi.Input[str]]:
        """
        Name of another service to fork from. This has effect only when a new service is being created.
        """
        return pulumi.get(self, "service_to_fork_from")

    @service_to_fork_from.setter
    def service_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_to_fork_from", value)

    @property
    @pulumi.getter(name="serviceToJoinWith")
    def service_to_join_with(self) -> Optional[pulumi.Input[str]]:
        """
        When bootstrapping, instead of creating a new Cassandra cluster try to join an existing one from another service. Can only be set on service creation.
        """
        return pulumi.get(self, "service_to_join_with")

    @service_to_join_with.setter
    def service_to_join_with(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_to_join_with", value)

    @property
    @pulumi.getter(name="staticIps")
    def static_ips(self) -> Optional[pulumi.Input[bool]]:
        """
        Use static public IP addresses.
        """
        return pulumi.get(self, "static_ips")

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "static_ips", value)


@pulumi.input_type
class CassandraCassandraUserConfigCassandraArgs:
    def __init__(__self__, *,
                 batch_size_fail_threshold_in_kb: Optional[pulumi.Input[int]] = None,
                 batch_size_warn_threshold_in_kb: Optional[pulumi.Input[int]] = None,
                 datacenter: Optional[pulumi.Input[str]] = None):
        if batch_size_fail_threshold_in_kb is not None:
            pulumi.set(__self__, "batch_size_fail_threshold_in_kb", batch_size_fail_threshold_in_kb)
        if batch_size_warn_threshold_in_kb is not None:
            pulumi.set(__self__, "batch_size_warn_threshold_in_kb", batch_size_warn_threshold_in_kb)
        if datacenter is not None:
            pulumi.set(__self__, "datacenter", datacenter)

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

    @batch_size_fail_threshold_in_kb.setter
    def batch_size_fail_threshold_in_kb(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "batch_size_fail_threshold_in_kb", value)

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

    @batch_size_warn_threshold_in_kb.setter
    def batch_size_warn_threshold_in_kb(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "batch_size_warn_threshold_in_kb", value)

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

    @datacenter.setter
    def datacenter(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "datacenter", value)


@pulumi.input_type
class CassandraCassandraUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

    @network.setter
    def network(self, value: pulumi.Input[str]):
        pulumi.set(self, "network", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class CassandraCassandraUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class CassandraCassandraUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class CassandraComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[str]] = None,
                 host: Optional[pulumi.Input[str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 route: Optional[pulumi.Input[str]] = None,
                 ssl: Optional[pulumi.Input[bool]] = None,
                 usage: Optional[pulumi.Input[str]] = None):
        if component is not None:
            pulumi.set(__self__, "component", component)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if kafka_authentication_method is not None:
            pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if route is not None:
            pulumi.set(__self__, "route", route)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if usage is not None:
            pulumi.set(__self__, "usage", usage)

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

    @component.setter
    def component(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "component", value)

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

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

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

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kafka_authentication_method", 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
    def route(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route", value)

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

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl", value)

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

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "usage", value)


@pulumi.input_type
class CassandraServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[str],
                 source_service_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] integration_type: Type of the service integration. The only supported value at the moment is `read_replica`
        :param pulumi.Input[str] source_service_name: Name of the source service
        """
        pulumi.set(__self__, "integration_type", integration_type)
        pulumi.set(__self__, "source_service_name", source_service_name)

    @property
    @pulumi.getter(name="integrationType")
    def integration_type(self) -> pulumi.Input[str]:
        """
        Type of the service integration. The only supported value at the moment is `read_replica`
        """
        return pulumi.get(self, "integration_type")

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "integration_type", value)

    @property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[str]:
        """
        Name of the source service
        """
        return pulumi.get(self, "source_service_name")

    @source_service_name.setter
    def source_service_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "source_service_name", value)


@pulumi.input_type
class CassandraTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: Service tag key
        :param pulumi.Input[str] value: Service tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        Service tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class ClickhouseClickhouseArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class ClickhouseClickhouseUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['ClickhouseClickhouseUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 private_access: Optional[pulumi.Input['ClickhouseClickhouseUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['ClickhouseClickhouseUserConfigPrivatelinkAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[str]] = None,
                 public_access: Optional[pulumi.Input['ClickhouseClickhouseUserConfigPublicAccessArgs']] = None,
                 service_to_fork_from: Optional[pulumi.Input[str]] = None,
                 static_ips: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[Sequence[pulumi.Input['ClickhouseClickhouseUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input['ClickhouseClickhouseUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks.
        :param pulumi.Input['ClickhouseClickhouseUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink.
        :param pulumi.Input[str] project_to_fork_from: Name of another project to fork a service from. This has effect only when a new service is being created.
        :param pulumi.Input['ClickhouseClickhouseUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet.
        :param pulumi.Input[str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created.
        :param pulumi.Input[bool] static_ips: Use static public IP addresses.
        """
        if additional_backup_regions is not None:
            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
        if ip_filter_objects is not None:
            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
        if ip_filter_strings is not None:
            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
        if ip_filters is not None:
            warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        if private_access is not None:
            pulumi.set(__self__, "private_access", private_access)
        if privatelink_access is not None:
            pulumi.set(__self__, "privatelink_access", privatelink_access)
        if project_to_fork_from is not None:
            pulumi.set(__self__, "project_to_fork_from", project_to_fork_from)
        if public_access is not None:
            pulumi.set(__self__, "public_access", public_access)
        if service_to_fork_from is not None:
            pulumi.set(__self__, "service_to_fork_from", service_to_fork_from)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)

    @property
    @pulumi.getter(name="additionalBackupRegions")
    def additional_backup_regions(self) -> Optional[pulumi.Input[str]]:
        """
        Additional Cloud Regions for Backup Replication.
        """
        return pulumi.get(self, "additional_backup_regions")

    @additional_backup_regions.setter
    def additional_backup_regions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ClickhouseClickhouseUserConfigIpFilterObjectArgs']]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        return pulumi.get(self, "ip_filter_objects")

    @ip_filter_objects.setter
    def ip_filter_objects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ClickhouseClickhouseUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        return pulumi.get(self, "ip_filter_strings")

    @ip_filter_strings.setter
    def ip_filter_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @property
    @pulumi.getter(name="ipFilters")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
        pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")

        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filters", value)

    @property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['ClickhouseClickhouseUserConfigPrivateAccessArgs']]:
        """
        Allow access to selected service ports from private networks.
        """
        return pulumi.get(self, "private_access")

    @private_access.setter
    def private_access(self, value: Optional[pulumi.Input['ClickhouseClickhouseUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['ClickhouseClickhouseUserConfigPrivatelinkAccessArgs']]:
        """
        Allow access to selected service components through Privatelink.
        """
        return pulumi.get(self, "privatelink_access")

    @privatelink_access.setter
    def privatelink_access(self, value: Optional[pulumi.Input['ClickhouseClickhouseUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)

    @property
    @pulumi.getter(name="projectToForkFrom")
    def project_to_fork_from(self) -> Optional[pulumi.Input[str]]:
        """
        Name of another project to fork a service from. This has effect only when a new service is being created.
        """
        return pulumi.get(self, "project_to_fork_from")

    @project_to_fork_from.setter
    def project_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "project_to_fork_from", value)

    @property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['ClickhouseClickhouseUserConfigPublicAccessArgs']]:
        """
        Allow access to selected service ports from the public Internet.
        """
        return pulumi.get(self, "public_access")

    @public_access.setter
    def public_access(self, value: Optional[pulumi.Input['ClickhouseClickhouseUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

    @property
    @pulumi.getter(name="serviceToForkFrom")
    def service_to_fork_from(self) -> Optional[pulumi.Input[str]]:
        """
        Name of another service to fork from. This has effect only when a new service is being created.
        """
        return pulumi.get(self, "service_to_fork_from")

    @service_to_fork_from.setter
    def service_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_to_fork_from", value)

    @property
    @pulumi.getter(name="staticIps")
    def static_ips(self) -> Optional[pulumi.Input[bool]]:
        """
        Use static public IP addresses.
        """
        return pulumi.get(self, "static_ips")

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "static_ips", value)


@pulumi.input_type
class ClickhouseClickhouseUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

    @network.setter
    def network(self, value: pulumi.Input[str]):
        pulumi.set(self, "network", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class ClickhouseClickhouseUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 clickhouse: Optional[pulumi.Input[bool]] = None,
                 clickhouse_https: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] clickhouse: Clickhouse server provided values
        """
        if clickhouse is not None:
            pulumi.set(__self__, "clickhouse", clickhouse)
        if clickhouse_https is not None:
            pulumi.set(__self__, "clickhouse_https", clickhouse_https)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @property
    @pulumi.getter
    def clickhouse(self) -> Optional[pulumi.Input[bool]]:
        """
        Clickhouse server provided values
        """
        return pulumi.get(self, "clickhouse")

    @clickhouse.setter
    def clickhouse(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "clickhouse", value)

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

    @clickhouse_https.setter
    def clickhouse_https(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "clickhouse_https", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class ClickhouseClickhouseUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 clickhouse: Optional[pulumi.Input[bool]] = None,
                 clickhouse_https: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] clickhouse: Clickhouse server provided values
        """
        if clickhouse is not None:
            pulumi.set(__self__, "clickhouse", clickhouse)
        if clickhouse_https is not None:
            pulumi.set(__self__, "clickhouse_https", clickhouse_https)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @property
    @pulumi.getter
    def clickhouse(self) -> Optional[pulumi.Input[bool]]:
        """
        Clickhouse server provided values
        """
        return pulumi.get(self, "clickhouse")

    @clickhouse.setter
    def clickhouse(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "clickhouse", value)

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

    @clickhouse_https.setter
    def clickhouse_https(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "clickhouse_https", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class ClickhouseClickhouseUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 clickhouse: Optional[pulumi.Input[bool]] = None,
                 clickhouse_https: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] clickhouse: Clickhouse server provided values
        """
        if clickhouse is not None:
            pulumi.set(__self__, "clickhouse", clickhouse)
        if clickhouse_https is not None:
            pulumi.set(__self__, "clickhouse_https", clickhouse_https)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @property
    @pulumi.getter
    def clickhouse(self) -> Optional[pulumi.Input[bool]]:
        """
        Clickhouse server provided values
        """
        return pulumi.get(self, "clickhouse")

    @clickhouse.setter
    def clickhouse(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "clickhouse", value)

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

    @clickhouse_https.setter
    def clickhouse_https(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "clickhouse_https", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class ClickhouseComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[str]] = None,
                 host: Optional[pulumi.Input[str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 route: Optional[pulumi.Input[str]] = None,
                 ssl: Optional[pulumi.Input[bool]] = None,
                 usage: Optional[pulumi.Input[str]] = None):
        if component is not None:
            pulumi.set(__self__, "component", component)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if kafka_authentication_method is not None:
            pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if route is not None:
            pulumi.set(__self__, "route", route)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if usage is not None:
            pulumi.set(__self__, "usage", usage)

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

    @component.setter
    def component(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "component", value)

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

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

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

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kafka_authentication_method", 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
    def route(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route", value)

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

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl", value)

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

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "usage", value)


@pulumi.input_type
class ClickhouseGrantPrivilegeGrantArgs:
    def __init__(__self__, *,
                 database: pulumi.Input[str],
                 column: Optional[pulumi.Input[str]] = None,
                 privilege: Optional[pulumi.Input[str]] = None,
                 table: Optional[pulumi.Input[str]] = None,
                 with_grant: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] database: The database that the grant refers to. To set up proper dependencies please refer to this variable as a reference. This property cannot be changed, doing so forces recreation of the resource.
        :param pulumi.Input[str] column: The column that the grant refers to. This property cannot be changed, doing so forces recreation of the resource.
        :param pulumi.Input[str] privilege: The privilege to grant, i.e. 'INSERT', 'SELECT', etc. This property cannot be changed, doing so forces recreation of the resource.
        :param pulumi.Input[str] table: The table that the grant refers to. This property cannot be changed, doing so forces recreation of the resource.
        :param pulumi.Input[bool] with_grant: If true then the grantee gets the ability to grant the privileges he received too. This property cannot be changed, doing so forces recreation of the resource.
        """
        pulumi.set(__self__, "database", database)
        if column is not None:
            pulumi.set(__self__, "column", column)
        if privilege is not None:
            pulumi.set(__self__, "privilege", privilege)
        if table is not None:
            pulumi.set(__self__, "table", table)
        if with_grant is not None:
            pulumi.set(__self__, "with_grant", with_grant)

    @property
    @pulumi.getter
    def database(self) -> pulumi.Input[str]:
        """
        The database that the grant refers to. To set up proper dependencies please refer to this variable as a reference. This property cannot be changed, doing so forces recreation of the resource.
        """
        return pulumi.get(self, "database")

    @database.setter
    def database(self, value: pulumi.Input[str]):
        pulumi.set(self, "database", value)

    @property
    @pulumi.getter
    def column(self) -> Optional[pulumi.Input[str]]:
        """
        The column that the grant refers to. This property cannot be changed, doing so forces recreation of the resource.
        """
        return pulumi.get(self, "column")

    @column.setter
    def column(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "column", value)

    @property
    @pulumi.getter
    def privilege(self) -> Optional[pulumi.Input[str]]:
        """
        The privilege to grant, i.e. 'INSERT', 'SELECT', etc. This property cannot be changed, doing so forces recreation of the resource.
        """
        return pulumi.get(self, "privilege")

    @privilege.setter
    def privilege(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "privilege", value)

    @property
    @pulumi.getter
    def table(self) -> Optional[pulumi.Input[str]]:
        """
        The table that the grant refers to. This property cannot be changed, doing so forces recreation of the resource.
        """
        return pulumi.get(self, "table")

    @table.setter
    def table(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "table", value)

    @property
    @pulumi.getter(name="withGrant")
    def with_grant(self) -> Optional[pulumi.Input[bool]]:
        """
        If true then the grantee gets the ability to grant the privileges he received too. This property cannot be changed, doing so forces recreation of the resource.
        """
        return pulumi.get(self, "with_grant")

    @with_grant.setter
    def with_grant(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "with_grant", value)


@pulumi.input_type
class ClickhouseGrantRoleGrantArgs:
    def __init__(__self__, *,
                 role: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] role: The role that is to be granted. To set up proper dependencies please refer to this variable as a reference. This property cannot be changed, doing so forces recreation of the resource.
        """
        if role is not None:
            pulumi.set(__self__, "role", role)

    @property
    @pulumi.getter
    def role(self) -> Optional[pulumi.Input[str]]:
        """
        The role that is to be granted. To set up proper dependencies please refer to this variable as a reference. This property cannot be changed, doing so forces recreation of the resource.
        """
        return pulumi.get(self, "role")

    @role.setter
    def role(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "role", value)


@pulumi.input_type
class ClickhouseServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[str],
                 source_service_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] integration_type: Type of the service integration. The only supported values at the moment are `clickhouse_kafka` and `clickhouse_postgresql`.
        :param pulumi.Input[str] source_service_name: Name of the source service
        """
        pulumi.set(__self__, "integration_type", integration_type)
        pulumi.set(__self__, "source_service_name", source_service_name)

    @property
    @pulumi.getter(name="integrationType")
    def integration_type(self) -> pulumi.Input[str]:
        """
        Type of the service integration. The only supported values at the moment are `clickhouse_kafka` and `clickhouse_postgresql`.
        """
        return pulumi.get(self, "integration_type")

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "integration_type", value)

    @property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[str]:
        """
        Name of the source service
        """
        return pulumi.get(self, "source_service_name")

    @source_service_name.setter
    def source_service_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "source_service_name", value)


@pulumi.input_type
class ClickhouseTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: Service tag key
        :param pulumi.Input[str] value: Service tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        Service tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class FlinkApplicationVersionSinkArgs:
    def __init__(__self__, *,
                 create_table: pulumi.Input[str],
                 integration_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] create_table: The CREATE TABLE statement
        :param pulumi.Input[str] integration_id: The integration ID
        """
        pulumi.set(__self__, "create_table", create_table)
        if integration_id is not None:
            pulumi.set(__self__, "integration_id", integration_id)

    @property
    @pulumi.getter(name="createTable")
    def create_table(self) -> pulumi.Input[str]:
        """
        The CREATE TABLE statement
        """
        return pulumi.get(self, "create_table")

    @create_table.setter
    def create_table(self, value: pulumi.Input[str]):
        pulumi.set(self, "create_table", value)

    @property
    @pulumi.getter(name="integrationId")
    def integration_id(self) -> Optional[pulumi.Input[str]]:
        """
        The integration ID
        """
        return pulumi.get(self, "integration_id")

    @integration_id.setter
    def integration_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "integration_id", value)


@pulumi.input_type
class FlinkApplicationVersionSourceArgs:
    def __init__(__self__, *,
                 create_table: pulumi.Input[str],
                 integration_id: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] create_table: The CREATE TABLE statement
        :param pulumi.Input[str] integration_id: The integration ID
        """
        pulumi.set(__self__, "create_table", create_table)
        if integration_id is not None:
            pulumi.set(__self__, "integration_id", integration_id)

    @property
    @pulumi.getter(name="createTable")
    def create_table(self) -> pulumi.Input[str]:
        """
        The CREATE TABLE statement
        """
        return pulumi.get(self, "create_table")

    @create_table.setter
    def create_table(self, value: pulumi.Input[str]):
        pulumi.set(self, "create_table", value)

    @property
    @pulumi.getter(name="integrationId")
    def integration_id(self) -> Optional[pulumi.Input[str]]:
        """
        The integration ID
        """
        return pulumi.get(self, "integration_id")

    @integration_id.setter
    def integration_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "integration_id", value)


@pulumi.input_type
class FlinkComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[str]] = None,
                 host: Optional[pulumi.Input[str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 route: Optional[pulumi.Input[str]] = None,
                 ssl: Optional[pulumi.Input[bool]] = None,
                 usage: Optional[pulumi.Input[str]] = None):
        if component is not None:
            pulumi.set(__self__, "component", component)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if kafka_authentication_method is not None:
            pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if route is not None:
            pulumi.set(__self__, "route", route)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if usage is not None:
            pulumi.set(__self__, "usage", usage)

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

    @component.setter
    def component(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "component", value)

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

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

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

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kafka_authentication_method", 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
    def route(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route", value)

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

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl", value)

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

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "usage", value)


@pulumi.input_type
class FlinkFlinkArgs:
    def __init__(__self__, *,
                 host_ports: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[str]]] host_ports: Host and Port of a Flink server
        """
        if host_ports is not None:
            pulumi.set(__self__, "host_ports", host_ports)

    @property
    @pulumi.getter(name="hostPorts")
    def host_ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Host and Port of a Flink server
        """
        return pulumi.get(self, "host_ports")

    @host_ports.setter
    def host_ports(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "host_ports", value)


@pulumi.input_type
class FlinkFlinkUserConfigArgs:
    def __init__(__self__, *,
                 flink_version: Optional[pulumi.Input[str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['FlinkFlinkUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 number_of_task_slots: Optional[pulumi.Input[int]] = None,
                 privatelink_access: Optional[pulumi.Input['FlinkFlinkUserConfigPrivatelinkAccessArgs']] = None):
        """
        :param pulumi.Input[str] flink_version: Flink major version.
        :param pulumi.Input[Sequence[pulumi.Input['FlinkFlinkUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input[int] number_of_task_slots: Task slots per node. For a 3 node plan, total number of task slots is 3x this value.
        :param pulumi.Input['FlinkFlinkUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink.
        """
        if flink_version is not None:
            pulumi.set(__self__, "flink_version", flink_version)
        if ip_filter_objects is not None:
            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
        if ip_filter_strings is not None:
            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
        if ip_filters is not None:
            warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        if number_of_task_slots is not None:
            pulumi.set(__self__, "number_of_task_slots", number_of_task_slots)
        if privatelink_access is not None:
            pulumi.set(__self__, "privatelink_access", privatelink_access)

    @property
    @pulumi.getter(name="flinkVersion")
    def flink_version(self) -> Optional[pulumi.Input[str]]:
        """
        Flink major version.
        """
        return pulumi.get(self, "flink_version")

    @flink_version.setter
    def flink_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "flink_version", value)

    @property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['FlinkFlinkUserConfigIpFilterObjectArgs']]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        return pulumi.get(self, "ip_filter_objects")

    @ip_filter_objects.setter
    def ip_filter_objects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['FlinkFlinkUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        return pulumi.get(self, "ip_filter_strings")

    @ip_filter_strings.setter
    def ip_filter_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @property
    @pulumi.getter(name="ipFilters")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
        pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")

        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filters", value)

    @property
    @pulumi.getter(name="numberOfTaskSlots")
    def number_of_task_slots(self) -> Optional[pulumi.Input[int]]:
        """
        Task slots per node. For a 3 node plan, total number of task slots is 3x this value.
        """
        return pulumi.get(self, "number_of_task_slots")

    @number_of_task_slots.setter
    def number_of_task_slots(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "number_of_task_slots", value)

    @property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['FlinkFlinkUserConfigPrivatelinkAccessArgs']]:
        """
        Allow access to selected service components through Privatelink.
        """
        return pulumi.get(self, "privatelink_access")

    @privatelink_access.setter
    def privatelink_access(self, value: Optional[pulumi.Input['FlinkFlinkUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)


@pulumi.input_type
class FlinkFlinkUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

    @network.setter
    def network(self, value: pulumi.Input[str]):
        pulumi.set(self, "network", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class FlinkFlinkUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 flink: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] flink: Flink server provided values
        """
        if flink is not None:
            pulumi.set(__self__, "flink", flink)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @property
    @pulumi.getter
    def flink(self) -> Optional[pulumi.Input[bool]]:
        """
        Flink server provided values
        """
        return pulumi.get(self, "flink")

    @flink.setter
    def flink(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "flink", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class FlinkServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[str],
                 source_service_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] integration_type: Type of the service integration. The only supported value at the moment is `read_replica`
        :param pulumi.Input[str] source_service_name: Name of the source service
        """
        pulumi.set(__self__, "integration_type", integration_type)
        pulumi.set(__self__, "source_service_name", source_service_name)

    @property
    @pulumi.getter(name="integrationType")
    def integration_type(self) -> pulumi.Input[str]:
        """
        Type of the service integration. The only supported value at the moment is `read_replica`
        """
        return pulumi.get(self, "integration_type")

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "integration_type", value)

    @property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[str]:
        """
        Name of the source service
        """
        return pulumi.get(self, "source_service_name")

    @source_service_name.setter
    def source_service_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "source_service_name", value)


@pulumi.input_type
class FlinkTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: Service tag key
        :param pulumi.Input[str] value: Service tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        Service tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class GrafanaComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[str]] = None,
                 host: Optional[pulumi.Input[str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 route: Optional[pulumi.Input[str]] = None,
                 ssl: Optional[pulumi.Input[bool]] = None,
                 usage: Optional[pulumi.Input[str]] = None):
        if component is not None:
            pulumi.set(__self__, "component", component)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if kafka_authentication_method is not None:
            pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if route is not None:
            pulumi.set(__self__, "route", route)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if usage is not None:
            pulumi.set(__self__, "usage", usage)

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

    @component.setter
    def component(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "component", value)

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

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

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

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kafka_authentication_method", 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
    def route(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route", value)

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

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl", value)

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

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "usage", value)


@pulumi.input_type
class GrafanaGrafanaArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class GrafanaGrafanaUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[str]] = None,
                 alerting_enabled: Optional[pulumi.Input[bool]] = None,
                 alerting_error_or_timeout: Optional[pulumi.Input[str]] = None,
                 alerting_max_annotations_to_keep: Optional[pulumi.Input[int]] = None,
                 alerting_nodata_or_nullvalues: Optional[pulumi.Input[str]] = None,
                 allow_embedding: Optional[pulumi.Input[bool]] = None,
                 auth_azuread: Optional[pulumi.Input['GrafanaGrafanaUserConfigAuthAzureadArgs']] = None,
                 auth_basic_enabled: Optional[pulumi.Input[bool]] = None,
                 auth_generic_oauth: Optional[pulumi.Input['GrafanaGrafanaUserConfigAuthGenericOauthArgs']] = None,
                 auth_github: Optional[pulumi.Input['GrafanaGrafanaUserConfigAuthGithubArgs']] = None,
                 auth_gitlab: Optional[pulumi.Input['GrafanaGrafanaUserConfigAuthGitlabArgs']] = None,
                 auth_google: Optional[pulumi.Input['GrafanaGrafanaUserConfigAuthGoogleArgs']] = None,
                 cookie_samesite: Optional[pulumi.Input[str]] = None,
                 custom_domain: Optional[pulumi.Input[str]] = None,
                 dashboard_previews_enabled: Optional[pulumi.Input[bool]] = None,
                 dashboards_min_refresh_interval: Optional[pulumi.Input[str]] = None,
                 dashboards_versions_to_keep: Optional[pulumi.Input[int]] = None,
                 dataproxy_send_user_header: Optional[pulumi.Input[bool]] = None,
                 dataproxy_timeout: Optional[pulumi.Input[int]] = None,
                 date_formats: Optional[pulumi.Input['GrafanaGrafanaUserConfigDateFormatsArgs']] = None,
                 disable_gravatar: Optional[pulumi.Input[bool]] = None,
                 editors_can_admin: Optional[pulumi.Input[bool]] = None,
                 external_image_storage: Optional[pulumi.Input['GrafanaGrafanaUserConfigExternalImageStorageArgs']] = None,
                 google_analytics_ua_id: Optional[pulumi.Input[str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['GrafanaGrafanaUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 metrics_enabled: Optional[pulumi.Input[bool]] = None,
                 oauth_allow_insecure_email_lookup: Optional[pulumi.Input[bool]] = None,
                 private_access: Optional[pulumi.Input['GrafanaGrafanaUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['GrafanaGrafanaUserConfigPrivatelinkAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[str]] = None,
                 public_access: Optional[pulumi.Input['GrafanaGrafanaUserConfigPublicAccessArgs']] = None,
                 recovery_basebackup_name: Optional[pulumi.Input[str]] = None,
                 service_to_fork_from: Optional[pulumi.Input[str]] = None,
                 smtp_server: Optional[pulumi.Input['GrafanaGrafanaUserConfigSmtpServerArgs']] = None,
                 static_ips: Optional[pulumi.Input[bool]] = None,
                 user_auto_assign_org: Optional[pulumi.Input[bool]] = None,
                 user_auto_assign_org_role: Optional[pulumi.Input[str]] = None,
                 viewers_can_edit: Optional[pulumi.Input[bool]] = None):
        if additional_backup_regions is not None:
            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
        if alerting_enabled is not None:
            pulumi.set(__self__, "alerting_enabled", alerting_enabled)
        if alerting_error_or_timeout is not None:
            pulumi.set(__self__, "alerting_error_or_timeout", alerting_error_or_timeout)
        if alerting_max_annotations_to_keep is not None:
            pulumi.set(__self__, "alerting_max_annotations_to_keep", alerting_max_annotations_to_keep)
        if alerting_nodata_or_nullvalues is not None:
            pulumi.set(__self__, "alerting_nodata_or_nullvalues", alerting_nodata_or_nullvalues)
        if allow_embedding is not None:
            pulumi.set(__self__, "allow_embedding", allow_embedding)
        if auth_azuread is not None:
            pulumi.set(__self__, "auth_azuread", auth_azuread)
        if auth_basic_enabled is not None:
            pulumi.set(__self__, "auth_basic_enabled", auth_basic_enabled)
        if auth_generic_oauth is not None:
            pulumi.set(__self__, "auth_generic_oauth", auth_generic_oauth)
        if auth_github is not None:
            pulumi.set(__self__, "auth_github", auth_github)
        if auth_gitlab is not None:
            pulumi.set(__self__, "auth_gitlab", auth_gitlab)
        if auth_google is not None:
            pulumi.set(__self__, "auth_google", auth_google)
        if cookie_samesite is not None:
            pulumi.set(__self__, "cookie_samesite", cookie_samesite)
        if custom_domain is not None:
            pulumi.set(__self__, "custom_domain", custom_domain)
        if dashboard_previews_enabled is not None:
            pulumi.set(__self__, "dashboard_previews_enabled", dashboard_previews_enabled)
        if dashboards_min_refresh_interval is not None:
            pulumi.set(__self__, "dashboards_min_refresh_interval", dashboards_min_refresh_interval)
        if dashboards_versions_to_keep is not None:
            pulumi.set(__self__, "dashboards_versions_to_keep", dashboards_versions_to_keep)
        if dataproxy_send_user_header is not None:
            pulumi.set(__self__, "dataproxy_send_user_header", dataproxy_send_user_header)
        if dataproxy_timeout is not None:
            pulumi.set(__self__, "dataproxy_timeout", dataproxy_timeout)
        if date_formats is not None:
            pulumi.set(__self__, "date_formats", date_formats)
        if disable_gravatar is not None:
            pulumi.set(__self__, "disable_gravatar", disable_gravatar)
        if editors_can_admin is not None:
            pulumi.set(__self__, "editors_can_admin", editors_can_admin)
        if external_image_storage is not None:
            pulumi.set(__self__, "external_image_storage", external_image_storage)
        if google_analytics_ua_id is not None:
            pulumi.set(__self__, "google_analytics_ua_id", google_analytics_ua_id)
        if ip_filter_objects is not None:
            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
        if ip_filter_strings is not None:
            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
        if ip_filters is not None:
            warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        if metrics_enabled is not None:
            pulumi.set(__self__, "metrics_enabled", metrics_enabled)
        if oauth_allow_insecure_email_lookup is not None:
            pulumi.set(__self__, "oauth_allow_insecure_email_lookup", oauth_allow_insecure_email_lookup)
        if private_access is not None:
            pulumi.set(__self__, "private_access", private_access)
        if privatelink_access is not None:
            pulumi.set(__self__, "privatelink_access", privatelink_access)
        if project_to_fork_from is not None:
            pulumi.set(__self__, "project_to_fork_from", project_to_fork_from)
        if public_access is not None:
            pulumi.set(__self__, "public_access", public_access)
        if recovery_basebackup_name is not None:
            pulumi.set(__self__, "recovery_basebackup_name", recovery_basebackup_name)
        if service_to_fork_from is not None:
            pulumi.set(__self__, "service_to_fork_from", service_to_fork_from)
        if smtp_server is not None:
            pulumi.set(__self__, "smtp_server", smtp_server)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)
        if user_auto_assign_org is not None:
            pulumi.set(__self__, "user_auto_assign_org", user_auto_assign_org)
        if user_auto_assign_org_role is not None:
            pulumi.set(__self__, "user_auto_assign_org_role", user_auto_assign_org_role)
        if viewers_can_edit is not None:
            pulumi.set(__self__, "viewers_can_edit", viewers_can_edit)

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

    @additional_backup_regions.setter
    def additional_backup_regions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "additional_backup_regions", value)

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

    @alerting_enabled.setter
    def alerting_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "alerting_enabled", value)

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

    @alerting_error_or_timeout.setter
    def alerting_error_or_timeout(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "alerting_error_or_timeout", value)

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

    @alerting_max_annotations_to_keep.setter
    def alerting_max_annotations_to_keep(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "alerting_max_annotations_to_keep", value)

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

    @alerting_nodata_or_nullvalues.setter
    def alerting_nodata_or_nullvalues(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "alerting_nodata_or_nullvalues", value)

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

    @allow_embedding.setter
    def allow_embedding(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_embedding", value)

    @property
    @pulumi.getter(name="authAzuread")
    def auth_azuread(self) -> Optional[pulumi.Input['GrafanaGrafanaUserConfigAuthAzureadArgs']]:
        return pulumi.get(self, "auth_azuread")

    @auth_azuread.setter
    def auth_azuread(self, value: Optional[pulumi.Input['GrafanaGrafanaUserConfigAuthAzureadArgs']]):
        pulumi.set(self, "auth_azuread", value)

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

    @auth_basic_enabled.setter
    def auth_basic_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "auth_basic_enabled", value)

    @property
    @pulumi.getter(name="authGenericOauth")
    def auth_generic_oauth(self) -> Optional[pulumi.Input['GrafanaGrafanaUserConfigAuthGenericOauthArgs']]:
        return pulumi.get(self, "auth_generic_oauth")

    @auth_generic_oauth.setter
    def auth_generic_oauth(self, value: Optional[pulumi.Input['GrafanaGrafanaUserConfigAuthGenericOauthArgs']]):
        pulumi.set(self, "auth_generic_oauth", value)

    @property
    @pulumi.getter(name="authGithub")
    def auth_github(self) -> Optional[pulumi.Input['GrafanaGrafanaUserConfigAuthGithubArgs']]:
        return pulumi.get(self, "auth_github")

    @auth_github.setter
    def auth_github(self, value: Optional[pulumi.Input['GrafanaGrafanaUserConfigAuthGithubArgs']]):
        pulumi.set(self, "auth_github", value)

    @property
    @pulumi.getter(name="authGitlab")
    def auth_gitlab(self) -> Optional[pulumi.Input['GrafanaGrafanaUserConfigAuthGitlabArgs']]:
        return pulumi.get(self, "auth_gitlab")

    @auth_gitlab.setter
    def auth_gitlab(self, value: Optional[pulumi.Input['GrafanaGrafanaUserConfigAuthGitlabArgs']]):
        pulumi.set(self, "auth_gitlab", value)

    @property
    @pulumi.getter(name="authGoogle")
    def auth_google(self) -> Optional[pulumi.Input['GrafanaGrafanaUserConfigAuthGoogleArgs']]:
        return pulumi.get(self, "auth_google")

    @auth_google.setter
    def auth_google(self, value: Optional[pulumi.Input['GrafanaGrafanaUserConfigAuthGoogleArgs']]):
        pulumi.set(self, "auth_google", value)

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

    @cookie_samesite.setter
    def cookie_samesite(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cookie_samesite", value)

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

    @custom_domain.setter
    def custom_domain(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "custom_domain", value)

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

    @dashboard_previews_enabled.setter
    def dashboard_previews_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "dashboard_previews_enabled", value)

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

    @dashboards_min_refresh_interval.setter
    def dashboards_min_refresh_interval(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dashboards_min_refresh_interval", value)

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

    @dashboards_versions_to_keep.setter
    def dashboards_versions_to_keep(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "dashboards_versions_to_keep", value)

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

    @dataproxy_send_user_header.setter
    def dataproxy_send_user_header(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "dataproxy_send_user_header", value)

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

    @dataproxy_timeout.setter
    def dataproxy_timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "dataproxy_timeout", value)

    @property
    @pulumi.getter(name="dateFormats")
    def date_formats(self) -> Optional[pulumi.Input['GrafanaGrafanaUserConfigDateFormatsArgs']]:
        return pulumi.get(self, "date_formats")

    @date_formats.setter
    def date_formats(self, value: Optional[pulumi.Input['GrafanaGrafanaUserConfigDateFormatsArgs']]):
        pulumi.set(self, "date_formats", value)

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

    @disable_gravatar.setter
    def disable_gravatar(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable_gravatar", value)

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

    @editors_can_admin.setter
    def editors_can_admin(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "editors_can_admin", value)

    @property
    @pulumi.getter(name="externalImageStorage")
    def external_image_storage(self) -> Optional[pulumi.Input['GrafanaGrafanaUserConfigExternalImageStorageArgs']]:
        return pulumi.get(self, "external_image_storage")

    @external_image_storage.setter
    def external_image_storage(self, value: Optional[pulumi.Input['GrafanaGrafanaUserConfigExternalImageStorageArgs']]):
        pulumi.set(self, "external_image_storage", value)

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

    @google_analytics_ua_id.setter
    def google_analytics_ua_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "google_analytics_ua_id", value)

    @property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['GrafanaGrafanaUserConfigIpFilterObjectArgs']]]]:
        return pulumi.get(self, "ip_filter_objects")

    @ip_filter_objects.setter
    def ip_filter_objects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['GrafanaGrafanaUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

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

    @ip_filter_strings.setter
    def ip_filter_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @property
    @pulumi.getter(name="ipFilters")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
        pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")

        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filters", value)

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

    @metrics_enabled.setter
    def metrics_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "metrics_enabled", value)

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

    @oauth_allow_insecure_email_lookup.setter
    def oauth_allow_insecure_email_lookup(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "oauth_allow_insecure_email_lookup", value)

    @property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['GrafanaGrafanaUserConfigPrivateAccessArgs']]:
        return pulumi.get(self, "private_access")

    @private_access.setter
    def private_access(self, value: Optional[pulumi.Input['GrafanaGrafanaUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['GrafanaGrafanaUserConfigPrivatelinkAccessArgs']]:
        return pulumi.get(self, "privatelink_access")

    @privatelink_access.setter
    def privatelink_access(self, value: Optional[pulumi.Input['GrafanaGrafanaUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)

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

    @project_to_fork_from.setter
    def project_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "project_to_fork_from", value)

    @property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['GrafanaGrafanaUserConfigPublicAccessArgs']]:
        return pulumi.get(self, "public_access")

    @public_access.setter
    def public_access(self, value: Optional[pulumi.Input['GrafanaGrafanaUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

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

    @recovery_basebackup_name.setter
    def recovery_basebackup_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "recovery_basebackup_name", value)

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

    @service_to_fork_from.setter
    def service_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_to_fork_from", value)

    @property
    @pulumi.getter(name="smtpServer")
    def smtp_server(self) -> Optional[pulumi.Input['GrafanaGrafanaUserConfigSmtpServerArgs']]:
        return pulumi.get(self, "smtp_server")

    @smtp_server.setter
    def smtp_server(self, value: Optional[pulumi.Input['GrafanaGrafanaUserConfigSmtpServerArgs']]):
        pulumi.set(self, "smtp_server", value)

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

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "static_ips", value)

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

    @user_auto_assign_org.setter
    def user_auto_assign_org(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "user_auto_assign_org", value)

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

    @user_auto_assign_org_role.setter
    def user_auto_assign_org_role(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "user_auto_assign_org_role", value)

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

    @viewers_can_edit.setter
    def viewers_can_edit(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "viewers_can_edit", value)


@pulumi.input_type
class GrafanaGrafanaUserConfigAuthAzureadArgs:
    def __init__(__self__, *,
                 auth_url: pulumi.Input[str],
                 client_id: pulumi.Input[str],
                 client_secret: pulumi.Input[str],
                 token_url: pulumi.Input[str],
                 allow_sign_up: Optional[pulumi.Input[bool]] = None,
                 allowed_domains: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allowed_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        pulumi.set(__self__, "token_url", token_url)
        if allow_sign_up is not None:
            pulumi.set(__self__, "allow_sign_up", allow_sign_up)
        if allowed_domains is not None:
            pulumi.set(__self__, "allowed_domains", allowed_domains)
        if allowed_groups is not None:
            pulumi.set(__self__, "allowed_groups", allowed_groups)

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

    @auth_url.setter
    def auth_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "auth_url", value)

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

    @client_id.setter
    def client_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_id", value)

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

    @client_secret.setter
    def client_secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_secret", value)

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

    @token_url.setter
    def token_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "token_url", value)

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

    @allow_sign_up.setter
    def allow_sign_up(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_sign_up", value)

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

    @allowed_domains.setter
    def allowed_domains(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allowed_domains", value)

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

    @allowed_groups.setter
    def allowed_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allowed_groups", value)


@pulumi.input_type
class GrafanaGrafanaUserConfigAuthGenericOauthArgs:
    def __init__(__self__, *,
                 api_url: pulumi.Input[str],
                 auth_url: pulumi.Input[str],
                 client_id: pulumi.Input[str],
                 client_secret: pulumi.Input[str],
                 token_url: pulumi.Input[str],
                 allow_sign_up: Optional[pulumi.Input[bool]] = None,
                 allowed_domains: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 allowed_organizations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 auto_login: Optional[pulumi.Input[bool]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 scopes: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "api_url", api_url)
        pulumi.set(__self__, "auth_url", auth_url)
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        pulumi.set(__self__, "token_url", token_url)
        if allow_sign_up is not None:
            pulumi.set(__self__, "allow_sign_up", allow_sign_up)
        if allowed_domains is not None:
            pulumi.set(__self__, "allowed_domains", allowed_domains)
        if allowed_organizations is not None:
            pulumi.set(__self__, "allowed_organizations", allowed_organizations)
        if auto_login is not None:
            pulumi.set(__self__, "auto_login", auto_login)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if scopes is not None:
            pulumi.set(__self__, "scopes", scopes)

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

    @api_url.setter
    def api_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "api_url", value)

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

    @auth_url.setter
    def auth_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "auth_url", value)

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

    @client_id.setter
    def client_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_id", value)

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

    @client_secret.setter
    def client_secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_secret", value)

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

    @token_url.setter
    def token_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "token_url", value)

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

    @allow_sign_up.setter
    def allow_sign_up(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_sign_up", value)

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

    @allowed_domains.setter
    def allowed_domains(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allowed_domains", value)

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

    @allowed_organizations.setter
    def allowed_organizations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allowed_organizations", value)

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

    @auto_login.setter
    def auto_login(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "auto_login", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

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

    @scopes.setter
    def scopes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "scopes", value)


@pulumi.input_type
class GrafanaGrafanaUserConfigAuthGithubArgs:
    def __init__(__self__, *,
                 client_id: pulumi.Input[str],
                 client_secret: pulumi.Input[str],
                 allow_sign_up: Optional[pulumi.Input[bool]] = None,
                 allowed_organizations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 team_ids: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]] = None):
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        if allow_sign_up is not None:
            pulumi.set(__self__, "allow_sign_up", allow_sign_up)
        if allowed_organizations is not None:
            pulumi.set(__self__, "allowed_organizations", allowed_organizations)
        if team_ids is not None:
            pulumi.set(__self__, "team_ids", team_ids)

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

    @client_id.setter
    def client_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_id", value)

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

    @client_secret.setter
    def client_secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_secret", value)

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

    @allow_sign_up.setter
    def allow_sign_up(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_sign_up", value)

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

    @allowed_organizations.setter
    def allowed_organizations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allowed_organizations", value)

    @property
    @pulumi.getter(name="teamIds")
    def team_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]:
        return pulumi.get(self, "team_ids")

    @team_ids.setter
    def team_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[int]]]]):
        pulumi.set(self, "team_ids", value)


@pulumi.input_type
class GrafanaGrafanaUserConfigAuthGitlabArgs:
    def __init__(__self__, *,
                 client_id: pulumi.Input[str],
                 client_secret: pulumi.Input[str],
                 allow_sign_up: Optional[pulumi.Input[bool]] = None,
                 allowed_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 api_url: Optional[pulumi.Input[str]] = None,
                 auth_url: Optional[pulumi.Input[str]] = None,
                 token_url: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        if allow_sign_up is not None:
            pulumi.set(__self__, "allow_sign_up", allow_sign_up)
        if allowed_groups is not None:
            pulumi.set(__self__, "allowed_groups", allowed_groups)
        if api_url is not None:
            pulumi.set(__self__, "api_url", api_url)
        if auth_url is not None:
            pulumi.set(__self__, "auth_url", auth_url)
        if token_url is not None:
            pulumi.set(__self__, "token_url", token_url)

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

    @client_id.setter
    def client_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_id", value)

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

    @client_secret.setter
    def client_secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_secret", value)

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

    @allow_sign_up.setter
    def allow_sign_up(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_sign_up", value)

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

    @allowed_groups.setter
    def allowed_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allowed_groups", value)

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

    @api_url.setter
    def api_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "api_url", value)

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

    @auth_url.setter
    def auth_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "auth_url", value)

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

    @token_url.setter
    def token_url(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "token_url", value)


@pulumi.input_type
class GrafanaGrafanaUserConfigAuthGoogleArgs:
    def __init__(__self__, *,
                 client_id: pulumi.Input[str],
                 client_secret: pulumi.Input[str],
                 allow_sign_up: Optional[pulumi.Input[bool]] = None,
                 allowed_domains: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        if allow_sign_up is not None:
            pulumi.set(__self__, "allow_sign_up", allow_sign_up)
        if allowed_domains is not None:
            pulumi.set(__self__, "allowed_domains", allowed_domains)

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

    @client_id.setter
    def client_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_id", value)

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

    @client_secret.setter
    def client_secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_secret", value)

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

    @allow_sign_up.setter
    def allow_sign_up(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_sign_up", value)

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

    @allowed_domains.setter
    def allowed_domains(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "allowed_domains", value)


@pulumi.input_type
class GrafanaGrafanaUserConfigDateFormatsArgs:
    def __init__(__self__, *,
                 default_timezone: Optional[pulumi.Input[str]] = None,
                 full_date: Optional[pulumi.Input[str]] = None,
                 interval_day: Optional[pulumi.Input[str]] = None,
                 interval_hour: Optional[pulumi.Input[str]] = None,
                 interval_minute: Optional[pulumi.Input[str]] = None,
                 interval_month: Optional[pulumi.Input[str]] = None,
                 interval_second: Optional[pulumi.Input[str]] = None,
                 interval_year: Optional[pulumi.Input[str]] = None):
        if default_timezone is not None:
            pulumi.set(__self__, "default_timezone", default_timezone)
        if full_date is not None:
            pulumi.set(__self__, "full_date", full_date)
        if interval_day is not None:
            pulumi.set(__self__, "interval_day", interval_day)
        if interval_hour is not None:
            pulumi.set(__self__, "interval_hour", interval_hour)
        if interval_minute is not None:
            pulumi.set(__self__, "interval_minute", interval_minute)
        if interval_month is not None:
            pulumi.set(__self__, "interval_month", interval_month)
        if interval_second is not None:
            pulumi.set(__self__, "interval_second", interval_second)
        if interval_year is not None:
            pulumi.set(__self__, "interval_year", interval_year)

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

    @default_timezone.setter
    def default_timezone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "default_timezone", value)

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

    @full_date.setter
    def full_date(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "full_date", value)

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

    @interval_day.setter
    def interval_day(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "interval_day", value)

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

    @interval_hour.setter
    def interval_hour(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "interval_hour", value)

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

    @interval_minute.setter
    def interval_minute(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "interval_minute", value)

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

    @interval_month.setter
    def interval_month(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "interval_month", value)

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

    @interval_second.setter
    def interval_second(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "interval_second", value)

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

    @interval_year.setter
    def interval_year(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "interval_year", value)


@pulumi.input_type
class GrafanaGrafanaUserConfigExternalImageStorageArgs:
    def __init__(__self__, *,
                 access_key: pulumi.Input[str],
                 bucket_url: pulumi.Input[str],
                 provider: pulumi.Input[str],
                 secret_key: pulumi.Input[str]):
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "bucket_url", bucket_url)
        pulumi.set(__self__, "provider", provider)
        pulumi.set(__self__, "secret_key", secret_key)

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

    @access_key.setter
    def access_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "access_key", value)

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

    @bucket_url.setter
    def bucket_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "bucket_url", value)

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

    @provider.setter
    def provider(self, value: pulumi.Input[str]):
        pulumi.set(self, "provider", value)

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

    @secret_key.setter
    def secret_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret_key", value)


@pulumi.input_type
class GrafanaGrafanaUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

    @network.setter
    def network(self, value: pulumi.Input[str]):
        pulumi.set(self, "network", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class GrafanaGrafanaUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 grafana: Optional[pulumi.Input[bool]] = None):
        if grafana is not None:
            pulumi.set(__self__, "grafana", grafana)

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

    @grafana.setter
    def grafana(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "grafana", value)


@pulumi.input_type
class GrafanaGrafanaUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 grafana: Optional[pulumi.Input[bool]] = None):
        if grafana is not None:
            pulumi.set(__self__, "grafana", grafana)

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

    @grafana.setter
    def grafana(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "grafana", value)


@pulumi.input_type
class GrafanaGrafanaUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 grafana: Optional[pulumi.Input[bool]] = None):
        if grafana is not None:
            pulumi.set(__self__, "grafana", grafana)

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

    @grafana.setter
    def grafana(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "grafana", value)


@pulumi.input_type
class GrafanaGrafanaUserConfigSmtpServerArgs:
    def __init__(__self__, *,
                 from_address: pulumi.Input[str],
                 host: pulumi.Input[str],
                 port: pulumi.Input[int],
                 from_name: Optional[pulumi.Input[str]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 skip_verify: Optional[pulumi.Input[bool]] = None,
                 starttls_policy: Optional[pulumi.Input[str]] = None,
                 username: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "from_address", from_address)
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)
        if from_name is not None:
            pulumi.set(__self__, "from_name", from_name)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if skip_verify is not None:
            pulumi.set(__self__, "skip_verify", skip_verify)
        if starttls_policy is not None:
            pulumi.set(__self__, "starttls_policy", starttls_policy)
        if username is not None:
            pulumi.set(__self__, "username", username)

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

    @from_address.setter
    def from_address(self, value: pulumi.Input[str]):
        pulumi.set(self, "from_address", value)

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

    @host.setter
    def host(self, value: pulumi.Input[str]):
        pulumi.set(self, "host", value)

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

    @port.setter
    def port(self, value: pulumi.Input[int]):
        pulumi.set(self, "port", value)

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

    @from_name.setter
    def from_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "from_name", value)

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

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

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

    @skip_verify.setter
    def skip_verify(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "skip_verify", value)

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

    @starttls_policy.setter
    def starttls_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "starttls_policy", value)

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

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)


@pulumi.input_type
class GrafanaServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[str],
                 source_service_name: pulumi.Input[str]):
        pulumi.set(__self__, "integration_type", integration_type)
        pulumi.set(__self__, "source_service_name", source_service_name)

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

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "integration_type", value)

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

    @source_service_name.setter
    def source_service_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "source_service_name", value)


@pulumi.input_type
class GrafanaTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class InfluxDbComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[str]] = None,
                 host: Optional[pulumi.Input[str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 route: Optional[pulumi.Input[str]] = None,
                 ssl: Optional[pulumi.Input[bool]] = None,
                 usage: Optional[pulumi.Input[str]] = None):
        if component is not None:
            pulumi.set(__self__, "component", component)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if kafka_authentication_method is not None:
            pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if route is not None:
            pulumi.set(__self__, "route", route)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if usage is not None:
            pulumi.set(__self__, "usage", usage)

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

    @component.setter
    def component(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "component", value)

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

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

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

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kafka_authentication_method", 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
    def route(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route", value)

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

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl", value)

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

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "usage", value)


@pulumi.input_type
class InfluxDbInfluxdbArgs:
    def __init__(__self__, *,
                 database_name: Optional[pulumi.Input[str]] = None):
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)

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

    @database_name.setter
    def database_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "database_name", value)


@pulumi.input_type
class InfluxDbInfluxdbUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[str]] = None,
                 custom_domain: Optional[pulumi.Input[str]] = None,
                 influxdb: Optional[pulumi.Input['InfluxDbInfluxdbUserConfigInfluxdbArgs']] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['InfluxDbInfluxdbUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 private_access: Optional[pulumi.Input['InfluxDbInfluxdbUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['InfluxDbInfluxdbUserConfigPrivatelinkAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[str]] = None,
                 public_access: Optional[pulumi.Input['InfluxDbInfluxdbUserConfigPublicAccessArgs']] = None,
                 recovery_basebackup_name: Optional[pulumi.Input[str]] = None,
                 service_to_fork_from: Optional[pulumi.Input[str]] = None,
                 static_ips: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[str] custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name.
        :param pulumi.Input['InfluxDbInfluxdbUserConfigInfluxdbArgs'] influxdb: influxdb.conf configuration values.
        :param pulumi.Input[Sequence[pulumi.Input['InfluxDbInfluxdbUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input['InfluxDbInfluxdbUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks.
        :param pulumi.Input['InfluxDbInfluxdbUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink.
        :param pulumi.Input[str] project_to_fork_from: Name of another project to fork a service from. This has effect only when a new service is being created.
        :param pulumi.Input['InfluxDbInfluxdbUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet.
        :param pulumi.Input[str] recovery_basebackup_name: Name of the basebackup to restore in forked service.
        :param pulumi.Input[str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created.
        :param pulumi.Input[bool] static_ips: Use static public IP addresses.
        """
        if additional_backup_regions is not None:
            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
        if custom_domain is not None:
            pulumi.set(__self__, "custom_domain", custom_domain)
        if influxdb is not None:
            pulumi.set(__self__, "influxdb", influxdb)
        if ip_filter_objects is not None:
            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
        if ip_filter_strings is not None:
            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
        if ip_filters is not None:
            warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        if private_access is not None:
            pulumi.set(__self__, "private_access", private_access)
        if privatelink_access is not None:
            pulumi.set(__self__, "privatelink_access", privatelink_access)
        if project_to_fork_from is not None:
            pulumi.set(__self__, "project_to_fork_from", project_to_fork_from)
        if public_access is not None:
            pulumi.set(__self__, "public_access", public_access)
        if recovery_basebackup_name is not None:
            pulumi.set(__self__, "recovery_basebackup_name", recovery_basebackup_name)
        if service_to_fork_from is not None:
            pulumi.set(__self__, "service_to_fork_from", service_to_fork_from)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)

    @property
    @pulumi.getter(name="additionalBackupRegions")
    def additional_backup_regions(self) -> Optional[pulumi.Input[str]]:
        """
        Additional Cloud Regions for Backup Replication.
        """
        return pulumi.get(self, "additional_backup_regions")

    @additional_backup_regions.setter
    def additional_backup_regions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @property
    @pulumi.getter(name="customDomain")
    def custom_domain(self) -> Optional[pulumi.Input[str]]:
        """
        Serve the web frontend using a custom CNAME pointing to the Aiven DNS name.
        """
        return pulumi.get(self, "custom_domain")

    @custom_domain.setter
    def custom_domain(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "custom_domain", value)

    @property
    @pulumi.getter
    def influxdb(self) -> Optional[pulumi.Input['InfluxDbInfluxdbUserConfigInfluxdbArgs']]:
        """
        influxdb.conf configuration values.
        """
        return pulumi.get(self, "influxdb")

    @influxdb.setter
    def influxdb(self, value: Optional[pulumi.Input['InfluxDbInfluxdbUserConfigInfluxdbArgs']]):
        pulumi.set(self, "influxdb", value)

    @property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InfluxDbInfluxdbUserConfigIpFilterObjectArgs']]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        return pulumi.get(self, "ip_filter_objects")

    @ip_filter_objects.setter
    def ip_filter_objects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InfluxDbInfluxdbUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        return pulumi.get(self, "ip_filter_strings")

    @ip_filter_strings.setter
    def ip_filter_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @property
    @pulumi.getter(name="ipFilters")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
        pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")

        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filters", value)

    @property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['InfluxDbInfluxdbUserConfigPrivateAccessArgs']]:
        """
        Allow access to selected service ports from private networks.
        """
        return pulumi.get(self, "private_access")

    @private_access.setter
    def private_access(self, value: Optional[pulumi.Input['InfluxDbInfluxdbUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['InfluxDbInfluxdbUserConfigPrivatelinkAccessArgs']]:
        """
        Allow access to selected service components through Privatelink.
        """
        return pulumi.get(self, "privatelink_access")

    @privatelink_access.setter
    def privatelink_access(self, value: Optional[pulumi.Input['InfluxDbInfluxdbUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)

    @property
    @pulumi.getter(name="projectToForkFrom")
    def project_to_fork_from(self) -> Optional[pulumi.Input[str]]:
        """
        Name of another project to fork a service from. This has effect only when a new service is being created.
        """
        return pulumi.get(self, "project_to_fork_from")

    @project_to_fork_from.setter
    def project_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "project_to_fork_from", value)

    @property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['InfluxDbInfluxdbUserConfigPublicAccessArgs']]:
        """
        Allow access to selected service ports from the public Internet.
        """
        return pulumi.get(self, "public_access")

    @public_access.setter
    def public_access(self, value: Optional[pulumi.Input['InfluxDbInfluxdbUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

    @property
    @pulumi.getter(name="recoveryBasebackupName")
    def recovery_basebackup_name(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the basebackup to restore in forked service.
        """
        return pulumi.get(self, "recovery_basebackup_name")

    @recovery_basebackup_name.setter
    def recovery_basebackup_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "recovery_basebackup_name", value)

    @property
    @pulumi.getter(name="serviceToForkFrom")
    def service_to_fork_from(self) -> Optional[pulumi.Input[str]]:
        """
        Name of another service to fork from. This has effect only when a new service is being created.
        """
        return pulumi.get(self, "service_to_fork_from")

    @service_to_fork_from.setter
    def service_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_to_fork_from", value)

    @property
    @pulumi.getter(name="staticIps")
    def static_ips(self) -> Optional[pulumi.Input[bool]]:
        """
        Use static public IP addresses.
        """
        return pulumi.get(self, "static_ips")

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "static_ips", value)


@pulumi.input_type
class InfluxDbInfluxdbUserConfigInfluxdbArgs:
    def __init__(__self__, *,
                 log_queries_after: Optional[pulumi.Input[int]] = None,
                 max_connection_limit: Optional[pulumi.Input[int]] = None,
                 max_row_limit: Optional[pulumi.Input[int]] = None,
                 max_select_buckets: Optional[pulumi.Input[int]] = None,
                 max_select_point: Optional[pulumi.Input[int]] = None,
                 query_log_enabled: Optional[pulumi.Input[bool]] = None,
                 query_timeout: Optional[pulumi.Input[int]] = None):
        if log_queries_after is not None:
            pulumi.set(__self__, "log_queries_after", log_queries_after)
        if max_connection_limit is not None:
            pulumi.set(__self__, "max_connection_limit", max_connection_limit)
        if max_row_limit is not None:
            pulumi.set(__self__, "max_row_limit", max_row_limit)
        if max_select_buckets is not None:
            pulumi.set(__self__, "max_select_buckets", max_select_buckets)
        if max_select_point is not None:
            pulumi.set(__self__, "max_select_point", max_select_point)
        if query_log_enabled is not None:
            pulumi.set(__self__, "query_log_enabled", query_log_enabled)
        if query_timeout is not None:
            pulumi.set(__self__, "query_timeout", query_timeout)

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

    @log_queries_after.setter
    def log_queries_after(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_queries_after", value)

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

    @max_connection_limit.setter
    def max_connection_limit(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_connection_limit", value)

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

    @max_row_limit.setter
    def max_row_limit(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_row_limit", value)

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

    @max_select_buckets.setter
    def max_select_buckets(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_select_buckets", value)

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

    @max_select_point.setter
    def max_select_point(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_select_point", value)

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

    @query_log_enabled.setter
    def query_log_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "query_log_enabled", value)

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

    @query_timeout.setter
    def query_timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "query_timeout", value)


@pulumi.input_type
class InfluxDbInfluxdbUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

    @network.setter
    def network(self, value: pulumi.Input[str]):
        pulumi.set(self, "network", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class InfluxDbInfluxdbUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 influxdb: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] influxdb: InfluxDB server provided values
        """
        if influxdb is not None:
            pulumi.set(__self__, "influxdb", influxdb)

    @property
    @pulumi.getter
    def influxdb(self) -> Optional[pulumi.Input[bool]]:
        """
        InfluxDB server provided values
        """
        return pulumi.get(self, "influxdb")

    @influxdb.setter
    def influxdb(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "influxdb", value)


@pulumi.input_type
class InfluxDbInfluxdbUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 influxdb: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] influxdb: InfluxDB server provided values
        """
        if influxdb is not None:
            pulumi.set(__self__, "influxdb", influxdb)

    @property
    @pulumi.getter
    def influxdb(self) -> Optional[pulumi.Input[bool]]:
        """
        InfluxDB server provided values
        """
        return pulumi.get(self, "influxdb")

    @influxdb.setter
    def influxdb(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "influxdb", value)


@pulumi.input_type
class InfluxDbInfluxdbUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 influxdb: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] influxdb: InfluxDB server provided values
        """
        if influxdb is not None:
            pulumi.set(__self__, "influxdb", influxdb)

    @property
    @pulumi.getter
    def influxdb(self) -> Optional[pulumi.Input[bool]]:
        """
        InfluxDB server provided values
        """
        return pulumi.get(self, "influxdb")

    @influxdb.setter
    def influxdb(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "influxdb", value)


@pulumi.input_type
class InfluxDbServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[str],
                 source_service_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] integration_type: Type of the service integration. The only supported value at the moment is `read_replica`
        :param pulumi.Input[str] source_service_name: Name of the source service
        """
        pulumi.set(__self__, "integration_type", integration_type)
        pulumi.set(__self__, "source_service_name", source_service_name)

    @property
    @pulumi.getter(name="integrationType")
    def integration_type(self) -> pulumi.Input[str]:
        """
        Type of the service integration. The only supported value at the moment is `read_replica`
        """
        return pulumi.get(self, "integration_type")

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "integration_type", value)

    @property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[str]:
        """
        Name of the source service
        """
        return pulumi.get(self, "source_service_name")

    @source_service_name.setter
    def source_service_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "source_service_name", value)


@pulumi.input_type
class InfluxDbTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: Service tag key
        :param pulumi.Input[str] value: Service tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        Service tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class KafkaComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[str]] = None,
                 host: Optional[pulumi.Input[str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 route: Optional[pulumi.Input[str]] = None,
                 ssl: Optional[pulumi.Input[bool]] = None,
                 usage: Optional[pulumi.Input[str]] = None):
        if component is not None:
            pulumi.set(__self__, "component", component)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if kafka_authentication_method is not None:
            pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if route is not None:
            pulumi.set(__self__, "route", route)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if usage is not None:
            pulumi.set(__self__, "usage", usage)

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

    @component.setter
    def component(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "component", value)

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

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

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

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kafka_authentication_method", 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
    def route(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route", value)

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

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl", value)

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

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "usage", value)


@pulumi.input_type
class KafkaConnectComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[str]] = None,
                 host: Optional[pulumi.Input[str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 route: Optional[pulumi.Input[str]] = None,
                 ssl: Optional[pulumi.Input[bool]] = None,
                 usage: Optional[pulumi.Input[str]] = None):
        if component is not None:
            pulumi.set(__self__, "component", component)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if kafka_authentication_method is not None:
            pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if route is not None:
            pulumi.set(__self__, "route", route)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if usage is not None:
            pulumi.set(__self__, "usage", usage)

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

    @component.setter
    def component(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "component", value)

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

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

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

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kafka_authentication_method", 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
    def route(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route", value)

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

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl", value)

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

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "usage", value)


@pulumi.input_type
class KafkaConnectKafkaConnectArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class KafkaConnectKafkaConnectUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['KafkaConnectKafkaConnectUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 kafka_connect: Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigKafkaConnectArgs']] = None,
                 private_access: Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigPrivatelinkAccessArgs']] = None,
                 public_access: Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigPublicAccessArgs']] = None,
                 static_ips: Optional[pulumi.Input[bool]] = None):
        if additional_backup_regions is not None:
            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
        if ip_filter_objects is not None:
            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
        if ip_filter_strings is not None:
            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
        if ip_filters is not None:
            warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        if kafka_connect is not None:
            pulumi.set(__self__, "kafka_connect", kafka_connect)
        if private_access is not None:
            pulumi.set(__self__, "private_access", private_access)
        if privatelink_access is not None:
            pulumi.set(__self__, "privatelink_access", privatelink_access)
        if public_access is not None:
            pulumi.set(__self__, "public_access", public_access)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)

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

    @additional_backup_regions.setter
    def additional_backup_regions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KafkaConnectKafkaConnectUserConfigIpFilterObjectArgs']]]]:
        return pulumi.get(self, "ip_filter_objects")

    @ip_filter_objects.setter
    def ip_filter_objects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['KafkaConnectKafkaConnectUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

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

    @ip_filter_strings.setter
    def ip_filter_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @property
    @pulumi.getter(name="ipFilters")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
        pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")

        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filters", value)

    @property
    @pulumi.getter(name="kafkaConnect")
    def kafka_connect(self) -> Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigKafkaConnectArgs']]:
        return pulumi.get(self, "kafka_connect")

    @kafka_connect.setter
    def kafka_connect(self, value: Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigKafkaConnectArgs']]):
        pulumi.set(self, "kafka_connect", value)

    @property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigPrivateAccessArgs']]:
        return pulumi.get(self, "private_access")

    @private_access.setter
    def private_access(self, value: Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigPrivatelinkAccessArgs']]:
        return pulumi.get(self, "privatelink_access")

    @privatelink_access.setter
    def privatelink_access(self, value: Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)

    @property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigPublicAccessArgs']]:
        return pulumi.get(self, "public_access")

    @public_access.setter
    def public_access(self, value: Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

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

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "static_ips", value)


@pulumi.input_type
class KafkaConnectKafkaConnectUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

    @network.setter
    def network(self, value: pulumi.Input[str]):
        pulumi.set(self, "network", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class KafkaConnectKafkaConnectUserConfigKafkaConnectArgs:
    def __init__(__self__, *,
                 connector_client_config_override_policy: Optional[pulumi.Input[str]] = None,
                 consumer_auto_offset_reset: Optional[pulumi.Input[str]] = None,
                 consumer_fetch_max_bytes: Optional[pulumi.Input[int]] = None,
                 consumer_isolation_level: Optional[pulumi.Input[str]] = None,
                 consumer_max_partition_fetch_bytes: Optional[pulumi.Input[int]] = None,
                 consumer_max_poll_interval_ms: Optional[pulumi.Input[int]] = None,
                 consumer_max_poll_records: Optional[pulumi.Input[int]] = None,
                 offset_flush_interval_ms: Optional[pulumi.Input[int]] = None,
                 offset_flush_timeout_ms: Optional[pulumi.Input[int]] = None,
                 producer_batch_size: Optional[pulumi.Input[int]] = None,
                 producer_buffer_memory: Optional[pulumi.Input[int]] = None,
                 producer_compression_type: Optional[pulumi.Input[str]] = None,
                 producer_linger_ms: Optional[pulumi.Input[int]] = None,
                 producer_max_request_size: Optional[pulumi.Input[int]] = None,
                 scheduled_rebalance_max_delay_ms: Optional[pulumi.Input[int]] = None,
                 session_timeout_ms: Optional[pulumi.Input[int]] = None):
        if connector_client_config_override_policy is not None:
            pulumi.set(__self__, "connector_client_config_override_policy", connector_client_config_override_policy)
        if consumer_auto_offset_reset is not None:
            pulumi.set(__self__, "consumer_auto_offset_reset", consumer_auto_offset_reset)
        if consumer_fetch_max_bytes is not None:
            pulumi.set(__self__, "consumer_fetch_max_bytes", consumer_fetch_max_bytes)
        if consumer_isolation_level is not None:
            pulumi.set(__self__, "consumer_isolation_level", consumer_isolation_level)
        if consumer_max_partition_fetch_bytes is not None:
            pulumi.set(__self__, "consumer_max_partition_fetch_bytes", consumer_max_partition_fetch_bytes)
        if consumer_max_poll_interval_ms is not None:
            pulumi.set(__self__, "consumer_max_poll_interval_ms", consumer_max_poll_interval_ms)
        if consumer_max_poll_records is not None:
            pulumi.set(__self__, "consumer_max_poll_records", consumer_max_poll_records)
        if offset_flush_interval_ms is not None:
            pulumi.set(__self__, "offset_flush_interval_ms", offset_flush_interval_ms)
        if offset_flush_timeout_ms is not None:
            pulumi.set(__self__, "offset_flush_timeout_ms", offset_flush_timeout_ms)
        if producer_batch_size is not None:
            pulumi.set(__self__, "producer_batch_size", producer_batch_size)
        if producer_buffer_memory is not None:
            pulumi.set(__self__, "producer_buffer_memory", producer_buffer_memory)
        if producer_compression_type is not None:
            pulumi.set(__self__, "producer_compression_type", producer_compression_type)
        if producer_linger_ms is not None:
            pulumi.set(__self__, "producer_linger_ms", producer_linger_ms)
        if producer_max_request_size is not None:
            pulumi.set(__self__, "producer_max_request_size", producer_max_request_size)
        if scheduled_rebalance_max_delay_ms is not None:
            pulumi.set(__self__, "scheduled_rebalance_max_delay_ms", scheduled_rebalance_max_delay_ms)
        if session_timeout_ms is not None:
            pulumi.set(__self__, "session_timeout_ms", session_timeout_ms)

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

    @connector_client_config_override_policy.setter
    def connector_client_config_override_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "connector_client_config_override_policy", value)

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

    @consumer_auto_offset_reset.setter
    def consumer_auto_offset_reset(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "consumer_auto_offset_reset", value)

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

    @consumer_fetch_max_bytes.setter
    def consumer_fetch_max_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "consumer_fetch_max_bytes", value)

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

    @consumer_isolation_level.setter
    def consumer_isolation_level(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "consumer_isolation_level", value)

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

    @consumer_max_partition_fetch_bytes.setter
    def consumer_max_partition_fetch_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "consumer_max_partition_fetch_bytes", value)

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

    @consumer_max_poll_interval_ms.setter
    def consumer_max_poll_interval_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "consumer_max_poll_interval_ms", value)

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

    @consumer_max_poll_records.setter
    def consumer_max_poll_records(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "consumer_max_poll_records", value)

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

    @offset_flush_interval_ms.setter
    def offset_flush_interval_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "offset_flush_interval_ms", value)

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

    @offset_flush_timeout_ms.setter
    def offset_flush_timeout_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "offset_flush_timeout_ms", value)

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

    @producer_batch_size.setter
    def producer_batch_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "producer_batch_size", value)

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

    @producer_buffer_memory.setter
    def producer_buffer_memory(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "producer_buffer_memory", value)

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

    @producer_compression_type.setter
    def producer_compression_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "producer_compression_type", value)

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

    @producer_linger_ms.setter
    def producer_linger_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "producer_linger_ms", value)

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

    @producer_max_request_size.setter
    def producer_max_request_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "producer_max_request_size", value)

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

    @scheduled_rebalance_max_delay_ms.setter
    def scheduled_rebalance_max_delay_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "scheduled_rebalance_max_delay_ms", value)

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

    @session_timeout_ms.setter
    def session_timeout_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "session_timeout_ms", value)


@pulumi.input_type
class KafkaConnectKafkaConnectUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 kafka_connect: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        if kafka_connect is not None:
            pulumi.set(__self__, "kafka_connect", kafka_connect)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

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

    @kafka_connect.setter
    def kafka_connect(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "kafka_connect", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class KafkaConnectKafkaConnectUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 jolokia: Optional[pulumi.Input[bool]] = None,
                 kafka_connect: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        if jolokia is not None:
            pulumi.set(__self__, "jolokia", jolokia)
        if kafka_connect is not None:
            pulumi.set(__self__, "kafka_connect", kafka_connect)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

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

    @jolokia.setter
    def jolokia(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "jolokia", value)

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

    @kafka_connect.setter
    def kafka_connect(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "kafka_connect", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class KafkaConnectKafkaConnectUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 kafka_connect: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        if kafka_connect is not None:
            pulumi.set(__self__, "kafka_connect", kafka_connect)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

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

    @kafka_connect.setter
    def kafka_connect(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "kafka_connect", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class KafkaConnectServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[str],
                 source_service_name: pulumi.Input[str]):
        pulumi.set(__self__, "integration_type", integration_type)
        pulumi.set(__self__, "source_service_name", source_service_name)

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

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "integration_type", value)

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

    @source_service_name.setter
    def source_service_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "source_service_name", value)


@pulumi.input_type
class KafkaConnectTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class KafkaConnectorTaskArgs:
    def __init__(__self__, *,
                 connector: Optional[pulumi.Input[str]] = None,
                 task: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[int] task: List of tasks of a connector.
        """
        if connector is not None:
            pulumi.set(__self__, "connector", connector)
        if task is not None:
            pulumi.set(__self__, "task", task)

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

    @connector.setter
    def connector(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "connector", value)

    @property
    @pulumi.getter
    def task(self) -> Optional[pulumi.Input[int]]:
        """
        List of tasks of a connector.
        """
        return pulumi.get(self, "task")

    @task.setter
    def task(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "task", value)


@pulumi.input_type
class KafkaKafkaArgs:
    def __init__(__self__, *,
                 access_cert: Optional[pulumi.Input[str]] = None,
                 access_key: Optional[pulumi.Input[str]] = None,
                 connect_uri: Optional[pulumi.Input[str]] = None,
                 rest_uri: Optional[pulumi.Input[str]] = None,
                 schema_registry_uri: Optional[pulumi.Input[str]] = None):
        if access_cert is not None:
            pulumi.set(__self__, "access_cert", access_cert)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if connect_uri is not None:
            pulumi.set(__self__, "connect_uri", connect_uri)
        if rest_uri is not None:
            pulumi.set(__self__, "rest_uri", rest_uri)
        if schema_registry_uri is not None:
            pulumi.set(__self__, "schema_registry_uri", schema_registry_uri)

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

    @access_cert.setter
    def access_cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "access_cert", value)

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

    @access_key.setter
    def access_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "access_key", value)

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

    @connect_uri.setter
    def connect_uri(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "connect_uri", value)

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

    @rest_uri.setter
    def rest_uri(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "rest_uri", value)

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

    @schema_registry_uri.setter
    def schema_registry_uri(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "schema_registry_uri", value)


@pulumi.input_type
class KafkaKafkaUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[str]] = None,
                 custom_domain: Optional[pulumi.Input[str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['KafkaKafkaUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 kafka: Optional[pulumi.Input['KafkaKafkaUserConfigKafkaArgs']] = None,
                 kafka_authentication_methods: Optional[pulumi.Input['KafkaKafkaUserConfigKafkaAuthenticationMethodsArgs']] = None,
                 kafka_connect: Optional[pulumi.Input[bool]] = None,
                 kafka_connect_config: Optional[pulumi.Input['KafkaKafkaUserConfigKafkaConnectConfigArgs']] = None,
                 kafka_rest: Optional[pulumi.Input[bool]] = None,
                 kafka_rest_authorization: Optional[pulumi.Input[bool]] = None,
                 kafka_rest_config: Optional[pulumi.Input['KafkaKafkaUserConfigKafkaRestConfigArgs']] = None,
                 kafka_version: Optional[pulumi.Input[str]] = None,
                 private_access: Optional[pulumi.Input['KafkaKafkaUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['KafkaKafkaUserConfigPrivatelinkAccessArgs']] = None,
                 public_access: Optional[pulumi.Input['KafkaKafkaUserConfigPublicAccessArgs']] = None,
                 schema_registry: Optional[pulumi.Input[bool]] = None,
                 schema_registry_config: Optional[pulumi.Input['KafkaKafkaUserConfigSchemaRegistryConfigArgs']] = None,
                 static_ips: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[str] custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name.
        :param pulumi.Input[Sequence[pulumi.Input['KafkaKafkaUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input['KafkaKafkaUserConfigKafkaArgs'] kafka: Kafka broker configuration values.
        :param pulumi.Input['KafkaKafkaUserConfigKafkaAuthenticationMethodsArgs'] kafka_authentication_methods: Kafka authentication methods.
        :param pulumi.Input[bool] kafka_connect: Enable Kafka Connect service. The default value is `false`.
        :param pulumi.Input['KafkaKafkaUserConfigKafkaConnectConfigArgs'] kafka_connect_config: Kafka Connect configuration values.
        :param pulumi.Input[bool] kafka_rest: Enable Kafka-REST service. The default value is `false`.
        :param pulumi.Input[bool] kafka_rest_authorization: Enable authorization in Kafka-REST service.
        :param pulumi.Input['KafkaKafkaUserConfigKafkaRestConfigArgs'] kafka_rest_config: Kafka REST configuration.
        :param pulumi.Input[str] kafka_version: Kafka major version.
        :param pulumi.Input['KafkaKafkaUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks.
        :param pulumi.Input['KafkaKafkaUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink.
        :param pulumi.Input['KafkaKafkaUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet.
        :param pulumi.Input[bool] schema_registry: Enable Schema-Registry service. The default value is `false`.
        :param pulumi.Input['KafkaKafkaUserConfigSchemaRegistryConfigArgs'] schema_registry_config: Schema Registry configuration.
        :param pulumi.Input[bool] static_ips: Use static public IP addresses.
        """
        if additional_backup_regions is not None:
            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
        if custom_domain is not None:
            pulumi.set(__self__, "custom_domain", custom_domain)
        if ip_filter_objects is not None:
            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
        if ip_filter_strings is not None:
            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
        if ip_filters is not None:
            warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        if kafka is not None:
            pulumi.set(__self__, "kafka", kafka)
        if kafka_authentication_methods is not None:
            pulumi.set(__self__, "kafka_authentication_methods", kafka_authentication_methods)
        if kafka_connect is not None:
            pulumi.set(__self__, "kafka_connect", kafka_connect)
        if kafka_connect_config is not None:
            pulumi.set(__self__, "kafka_connect_config", kafka_connect_config)
        if kafka_rest is not None:
            pulumi.set(__self__, "kafka_rest", kafka_rest)
        if kafka_rest_authorization is not None:
            pulumi.set(__self__, "kafka_rest_authorization", kafka_rest_authorization)
        if kafka_rest_config is not None:
            pulumi.set(__self__, "kafka_rest_config", kafka_rest_config)
        if kafka_version is not None:
            pulumi.set(__self__, "kafka_version", kafka_version)
        if private_access is not None:
            pulumi.set(__self__, "private_access", private_access)
        if privatelink_access is not None:
            pulumi.set(__self__, "privatelink_access", privatelink_access)
        if public_access is not None:
            pulumi.set(__self__, "public_access", public_access)
        if schema_registry is not None:
            pulumi.set(__self__, "schema_registry", schema_registry)
        if schema_registry_config is not None:
            pulumi.set(__self__, "schema_registry_config", schema_registry_config)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)

    @property
    @pulumi.getter(name="additionalBackupRegions")
    def additional_backup_regions(self) -> Optional[pulumi.Input[str]]:
        """
        Additional Cloud Regions for Backup Replication.
        """
        return pulumi.get(self, "additional_backup_regions")

    @additional_backup_regions.setter
    def additional_backup_regions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @property
    @pulumi.getter(name="customDomain")
    def custom_domain(self) -> Optional[pulumi.Input[str]]:
        """
        Serve the web frontend using a custom CNAME pointing to the Aiven DNS name.
        """
        return pulumi.get(self, "custom_domain")

    @custom_domain.setter
    def custom_domain(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "custom_domain", value)

    @property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KafkaKafkaUserConfigIpFilterObjectArgs']]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        return pulumi.get(self, "ip_filter_objects")

    @ip_filter_objects.setter
    def ip_filter_objects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['KafkaKafkaUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        return pulumi.get(self, "ip_filter_strings")

    @ip_filter_strings.setter
    def ip_filter_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @property
    @pulumi.getter(name="ipFilters")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
        pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")

        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filters", value)

    @property
    @pulumi.getter
    def kafka(self) -> Optional[pulumi.Input['KafkaKafkaUserConfigKafkaArgs']]:
        """
        Kafka broker configuration values.
        """
        return pulumi.get(self, "kafka")

    @kafka.setter
    def kafka(self, value: Optional[pulumi.Input['KafkaKafkaUserConfigKafkaArgs']]):
        pulumi.set(self, "kafka", value)

    @property
    @pulumi.getter(name="kafkaAuthenticationMethods")
    def kafka_authentication_methods(self) -> Optional[pulumi.Input['KafkaKafkaUserConfigKafkaAuthenticationMethodsArgs']]:
        """
        Kafka authentication methods.
        """
        return pulumi.get(self, "kafka_authentication_methods")

    @kafka_authentication_methods.setter
    def kafka_authentication_methods(self, value: Optional[pulumi.Input['KafkaKafkaUserConfigKafkaAuthenticationMethodsArgs']]):
        pulumi.set(self, "kafka_authentication_methods", value)

    @property
    @pulumi.getter(name="kafkaConnect")
    def kafka_connect(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable Kafka Connect service. The default value is `false`.
        """
        return pulumi.get(self, "kafka_connect")

    @kafka_connect.setter
    def kafka_connect(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "kafka_connect", value)

    @property
    @pulumi.getter(name="kafkaConnectConfig")
    def kafka_connect_config(self) -> Optional[pulumi.Input['KafkaKafkaUserConfigKafkaConnectConfigArgs']]:
        """
        Kafka Connect configuration values.
        """
        return pulumi.get(self, "kafka_connect_config")

    @kafka_connect_config.setter
    def kafka_connect_config(self, value: Optional[pulumi.Input['KafkaKafkaUserConfigKafkaConnectConfigArgs']]):
        pulumi.set(self, "kafka_connect_config", value)

    @property
    @pulumi.getter(name="kafkaRest")
    def kafka_rest(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable Kafka-REST service. The default value is `false`.
        """
        return pulumi.get(self, "kafka_rest")

    @kafka_rest.setter
    def kafka_rest(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "kafka_rest", value)

    @property
    @pulumi.getter(name="kafkaRestAuthorization")
    def kafka_rest_authorization(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable authorization in Kafka-REST service.
        """
        return pulumi.get(self, "kafka_rest_authorization")

    @kafka_rest_authorization.setter
    def kafka_rest_authorization(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "kafka_rest_authorization", value)

    @property
    @pulumi.getter(name="kafkaRestConfig")
    def kafka_rest_config(self) -> Optional[pulumi.Input['KafkaKafkaUserConfigKafkaRestConfigArgs']]:
        """
        Kafka REST configuration.
        """
        return pulumi.get(self, "kafka_rest_config")

    @kafka_rest_config.setter
    def kafka_rest_config(self, value: Optional[pulumi.Input['KafkaKafkaUserConfigKafkaRestConfigArgs']]):
        pulumi.set(self, "kafka_rest_config", value)

    @property
    @pulumi.getter(name="kafkaVersion")
    def kafka_version(self) -> Optional[pulumi.Input[str]]:
        """
        Kafka major version.
        """
        return pulumi.get(self, "kafka_version")

    @kafka_version.setter
    def kafka_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kafka_version", value)

    @property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['KafkaKafkaUserConfigPrivateAccessArgs']]:
        """
        Allow access to selected service ports from private networks.
        """
        return pulumi.get(self, "private_access")

    @private_access.setter
    def private_access(self, value: Optional[pulumi.Input['KafkaKafkaUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['KafkaKafkaUserConfigPrivatelinkAccessArgs']]:
        """
        Allow access to selected service components through Privatelink.
        """
        return pulumi.get(self, "privatelink_access")

    @privatelink_access.setter
    def privatelink_access(self, value: Optional[pulumi.Input['KafkaKafkaUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)

    @property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['KafkaKafkaUserConfigPublicAccessArgs']]:
        """
        Allow access to selected service ports from the public Internet.
        """
        return pulumi.get(self, "public_access")

    @public_access.setter
    def public_access(self, value: Optional[pulumi.Input['KafkaKafkaUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

    @property
    @pulumi.getter(name="schemaRegistry")
    def schema_registry(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable Schema-Registry service. The default value 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="schemaRegistryConfig")
    def schema_registry_config(self) -> Optional[pulumi.Input['KafkaKafkaUserConfigSchemaRegistryConfigArgs']]:
        """
        Schema Registry configuration.
        """
        return pulumi.get(self, "schema_registry_config")

    @schema_registry_config.setter
    def schema_registry_config(self, value: Optional[pulumi.Input['KafkaKafkaUserConfigSchemaRegistryConfigArgs']]):
        pulumi.set(self, "schema_registry_config", value)

    @property
    @pulumi.getter(name="staticIps")
    def static_ips(self) -> Optional[pulumi.Input[bool]]:
        """
        Use static public IP addresses.
        """
        return pulumi.get(self, "static_ips")

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "static_ips", value)


@pulumi.input_type
class KafkaKafkaUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

    @network.setter
    def network(self, value: pulumi.Input[str]):
        pulumi.set(self, "network", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class KafkaKafkaUserConfigKafkaArgs:
    def __init__(__self__, *,
                 auto_create_topics_enable: Optional[pulumi.Input[bool]] = None,
                 compression_type: Optional[pulumi.Input[str]] = None,
                 connections_max_idle_ms: Optional[pulumi.Input[int]] = None,
                 default_replication_factor: Optional[pulumi.Input[int]] = None,
                 group_initial_rebalance_delay_ms: Optional[pulumi.Input[int]] = None,
                 group_max_session_timeout_ms: Optional[pulumi.Input[int]] = None,
                 group_min_session_timeout_ms: Optional[pulumi.Input[int]] = None,
                 log_cleaner_delete_retention_ms: Optional[pulumi.Input[int]] = None,
                 log_cleaner_max_compaction_lag_ms: Optional[pulumi.Input[int]] = None,
                 log_cleaner_min_cleanable_ratio: Optional[pulumi.Input[float]] = None,
                 log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[int]] = None,
                 log_cleanup_policy: Optional[pulumi.Input[str]] = None,
                 log_flush_interval_messages: Optional[pulumi.Input[int]] = None,
                 log_flush_interval_ms: Optional[pulumi.Input[int]] = None,
                 log_index_interval_bytes: Optional[pulumi.Input[int]] = None,
                 log_index_size_max_bytes: Optional[pulumi.Input[int]] = None,
                 log_message_downconversion_enable: Optional[pulumi.Input[bool]] = None,
                 log_message_timestamp_difference_max_ms: Optional[pulumi.Input[int]] = None,
                 log_message_timestamp_type: Optional[pulumi.Input[str]] = None,
                 log_preallocate: Optional[pulumi.Input[bool]] = None,
                 log_retention_bytes: Optional[pulumi.Input[int]] = None,
                 log_retention_hours: Optional[pulumi.Input[int]] = None,
                 log_retention_ms: Optional[pulumi.Input[int]] = None,
                 log_roll_jitter_ms: Optional[pulumi.Input[int]] = None,
                 log_roll_ms: Optional[pulumi.Input[int]] = None,
                 log_segment_bytes: Optional[pulumi.Input[int]] = None,
                 log_segment_delete_delay_ms: Optional[pulumi.Input[int]] = None,
                 max_connections_per_ip: Optional[pulumi.Input[int]] = None,
                 max_incremental_fetch_session_cache_slots: Optional[pulumi.Input[int]] = None,
                 message_max_bytes: Optional[pulumi.Input[int]] = None,
                 min_insync_replicas: Optional[pulumi.Input[int]] = None,
                 num_partitions: Optional[pulumi.Input[int]] = None,
                 offsets_retention_minutes: Optional[pulumi.Input[int]] = None,
                 producer_purgatory_purge_interval_requests: Optional[pulumi.Input[int]] = None,
                 replica_fetch_max_bytes: Optional[pulumi.Input[int]] = None,
                 replica_fetch_response_max_bytes: Optional[pulumi.Input[int]] = None,
                 socket_request_max_bytes: Optional[pulumi.Input[int]] = None,
                 transaction_remove_expired_transaction_cleanup_interval_ms: Optional[pulumi.Input[int]] = None,
                 transaction_state_log_segment_bytes: Optional[pulumi.Input[int]] = 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 connections_max_idle_ms is not None:
            pulumi.set(__self__, "connections_max_idle_ms", connections_max_idle_ms)
        if default_replication_factor is not None:
            pulumi.set(__self__, "default_replication_factor", default_replication_factor)
        if group_initial_rebalance_delay_ms is not None:
            pulumi.set(__self__, "group_initial_rebalance_delay_ms", group_initial_rebalance_delay_ms)
        if group_max_session_timeout_ms is not None:
            pulumi.set(__self__, "group_max_session_timeout_ms", group_max_session_timeout_ms)
        if group_min_session_timeout_ms is not None:
            pulumi.set(__self__, "group_min_session_timeout_ms", group_min_session_timeout_ms)
        if log_cleaner_delete_retention_ms is not None:
            pulumi.set(__self__, "log_cleaner_delete_retention_ms", log_cleaner_delete_retention_ms)
        if log_cleaner_max_compaction_lag_ms is not None:
            pulumi.set(__self__, "log_cleaner_max_compaction_lag_ms", log_cleaner_max_compaction_lag_ms)
        if log_cleaner_min_cleanable_ratio is not None:
            pulumi.set(__self__, "log_cleaner_min_cleanable_ratio", log_cleaner_min_cleanable_ratio)
        if log_cleaner_min_compaction_lag_ms is not None:
            pulumi.set(__self__, "log_cleaner_min_compaction_lag_ms", log_cleaner_min_compaction_lag_ms)
        if log_cleanup_policy is not None:
            pulumi.set(__self__, "log_cleanup_policy", log_cleanup_policy)
        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_index_interval_bytes is not None:
            pulumi.set(__self__, "log_index_interval_bytes", log_index_interval_bytes)
        if log_index_size_max_bytes is not None:
            pulumi.set(__self__, "log_index_size_max_bytes", log_index_size_max_bytes)
        if log_message_downconversion_enable is not None:
            pulumi.set(__self__, "log_message_downconversion_enable", log_message_downconversion_enable)
        if log_message_timestamp_difference_max_ms is not None:
            pulumi.set(__self__, "log_message_timestamp_difference_max_ms", log_message_timestamp_difference_max_ms)
        if log_message_timestamp_type is not None:
            pulumi.set(__self__, "log_message_timestamp_type", log_message_timestamp_type)
        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_ms is not None:
            pulumi.set(__self__, "log_retention_ms", log_retention_ms)
        if log_roll_jitter_ms is not None:
            pulumi.set(__self__, "log_roll_jitter_ms", log_roll_jitter_ms)
        if log_roll_ms is not None:
            pulumi.set(__self__, "log_roll_ms", log_roll_ms)
        if log_segment_bytes is not None:
            pulumi.set(__self__, "log_segment_bytes", log_segment_bytes)
        if log_segment_delete_delay_ms is not None:
            pulumi.set(__self__, "log_segment_delete_delay_ms", log_segment_delete_delay_ms)
        if max_connections_per_ip is not None:
            pulumi.set(__self__, "max_connections_per_ip", max_connections_per_ip)
        if max_incremental_fetch_session_cache_slots is not None:
            pulumi.set(__self__, "max_incremental_fetch_session_cache_slots", max_incremental_fetch_session_cache_slots)
        if message_max_bytes is not None:
            pulumi.set(__self__, "message_max_bytes", message_max_bytes)
        if min_insync_replicas is not None:
            pulumi.set(__self__, "min_insync_replicas", min_insync_replicas)
        if num_partitions is not None:
            pulumi.set(__self__, "num_partitions", num_partitions)
        if offsets_retention_minutes is not None:
            pulumi.set(__self__, "offsets_retention_minutes", offsets_retention_minutes)
        if producer_purgatory_purge_interval_requests is not None:
            pulumi.set(__self__, "producer_purgatory_purge_interval_requests", producer_purgatory_purge_interval_requests)
        if replica_fetch_max_bytes is not None:
            pulumi.set(__self__, "replica_fetch_max_bytes", replica_fetch_max_bytes)
        if replica_fetch_response_max_bytes is not None:
            pulumi.set(__self__, "replica_fetch_response_max_bytes", replica_fetch_response_max_bytes)
        if socket_request_max_bytes is not None:
            pulumi.set(__self__, "socket_request_max_bytes", socket_request_max_bytes)
        if transaction_remove_expired_transaction_cleanup_interval_ms is not None:
            pulumi.set(__self__, "transaction_remove_expired_transaction_cleanup_interval_ms", transaction_remove_expired_transaction_cleanup_interval_ms)
        if transaction_state_log_segment_bytes is not None:
            pulumi.set(__self__, "transaction_state_log_segment_bytes", transaction_state_log_segment_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="connectionsMaxIdleMs")
    def connections_max_idle_ms(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "connections_max_idle_ms")

    @connections_max_idle_ms.setter
    def connections_max_idle_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "connections_max_idle_ms", value)

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

    @default_replication_factor.setter
    def default_replication_factor(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "default_replication_factor", value)

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

    @group_initial_rebalance_delay_ms.setter
    def group_initial_rebalance_delay_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "group_initial_rebalance_delay_ms", value)

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

    @group_max_session_timeout_ms.setter
    def group_max_session_timeout_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "group_max_session_timeout_ms", value)

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

    @group_min_session_timeout_ms.setter
    def group_min_session_timeout_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "group_min_session_timeout_ms", value)

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

    @log_cleaner_delete_retention_ms.setter
    def log_cleaner_delete_retention_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_cleaner_delete_retention_ms", value)

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

    @log_cleaner_max_compaction_lag_ms.setter
    def log_cleaner_max_compaction_lag_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_cleaner_max_compaction_lag_ms", value)

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

    @log_cleaner_min_cleanable_ratio.setter
    def log_cleaner_min_cleanable_ratio(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "log_cleaner_min_cleanable_ratio", value)

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

    @log_cleaner_min_compaction_lag_ms.setter
    def log_cleaner_min_compaction_lag_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_cleaner_min_compaction_lag_ms", value)

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

    @log_cleanup_policy.setter
    def log_cleanup_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "log_cleanup_policy", value)

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

    @log_flush_interval_messages.setter
    def log_flush_interval_messages(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_flush_interval_messages", value)

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

    @log_flush_interval_ms.setter
    def log_flush_interval_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_flush_interval_ms", value)

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

    @log_index_interval_bytes.setter
    def log_index_interval_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_index_interval_bytes", value)

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

    @log_index_size_max_bytes.setter
    def log_index_size_max_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_index_size_max_bytes", value)

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

    @log_message_downconversion_enable.setter
    def log_message_downconversion_enable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "log_message_downconversion_enable", value)

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

    @log_message_timestamp_difference_max_ms.setter
    def log_message_timestamp_difference_max_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_message_timestamp_difference_max_ms", value)

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

    @log_message_timestamp_type.setter
    def log_message_timestamp_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "log_message_timestamp_type", 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[int]]:
        return pulumi.get(self, "log_retention_bytes")

    @log_retention_bytes.setter
    def log_retention_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_retention_bytes", value)

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

    @log_retention_hours.setter
    def log_retention_hours(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_retention_hours", value)

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

    @log_retention_ms.setter
    def log_retention_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_retention_ms", value)

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

    @log_roll_jitter_ms.setter
    def log_roll_jitter_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_roll_jitter_ms", value)

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

    @log_roll_ms.setter
    def log_roll_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_roll_ms", value)

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

    @log_segment_bytes.setter
    def log_segment_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_segment_bytes", value)

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

    @log_segment_delete_delay_ms.setter
    def log_segment_delete_delay_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_segment_delete_delay_ms", value)

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

    @max_connections_per_ip.setter
    def max_connections_per_ip(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_connections_per_ip", value)

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

    @max_incremental_fetch_session_cache_slots.setter
    def max_incremental_fetch_session_cache_slots(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_incremental_fetch_session_cache_slots", value)

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

    @message_max_bytes.setter
    def message_max_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "message_max_bytes", value)

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

    @min_insync_replicas.setter
    def min_insync_replicas(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_insync_replicas", value)

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

    @num_partitions.setter
    def num_partitions(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "num_partitions", value)

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

    @offsets_retention_minutes.setter
    def offsets_retention_minutes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "offsets_retention_minutes", value)

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

    @producer_purgatory_purge_interval_requests.setter
    def producer_purgatory_purge_interval_requests(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "producer_purgatory_purge_interval_requests", value)

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

    @replica_fetch_max_bytes.setter
    def replica_fetch_max_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "replica_fetch_max_bytes", value)

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

    @replica_fetch_response_max_bytes.setter
    def replica_fetch_response_max_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "replica_fetch_response_max_bytes", value)

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

    @socket_request_max_bytes.setter
    def socket_request_max_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "socket_request_max_bytes", value)

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

    @transaction_remove_expired_transaction_cleanup_interval_ms.setter
    def transaction_remove_expired_transaction_cleanup_interval_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "transaction_remove_expired_transaction_cleanup_interval_ms", value)

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

    @transaction_state_log_segment_bytes.setter
    def transaction_state_log_segment_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "transaction_state_log_segment_bytes", value)


@pulumi.input_type
class KafkaKafkaUserConfigKafkaAuthenticationMethodsArgs:
    def __init__(__self__, *,
                 certificate: Optional[pulumi.Input[bool]] = None,
                 sasl: Optional[pulumi.Input[bool]] = None):
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if sasl is not None:
            pulumi.set(__self__, "sasl", sasl)

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

    @certificate.setter
    def certificate(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "certificate", value)

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

    @sasl.setter
    def sasl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "sasl", value)


@pulumi.input_type
class KafkaKafkaUserConfigKafkaConnectConfigArgs:
    def __init__(__self__, *,
                 connector_client_config_override_policy: Optional[pulumi.Input[str]] = None,
                 consumer_auto_offset_reset: Optional[pulumi.Input[str]] = None,
                 consumer_fetch_max_bytes: Optional[pulumi.Input[int]] = None,
                 consumer_isolation_level: Optional[pulumi.Input[str]] = None,
                 consumer_max_partition_fetch_bytes: Optional[pulumi.Input[int]] = None,
                 consumer_max_poll_interval_ms: Optional[pulumi.Input[int]] = None,
                 consumer_max_poll_records: Optional[pulumi.Input[int]] = None,
                 offset_flush_interval_ms: Optional[pulumi.Input[int]] = None,
                 offset_flush_timeout_ms: Optional[pulumi.Input[int]] = None,
                 producer_batch_size: Optional[pulumi.Input[int]] = None,
                 producer_buffer_memory: Optional[pulumi.Input[int]] = None,
                 producer_compression_type: Optional[pulumi.Input[str]] = None,
                 producer_linger_ms: Optional[pulumi.Input[int]] = None,
                 producer_max_request_size: Optional[pulumi.Input[int]] = None,
                 scheduled_rebalance_max_delay_ms: Optional[pulumi.Input[int]] = None,
                 session_timeout_ms: Optional[pulumi.Input[int]] = None):
        if connector_client_config_override_policy is not None:
            pulumi.set(__self__, "connector_client_config_override_policy", connector_client_config_override_policy)
        if consumer_auto_offset_reset is not None:
            pulumi.set(__self__, "consumer_auto_offset_reset", consumer_auto_offset_reset)
        if consumer_fetch_max_bytes is not None:
            pulumi.set(__self__, "consumer_fetch_max_bytes", consumer_fetch_max_bytes)
        if consumer_isolation_level is not None:
            pulumi.set(__self__, "consumer_isolation_level", consumer_isolation_level)
        if consumer_max_partition_fetch_bytes is not None:
            pulumi.set(__self__, "consumer_max_partition_fetch_bytes", consumer_max_partition_fetch_bytes)
        if consumer_max_poll_interval_ms is not None:
            pulumi.set(__self__, "consumer_max_poll_interval_ms", consumer_max_poll_interval_ms)
        if consumer_max_poll_records is not None:
            pulumi.set(__self__, "consumer_max_poll_records", consumer_max_poll_records)
        if offset_flush_interval_ms is not None:
            pulumi.set(__self__, "offset_flush_interval_ms", offset_flush_interval_ms)
        if offset_flush_timeout_ms is not None:
            pulumi.set(__self__, "offset_flush_timeout_ms", offset_flush_timeout_ms)
        if producer_batch_size is not None:
            pulumi.set(__self__, "producer_batch_size", producer_batch_size)
        if producer_buffer_memory is not None:
            pulumi.set(__self__, "producer_buffer_memory", producer_buffer_memory)
        if producer_compression_type is not None:
            pulumi.set(__self__, "producer_compression_type", producer_compression_type)
        if producer_linger_ms is not None:
            pulumi.set(__self__, "producer_linger_ms", producer_linger_ms)
        if producer_max_request_size is not None:
            pulumi.set(__self__, "producer_max_request_size", producer_max_request_size)
        if scheduled_rebalance_max_delay_ms is not None:
            pulumi.set(__self__, "scheduled_rebalance_max_delay_ms", scheduled_rebalance_max_delay_ms)
        if session_timeout_ms is not None:
            pulumi.set(__self__, "session_timeout_ms", session_timeout_ms)

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

    @connector_client_config_override_policy.setter
    def connector_client_config_override_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "connector_client_config_override_policy", value)

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

    @consumer_auto_offset_reset.setter
    def consumer_auto_offset_reset(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "consumer_auto_offset_reset", value)

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

    @consumer_fetch_max_bytes.setter
    def consumer_fetch_max_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "consumer_fetch_max_bytes", value)

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

    @consumer_isolation_level.setter
    def consumer_isolation_level(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "consumer_isolation_level", value)

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

    @consumer_max_partition_fetch_bytes.setter
    def consumer_max_partition_fetch_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "consumer_max_partition_fetch_bytes", value)

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

    @consumer_max_poll_interval_ms.setter
    def consumer_max_poll_interval_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "consumer_max_poll_interval_ms", value)

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

    @consumer_max_poll_records.setter
    def consumer_max_poll_records(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "consumer_max_poll_records", value)

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

    @offset_flush_interval_ms.setter
    def offset_flush_interval_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "offset_flush_interval_ms", value)

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

    @offset_flush_timeout_ms.setter
    def offset_flush_timeout_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "offset_flush_timeout_ms", value)

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

    @producer_batch_size.setter
    def producer_batch_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "producer_batch_size", value)

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

    @producer_buffer_memory.setter
    def producer_buffer_memory(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "producer_buffer_memory", value)

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

    @producer_compression_type.setter
    def producer_compression_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "producer_compression_type", value)

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

    @producer_linger_ms.setter
    def producer_linger_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "producer_linger_ms", value)

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

    @producer_max_request_size.setter
    def producer_max_request_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "producer_max_request_size", value)

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

    @scheduled_rebalance_max_delay_ms.setter
    def scheduled_rebalance_max_delay_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "scheduled_rebalance_max_delay_ms", value)

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

    @session_timeout_ms.setter
    def session_timeout_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "session_timeout_ms", value)


@pulumi.input_type
class KafkaKafkaUserConfigKafkaRestConfigArgs:
    def __init__(__self__, *,
                 consumer_enable_auto_commit: Optional[pulumi.Input[bool]] = None,
                 consumer_request_max_bytes: Optional[pulumi.Input[int]] = None,
                 consumer_request_timeout_ms: Optional[pulumi.Input[int]] = None,
                 producer_acks: Optional[pulumi.Input[str]] = None,
                 producer_compression_type: Optional[pulumi.Input[str]] = None,
                 producer_linger_ms: Optional[pulumi.Input[int]] = None,
                 producer_max_request_size: Optional[pulumi.Input[int]] = None,
                 simpleconsumer_pool_size_max: Optional[pulumi.Input[int]] = None):
        if consumer_enable_auto_commit is not None:
            pulumi.set(__self__, "consumer_enable_auto_commit", consumer_enable_auto_commit)
        if consumer_request_max_bytes is not None:
            pulumi.set(__self__, "consumer_request_max_bytes", consumer_request_max_bytes)
        if consumer_request_timeout_ms is not None:
            pulumi.set(__self__, "consumer_request_timeout_ms", consumer_request_timeout_ms)
        if producer_acks is not None:
            pulumi.set(__self__, "producer_acks", producer_acks)
        if producer_compression_type is not None:
            pulumi.set(__self__, "producer_compression_type", producer_compression_type)
        if producer_linger_ms is not None:
            pulumi.set(__self__, "producer_linger_ms", producer_linger_ms)
        if producer_max_request_size is not None:
            pulumi.set(__self__, "producer_max_request_size", producer_max_request_size)
        if simpleconsumer_pool_size_max is not None:
            pulumi.set(__self__, "simpleconsumer_pool_size_max", simpleconsumer_pool_size_max)

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

    @consumer_enable_auto_commit.setter
    def consumer_enable_auto_commit(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "consumer_enable_auto_commit", value)

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

    @consumer_request_max_bytes.setter
    def consumer_request_max_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "consumer_request_max_bytes", value)

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

    @consumer_request_timeout_ms.setter
    def consumer_request_timeout_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "consumer_request_timeout_ms", value)

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

    @producer_acks.setter
    def producer_acks(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "producer_acks", value)

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

    @producer_compression_type.setter
    def producer_compression_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "producer_compression_type", value)

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

    @producer_linger_ms.setter
    def producer_linger_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "producer_linger_ms", value)

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

    @producer_max_request_size.setter
    def producer_max_request_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "producer_max_request_size", value)

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

    @simpleconsumer_pool_size_max.setter
    def simpleconsumer_pool_size_max(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "simpleconsumer_pool_size_max", value)


@pulumi.input_type
class KafkaKafkaUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 kafka: Optional[pulumi.Input[bool]] = None,
                 kafka_connect: Optional[pulumi.Input[bool]] = None,
                 kafka_rest: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None,
                 schema_registry: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] kafka: Kafka server provided values
        """
        if kafka is not None:
            pulumi.set(__self__, "kafka", kafka)
        if kafka_connect is not None:
            pulumi.set(__self__, "kafka_connect", kafka_connect)
        if kafka_rest is not None:
            pulumi.set(__self__, "kafka_rest", kafka_rest)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)
        if schema_registry is not None:
            pulumi.set(__self__, "schema_registry", schema_registry)

    @property
    @pulumi.getter
    def kafka(self) -> Optional[pulumi.Input[bool]]:
        """
        Kafka server provided values
        """
        return pulumi.get(self, "kafka")

    @kafka.setter
    def kafka(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "kafka", value)

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

    @kafka_connect.setter
    def kafka_connect(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "kafka_connect", value)

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

    @kafka_rest.setter
    def kafka_rest(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "kafka_rest", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)

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

    @schema_registry.setter
    def schema_registry(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "schema_registry", value)


@pulumi.input_type
class KafkaKafkaUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 jolokia: Optional[pulumi.Input[bool]] = None,
                 kafka: Optional[pulumi.Input[bool]] = None,
                 kafka_connect: Optional[pulumi.Input[bool]] = None,
                 kafka_rest: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None,
                 schema_registry: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] kafka: Kafka server provided values
        """
        if jolokia is not None:
            pulumi.set(__self__, "jolokia", jolokia)
        if kafka is not None:
            pulumi.set(__self__, "kafka", kafka)
        if kafka_connect is not None:
            pulumi.set(__self__, "kafka_connect", kafka_connect)
        if kafka_rest is not None:
            pulumi.set(__self__, "kafka_rest", kafka_rest)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)
        if schema_registry is not None:
            pulumi.set(__self__, "schema_registry", schema_registry)

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

    @jolokia.setter
    def jolokia(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "jolokia", value)

    @property
    @pulumi.getter
    def kafka(self) -> Optional[pulumi.Input[bool]]:
        """
        Kafka server provided values
        """
        return pulumi.get(self, "kafka")

    @kafka.setter
    def kafka(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "kafka", value)

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

    @kafka_connect.setter
    def kafka_connect(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "kafka_connect", value)

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

    @kafka_rest.setter
    def kafka_rest(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "kafka_rest", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)

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

    @schema_registry.setter
    def schema_registry(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "schema_registry", value)


@pulumi.input_type
class KafkaKafkaUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 kafka: Optional[pulumi.Input[bool]] = None,
                 kafka_connect: Optional[pulumi.Input[bool]] = None,
                 kafka_rest: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None,
                 schema_registry: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] kafka: Kafka server provided values
        """
        if kafka is not None:
            pulumi.set(__self__, "kafka", kafka)
        if kafka_connect is not None:
            pulumi.set(__self__, "kafka_connect", kafka_connect)
        if kafka_rest is not None:
            pulumi.set(__self__, "kafka_rest", kafka_rest)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)
        if schema_registry is not None:
            pulumi.set(__self__, "schema_registry", schema_registry)

    @property
    @pulumi.getter
    def kafka(self) -> Optional[pulumi.Input[bool]]:
        """
        Kafka server provided values
        """
        return pulumi.get(self, "kafka")

    @kafka.setter
    def kafka(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "kafka", value)

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

    @kafka_connect.setter
    def kafka_connect(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "kafka_connect", value)

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

    @kafka_rest.setter
    def kafka_rest(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "kafka_rest", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)

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

    @schema_registry.setter
    def schema_registry(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "schema_registry", value)


@pulumi.input_type
class KafkaKafkaUserConfigSchemaRegistryConfigArgs:
    def __init__(__self__, *,
                 leader_eligibility: Optional[pulumi.Input[bool]] = None,
                 topic_name: Optional[pulumi.Input[str]] = None):
        if leader_eligibility is not None:
            pulumi.set(__self__, "leader_eligibility", leader_eligibility)
        if topic_name is not None:
            pulumi.set(__self__, "topic_name", topic_name)

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

    @leader_eligibility.setter
    def leader_eligibility(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "leader_eligibility", value)

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

    @topic_name.setter
    def topic_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "topic_name", value)


@pulumi.input_type
class KafkaMirrorMakerComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[str]] = None,
                 host: Optional[pulumi.Input[str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 route: Optional[pulumi.Input[str]] = None,
                 ssl: Optional[pulumi.Input[bool]] = None,
                 usage: Optional[pulumi.Input[str]] = None):
        if component is not None:
            pulumi.set(__self__, "component", component)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if kafka_authentication_method is not None:
            pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if route is not None:
            pulumi.set(__self__, "route", route)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if usage is not None:
            pulumi.set(__self__, "usage", usage)

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

    @component.setter
    def component(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "component", value)

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

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

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

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kafka_authentication_method", 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
    def route(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route", value)

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

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl", value)

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

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "usage", value)


@pulumi.input_type
class KafkaMirrorMakerKafkaMirrormakerArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class KafkaMirrorMakerKafkaMirrormakerUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['KafkaMirrorMakerKafkaMirrormakerUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 kafka_mirrormaker: Optional[pulumi.Input['KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerArgs']] = None,
                 static_ips: Optional[pulumi.Input[bool]] = None):
        if additional_backup_regions is not None:
            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
        if ip_filter_objects is not None:
            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
        if ip_filter_strings is not None:
            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
        if ip_filters is not None:
            warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        if kafka_mirrormaker is not None:
            pulumi.set(__self__, "kafka_mirrormaker", kafka_mirrormaker)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)

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

    @additional_backup_regions.setter
    def additional_backup_regions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KafkaMirrorMakerKafkaMirrormakerUserConfigIpFilterObjectArgs']]]]:
        return pulumi.get(self, "ip_filter_objects")

    @ip_filter_objects.setter
    def ip_filter_objects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['KafkaMirrorMakerKafkaMirrormakerUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

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

    @ip_filter_strings.setter
    def ip_filter_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @property
    @pulumi.getter(name="ipFilters")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
        pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")

        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filters", value)

    @property
    @pulumi.getter(name="kafkaMirrormaker")
    def kafka_mirrormaker(self) -> Optional[pulumi.Input['KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerArgs']]:
        return pulumi.get(self, "kafka_mirrormaker")

    @kafka_mirrormaker.setter
    def kafka_mirrormaker(self, value: Optional[pulumi.Input['KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerArgs']]):
        pulumi.set(self, "kafka_mirrormaker", value)

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

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "static_ips", value)


@pulumi.input_type
class KafkaMirrorMakerKafkaMirrormakerUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

    @network.setter
    def network(self, value: pulumi.Input[str]):
        pulumi.set(self, "network", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerArgs:
    def __init__(__self__, *,
                 emit_checkpoints_enabled: Optional[pulumi.Input[bool]] = None,
                 emit_checkpoints_interval_seconds: Optional[pulumi.Input[int]] = None,
                 refresh_groups_enabled: Optional[pulumi.Input[bool]] = None,
                 refresh_groups_interval_seconds: Optional[pulumi.Input[int]] = None,
                 refresh_topics_enabled: Optional[pulumi.Input[bool]] = None,
                 refresh_topics_interval_seconds: Optional[pulumi.Input[int]] = None,
                 sync_group_offsets_enabled: Optional[pulumi.Input[bool]] = None,
                 sync_group_offsets_interval_seconds: Optional[pulumi.Input[int]] = None,
                 sync_topic_configs_enabled: Optional[pulumi.Input[bool]] = None,
                 tasks_max_per_cpu: Optional[pulumi.Input[int]] = None):
        if emit_checkpoints_enabled is not None:
            pulumi.set(__self__, "emit_checkpoints_enabled", emit_checkpoints_enabled)
        if emit_checkpoints_interval_seconds is not None:
            pulumi.set(__self__, "emit_checkpoints_interval_seconds", emit_checkpoints_interval_seconds)
        if refresh_groups_enabled is not None:
            pulumi.set(__self__, "refresh_groups_enabled", refresh_groups_enabled)
        if refresh_groups_interval_seconds is not None:
            pulumi.set(__self__, "refresh_groups_interval_seconds", refresh_groups_interval_seconds)
        if refresh_topics_enabled is not None:
            pulumi.set(__self__, "refresh_topics_enabled", refresh_topics_enabled)
        if refresh_topics_interval_seconds is not None:
            pulumi.set(__self__, "refresh_topics_interval_seconds", refresh_topics_interval_seconds)
        if sync_group_offsets_enabled is not None:
            pulumi.set(__self__, "sync_group_offsets_enabled", sync_group_offsets_enabled)
        if sync_group_offsets_interval_seconds is not None:
            pulumi.set(__self__, "sync_group_offsets_interval_seconds", sync_group_offsets_interval_seconds)
        if sync_topic_configs_enabled is not None:
            pulumi.set(__self__, "sync_topic_configs_enabled", sync_topic_configs_enabled)
        if tasks_max_per_cpu is not None:
            pulumi.set(__self__, "tasks_max_per_cpu", tasks_max_per_cpu)

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

    @emit_checkpoints_enabled.setter
    def emit_checkpoints_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "emit_checkpoints_enabled", value)

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

    @emit_checkpoints_interval_seconds.setter
    def emit_checkpoints_interval_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "emit_checkpoints_interval_seconds", value)

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

    @refresh_groups_enabled.setter
    def refresh_groups_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "refresh_groups_enabled", value)

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

    @refresh_groups_interval_seconds.setter
    def refresh_groups_interval_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "refresh_groups_interval_seconds", value)

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

    @refresh_topics_enabled.setter
    def refresh_topics_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "refresh_topics_enabled", value)

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

    @refresh_topics_interval_seconds.setter
    def refresh_topics_interval_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "refresh_topics_interval_seconds", value)

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

    @sync_group_offsets_enabled.setter
    def sync_group_offsets_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "sync_group_offsets_enabled", value)

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

    @sync_group_offsets_interval_seconds.setter
    def sync_group_offsets_interval_seconds(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "sync_group_offsets_interval_seconds", value)

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

    @sync_topic_configs_enabled.setter
    def sync_topic_configs_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "sync_topic_configs_enabled", value)

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

    @tasks_max_per_cpu.setter
    def tasks_max_per_cpu(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "tasks_max_per_cpu", value)


@pulumi.input_type
class KafkaMirrorMakerServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[str],
                 source_service_name: pulumi.Input[str]):
        pulumi.set(__self__, "integration_type", integration_type)
        pulumi.set(__self__, "source_service_name", source_service_name)

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

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "integration_type", value)

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

    @source_service_name.setter
    def source_service_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "source_service_name", value)


@pulumi.input_type
class KafkaMirrorMakerTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class KafkaServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[str],
                 source_service_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] integration_type: Type of the service integration. The only supported value at the moment is `read_replica`
        :param pulumi.Input[str] source_service_name: Name of the source service
        """
        pulumi.set(__self__, "integration_type", integration_type)
        pulumi.set(__self__, "source_service_name", source_service_name)

    @property
    @pulumi.getter(name="integrationType")
    def integration_type(self) -> pulumi.Input[str]:
        """
        Type of the service integration. The only supported value at the moment is `read_replica`
        """
        return pulumi.get(self, "integration_type")

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "integration_type", value)

    @property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[str]:
        """
        Name of the source service
        """
        return pulumi.get(self, "source_service_name")

    @source_service_name.setter
    def source_service_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "source_service_name", value)


@pulumi.input_type
class KafkaTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: Service tag key
        :param pulumi.Input[str] value: Service tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        Service tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class KafkaTopicConfigArgs:
    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,
                 index_interval_bytes: Optional[pulumi.Input[str]] = None,
                 max_compaction_lag_ms: Optional[pulumi.Input[str]] = None,
                 max_message_bytes: Optional[pulumi.Input[str]] = None,
                 message_downconversion_enable: Optional[pulumi.Input[bool]] = None,
                 message_format_version: Optional[pulumi.Input[str]] = None,
                 message_timestamp_difference_max_ms: Optional[pulumi.Input[str]] = None,
                 message_timestamp_type: Optional[pulumi.Input[str]] = None,
                 min_cleanable_dirty_ratio: Optional[pulumi.Input[float]] = 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,
                 segment_index_bytes: Optional[pulumi.Input[str]] = None,
                 segment_jitter_ms: Optional[pulumi.Input[str]] = None,
                 segment_ms: Optional[pulumi.Input[str]] = None,
                 unclean_leader_election_enable: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] cleanup_policy: cleanup.policy value
        :param pulumi.Input[str] compression_type: compression.type value
        :param pulumi.Input[str] delete_retention_ms: delete.retention.ms value
        :param pulumi.Input[str] file_delete_delay_ms: file.delete.delay.ms value
        :param pulumi.Input[str] flush_messages: flush.messages value
        :param pulumi.Input[str] flush_ms: flush.ms value
        :param pulumi.Input[str] index_interval_bytes: index.interval.bytes value
        :param pulumi.Input[str] max_compaction_lag_ms: max.compaction.lag.ms value
        :param pulumi.Input[str] max_message_bytes: max.message.bytes value
        :param pulumi.Input[bool] message_downconversion_enable: message.downconversion.enable value
        :param pulumi.Input[str] message_format_version: message.format.version value
        :param pulumi.Input[str] message_timestamp_difference_max_ms: message.timestamp.difference.max.ms value
        :param pulumi.Input[str] message_timestamp_type: message.timestamp.type value
        :param pulumi.Input[float] min_cleanable_dirty_ratio: min.cleanable.dirty.ratio value
        :param pulumi.Input[str] min_compaction_lag_ms: min.compaction.lag.ms value
        :param pulumi.Input[str] min_insync_replicas: min.insync.replicas value
        :param pulumi.Input[bool] preallocate: preallocate value
        :param pulumi.Input[str] retention_bytes: retention.bytes value
        :param pulumi.Input[str] retention_ms: retention.ms value
        :param pulumi.Input[str] segment_bytes: segment.bytes value
        :param pulumi.Input[str] segment_index_bytes: segment.index.bytes value
        :param pulumi.Input[str] segment_jitter_ms: segment.jitter.ms value
        :param pulumi.Input[str] segment_ms: segment.ms value
        :param pulumi.Input[bool] unclean_leader_election_enable: unclean.leader.election.enable value; This field is deprecated and no longer functional.
        """
        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 index_interval_bytes is not None:
            pulumi.set(__self__, "index_interval_bytes", index_interval_bytes)
        if max_compaction_lag_ms is not None:
            pulumi.set(__self__, "max_compaction_lag_ms", max_compaction_lag_ms)
        if max_message_bytes is not None:
            pulumi.set(__self__, "max_message_bytes", max_message_bytes)
        if message_downconversion_enable is not None:
            pulumi.set(__self__, "message_downconversion_enable", message_downconversion_enable)
        if message_format_version is not None:
            pulumi.set(__self__, "message_format_version", message_format_version)
        if message_timestamp_difference_max_ms is not None:
            pulumi.set(__self__, "message_timestamp_difference_max_ms", message_timestamp_difference_max_ms)
        if message_timestamp_type is not None:
            pulumi.set(__self__, "message_timestamp_type", message_timestamp_type)
        if min_cleanable_dirty_ratio is not None:
            pulumi.set(__self__, "min_cleanable_dirty_ratio", min_cleanable_dirty_ratio)
        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)
        if segment_index_bytes is not None:
            pulumi.set(__self__, "segment_index_bytes", segment_index_bytes)
        if segment_jitter_ms is not None:
            pulumi.set(__self__, "segment_jitter_ms", segment_jitter_ms)
        if segment_ms is not None:
            pulumi.set(__self__, "segment_ms", segment_ms)
        if unclean_leader_election_enable is not None:
            warnings.warn("""This field is deprecated and no longer functional.""", DeprecationWarning)
            pulumi.log.warn("""unclean_leader_election_enable is deprecated: This field is deprecated and no longer functional.""")
        if unclean_leader_election_enable is not None:
            pulumi.set(__self__, "unclean_leader_election_enable", unclean_leader_election_enable)

    @property
    @pulumi.getter(name="cleanupPolicy")
    def cleanup_policy(self) -> Optional[pulumi.Input[str]]:
        """
        cleanup.policy value
        """
        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]]:
        """
        compression.type value
        """
        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]]:
        """
        delete.retention.ms value
        """
        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]]:
        """
        file.delete.delay.ms value
        """
        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]]:
        """
        flush.messages value
        """
        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]]:
        """
        flush.ms value
        """
        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="indexIntervalBytes")
    def index_interval_bytes(self) -> Optional[pulumi.Input[str]]:
        """
        index.interval.bytes value
        """
        return pulumi.get(self, "index_interval_bytes")

    @index_interval_bytes.setter
    def index_interval_bytes(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "index_interval_bytes", value)

    @property
    @pulumi.getter(name="maxCompactionLagMs")
    def max_compaction_lag_ms(self) -> Optional[pulumi.Input[str]]:
        """
        max.compaction.lag.ms value
        """
        return pulumi.get(self, "max_compaction_lag_ms")

    @max_compaction_lag_ms.setter
    def max_compaction_lag_ms(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_compaction_lag_ms", value)

    @property
    @pulumi.getter(name="maxMessageBytes")
    def max_message_bytes(self) -> Optional[pulumi.Input[str]]:
        """
        max.message.bytes value
        """
        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="messageDownconversionEnable")
    def message_downconversion_enable(self) -> Optional[pulumi.Input[bool]]:
        """
        message.downconversion.enable value
        """
        return pulumi.get(self, "message_downconversion_enable")

    @message_downconversion_enable.setter
    def message_downconversion_enable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "message_downconversion_enable", value)

    @property
    @pulumi.getter(name="messageFormatVersion")
    def message_format_version(self) -> Optional[pulumi.Input[str]]:
        """
        message.format.version value
        """
        return pulumi.get(self, "message_format_version")

    @message_format_version.setter
    def message_format_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_format_version", value)

    @property
    @pulumi.getter(name="messageTimestampDifferenceMaxMs")
    def message_timestamp_difference_max_ms(self) -> Optional[pulumi.Input[str]]:
        """
        message.timestamp.difference.max.ms value
        """
        return pulumi.get(self, "message_timestamp_difference_max_ms")

    @message_timestamp_difference_max_ms.setter
    def message_timestamp_difference_max_ms(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_timestamp_difference_max_ms", value)

    @property
    @pulumi.getter(name="messageTimestampType")
    def message_timestamp_type(self) -> Optional[pulumi.Input[str]]:
        """
        message.timestamp.type value
        """
        return pulumi.get(self, "message_timestamp_type")

    @message_timestamp_type.setter
    def message_timestamp_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "message_timestamp_type", value)

    @property
    @pulumi.getter(name="minCleanableDirtyRatio")
    def min_cleanable_dirty_ratio(self) -> Optional[pulumi.Input[float]]:
        """
        min.cleanable.dirty.ratio value
        """
        return pulumi.get(self, "min_cleanable_dirty_ratio")

    @min_cleanable_dirty_ratio.setter
    def min_cleanable_dirty_ratio(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "min_cleanable_dirty_ratio", value)

    @property
    @pulumi.getter(name="minCompactionLagMs")
    def min_compaction_lag_ms(self) -> Optional[pulumi.Input[str]]:
        """
        min.compaction.lag.ms value
        """
        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]]:
        """
        min.insync.replicas value
        """
        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]]:
        """
        preallocate value
        """
        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]]:
        """
        retention.bytes value
        """
        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]]:
        """
        retention.ms value
        """
        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]]:
        """
        segment.bytes value
        """
        return pulumi.get(self, "segment_bytes")

    @segment_bytes.setter
    def segment_bytes(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "segment_bytes", value)

    @property
    @pulumi.getter(name="segmentIndexBytes")
    def segment_index_bytes(self) -> Optional[pulumi.Input[str]]:
        """
        segment.index.bytes value
        """
        return pulumi.get(self, "segment_index_bytes")

    @segment_index_bytes.setter
    def segment_index_bytes(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "segment_index_bytes", value)

    @property
    @pulumi.getter(name="segmentJitterMs")
    def segment_jitter_ms(self) -> Optional[pulumi.Input[str]]:
        """
        segment.jitter.ms value
        """
        return pulumi.get(self, "segment_jitter_ms")

    @segment_jitter_ms.setter
    def segment_jitter_ms(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "segment_jitter_ms", value)

    @property
    @pulumi.getter(name="segmentMs")
    def segment_ms(self) -> Optional[pulumi.Input[str]]:
        """
        segment.ms value
        """
        return pulumi.get(self, "segment_ms")

    @segment_ms.setter
    def segment_ms(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "segment_ms", value)

    @property
    @pulumi.getter(name="uncleanLeaderElectionEnable")
    def unclean_leader_election_enable(self) -> Optional[pulumi.Input[bool]]:
        """
        unclean.leader.election.enable value; This field is deprecated and no longer functional.
        """
        warnings.warn("""This field is deprecated and no longer functional.""", DeprecationWarning)
        pulumi.log.warn("""unclean_leader_election_enable is deprecated: This field is deprecated and no longer functional.""")

        return pulumi.get(self, "unclean_leader_election_enable")

    @unclean_leader_election_enable.setter
    def unclean_leader_election_enable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "unclean_leader_election_enable", value)


@pulumi.input_type
class KafkaTopicTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] key: Topic tag key. Maximum length: `64`.
        :param pulumi.Input[str] value: Topic tag value. Maximum length: `256`.
        """
        pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        Topic tag key. Maximum length: `64`.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[str]]:
        """
        Topic tag value. Maximum length: `256`.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class M3AggregatorComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[str]] = None,
                 host: Optional[pulumi.Input[str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 route: Optional[pulumi.Input[str]] = None,
                 ssl: Optional[pulumi.Input[bool]] = None,
                 usage: Optional[pulumi.Input[str]] = None):
        if component is not None:
            pulumi.set(__self__, "component", component)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if kafka_authentication_method is not None:
            pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if route is not None:
            pulumi.set(__self__, "route", route)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if usage is not None:
            pulumi.set(__self__, "usage", usage)

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

    @component.setter
    def component(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "component", value)

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

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

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

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kafka_authentication_method", 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
    def route(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route", value)

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

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl", value)

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

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "usage", value)


@pulumi.input_type
class M3AggregatorM3aggregatorArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class M3AggregatorM3aggregatorUserConfigArgs:
    def __init__(__self__, *,
                 custom_domain: Optional[pulumi.Input[str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['M3AggregatorM3aggregatorUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 m3_version: Optional[pulumi.Input[str]] = None,
                 m3aggregator_version: Optional[pulumi.Input[str]] = None,
                 static_ips: Optional[pulumi.Input[bool]] = None):
        if custom_domain is not None:
            pulumi.set(__self__, "custom_domain", custom_domain)
        if ip_filter_objects is not None:
            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
        if ip_filter_strings is not None:
            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
        if ip_filters is not None:
            warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        if m3_version is not None:
            warnings.warn("""Usage of this field is discouraged.""", DeprecationWarning)
            pulumi.log.warn("""m3_version is deprecated: Usage of this field is discouraged.""")
        if m3_version is not None:
            pulumi.set(__self__, "m3_version", m3_version)
        if m3aggregator_version is not None:
            pulumi.set(__self__, "m3aggregator_version", m3aggregator_version)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)

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

    @custom_domain.setter
    def custom_domain(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "custom_domain", value)

    @property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['M3AggregatorM3aggregatorUserConfigIpFilterObjectArgs']]]]:
        return pulumi.get(self, "ip_filter_objects")

    @ip_filter_objects.setter
    def ip_filter_objects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['M3AggregatorM3aggregatorUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

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

    @ip_filter_strings.setter
    def ip_filter_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @property
    @pulumi.getter(name="ipFilters")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
        pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")

        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filters", value)

    @property
    @pulumi.getter(name="m3Version")
    def m3_version(self) -> Optional[pulumi.Input[str]]:
        warnings.warn("""Usage of this field is discouraged.""", DeprecationWarning)
        pulumi.log.warn("""m3_version is deprecated: Usage of this field is discouraged.""")

        return pulumi.get(self, "m3_version")

    @m3_version.setter
    def m3_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "m3_version", value)

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

    @m3aggregator_version.setter
    def m3aggregator_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "m3aggregator_version", value)

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

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "static_ips", value)


@pulumi.input_type
class M3AggregatorM3aggregatorUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

    @network.setter
    def network(self, value: pulumi.Input[str]):
        pulumi.set(self, "network", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class M3AggregatorServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[str],
                 source_service_name: pulumi.Input[str]):
        pulumi.set(__self__, "integration_type", integration_type)
        pulumi.set(__self__, "source_service_name", source_service_name)

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

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "integration_type", value)

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

    @source_service_name.setter
    def source_service_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "source_service_name", value)


@pulumi.input_type
class M3AggregatorTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class M3DbComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[str]] = None,
                 host: Optional[pulumi.Input[str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 route: Optional[pulumi.Input[str]] = None,
                 ssl: Optional[pulumi.Input[bool]] = None,
                 usage: Optional[pulumi.Input[str]] = None):
        if component is not None:
            pulumi.set(__self__, "component", component)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if kafka_authentication_method is not None:
            pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if route is not None:
            pulumi.set(__self__, "route", route)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if usage is not None:
            pulumi.set(__self__, "usage", usage)

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

    @component.setter
    def component(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "component", value)

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

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

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

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kafka_authentication_method", 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
    def route(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route", value)

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

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl", value)

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

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "usage", value)


@pulumi.input_type
class M3DbM3dbArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class M3DbM3dbUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[str]] = None,
                 custom_domain: Optional[pulumi.Input[str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 limits: Optional[pulumi.Input['M3DbM3dbUserConfigLimitsArgs']] = None,
                 m3: Optional[pulumi.Input['M3DbM3dbUserConfigM3Args']] = None,
                 m3_version: Optional[pulumi.Input[str]] = None,
                 m3coordinator_enable_graphite_carbon_ingest: Optional[pulumi.Input[bool]] = None,
                 m3db_version: Optional[pulumi.Input[str]] = None,
                 namespaces: Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigNamespaceArgs']]]] = None,
                 private_access: Optional[pulumi.Input['M3DbM3dbUserConfigPrivateAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[str]] = None,
                 public_access: Optional[pulumi.Input['M3DbM3dbUserConfigPublicAccessArgs']] = None,
                 rules: Optional[pulumi.Input['M3DbM3dbUserConfigRulesArgs']] = None,
                 service_to_fork_from: Optional[pulumi.Input[str]] = None,
                 static_ips: Optional[pulumi.Input[bool]] = None):
        if additional_backup_regions is not None:
            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
        if custom_domain is not None:
            pulumi.set(__self__, "custom_domain", custom_domain)
        if ip_filter_objects is not None:
            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
        if ip_filter_strings is not None:
            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
        if ip_filters is not None:
            warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        if limits is not None:
            pulumi.set(__self__, "limits", limits)
        if m3 is not None:
            pulumi.set(__self__, "m3", m3)
        if m3_version is not None:
            warnings.warn("""Usage of this field is discouraged.""", DeprecationWarning)
            pulumi.log.warn("""m3_version is deprecated: Usage of this field is discouraged.""")
        if m3_version is not None:
            pulumi.set(__self__, "m3_version", m3_version)
        if m3coordinator_enable_graphite_carbon_ingest is not None:
            pulumi.set(__self__, "m3coordinator_enable_graphite_carbon_ingest", m3coordinator_enable_graphite_carbon_ingest)
        if m3db_version is not None:
            pulumi.set(__self__, "m3db_version", m3db_version)
        if namespaces is not None:
            pulumi.set(__self__, "namespaces", namespaces)
        if private_access is not None:
            pulumi.set(__self__, "private_access", private_access)
        if project_to_fork_from is not None:
            pulumi.set(__self__, "project_to_fork_from", project_to_fork_from)
        if public_access is not None:
            pulumi.set(__self__, "public_access", public_access)
        if rules is not None:
            pulumi.set(__self__, "rules", rules)
        if service_to_fork_from is not None:
            pulumi.set(__self__, "service_to_fork_from", service_to_fork_from)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)

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

    @additional_backup_regions.setter
    def additional_backup_regions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "additional_backup_regions", value)

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

    @custom_domain.setter
    def custom_domain(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "custom_domain", value)

    @property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigIpFilterObjectArgs']]]]:
        return pulumi.get(self, "ip_filter_objects")

    @ip_filter_objects.setter
    def ip_filter_objects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

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

    @ip_filter_strings.setter
    def ip_filter_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @property
    @pulumi.getter(name="ipFilters")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
        pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")

        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filters", value)

    @property
    @pulumi.getter
    def limits(self) -> Optional[pulumi.Input['M3DbM3dbUserConfigLimitsArgs']]:
        return pulumi.get(self, "limits")

    @limits.setter
    def limits(self, value: Optional[pulumi.Input['M3DbM3dbUserConfigLimitsArgs']]):
        pulumi.set(self, "limits", value)

    @property
    @pulumi.getter
    def m3(self) -> Optional[pulumi.Input['M3DbM3dbUserConfigM3Args']]:
        return pulumi.get(self, "m3")

    @m3.setter
    def m3(self, value: Optional[pulumi.Input['M3DbM3dbUserConfigM3Args']]):
        pulumi.set(self, "m3", value)

    @property
    @pulumi.getter(name="m3Version")
    def m3_version(self) -> Optional[pulumi.Input[str]]:
        warnings.warn("""Usage of this field is discouraged.""", DeprecationWarning)
        pulumi.log.warn("""m3_version is deprecated: Usage of this field is discouraged.""")

        return pulumi.get(self, "m3_version")

    @m3_version.setter
    def m3_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "m3_version", value)

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

    @m3coordinator_enable_graphite_carbon_ingest.setter
    def m3coordinator_enable_graphite_carbon_ingest(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "m3coordinator_enable_graphite_carbon_ingest", value)

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

    @m3db_version.setter
    def m3db_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "m3db_version", value)

    @property
    @pulumi.getter
    def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigNamespaceArgs']]]]:
        return pulumi.get(self, "namespaces")

    @namespaces.setter
    def namespaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigNamespaceArgs']]]]):
        pulumi.set(self, "namespaces", value)

    @property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['M3DbM3dbUserConfigPrivateAccessArgs']]:
        return pulumi.get(self, "private_access")

    @private_access.setter
    def private_access(self, value: Optional[pulumi.Input['M3DbM3dbUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

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

    @project_to_fork_from.setter
    def project_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "project_to_fork_from", value)

    @property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['M3DbM3dbUserConfigPublicAccessArgs']]:
        return pulumi.get(self, "public_access")

    @public_access.setter
    def public_access(self, value: Optional[pulumi.Input['M3DbM3dbUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

    @property
    @pulumi.getter
    def rules(self) -> Optional[pulumi.Input['M3DbM3dbUserConfigRulesArgs']]:
        return pulumi.get(self, "rules")

    @rules.setter
    def rules(self, value: Optional[pulumi.Input['M3DbM3dbUserConfigRulesArgs']]):
        pulumi.set(self, "rules", value)

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

    @service_to_fork_from.setter
    def service_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_to_fork_from", value)

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

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "static_ips", value)


@pulumi.input_type
class M3DbM3dbUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

    @network.setter
    def network(self, value: pulumi.Input[str]):
        pulumi.set(self, "network", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class M3DbM3dbUserConfigLimitsArgs:
    def __init__(__self__, *,
                 max_recently_queried_series_blocks: Optional[pulumi.Input[int]] = None,
                 max_recently_queried_series_disk_bytes_read: Optional[pulumi.Input[int]] = None,
                 max_recently_queried_series_lookback: Optional[pulumi.Input[str]] = None,
                 query_docs: Optional[pulumi.Input[int]] = None,
                 query_require_exhaustive: Optional[pulumi.Input[bool]] = None,
                 query_series: Optional[pulumi.Input[int]] = None):
        if max_recently_queried_series_blocks is not None:
            pulumi.set(__self__, "max_recently_queried_series_blocks", max_recently_queried_series_blocks)
        if max_recently_queried_series_disk_bytes_read is not None:
            pulumi.set(__self__, "max_recently_queried_series_disk_bytes_read", max_recently_queried_series_disk_bytes_read)
        if max_recently_queried_series_lookback is not None:
            pulumi.set(__self__, "max_recently_queried_series_lookback", max_recently_queried_series_lookback)
        if query_docs is not None:
            pulumi.set(__self__, "query_docs", query_docs)
        if query_require_exhaustive is not None:
            pulumi.set(__self__, "query_require_exhaustive", query_require_exhaustive)
        if query_series is not None:
            pulumi.set(__self__, "query_series", query_series)

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

    @max_recently_queried_series_blocks.setter
    def max_recently_queried_series_blocks(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_recently_queried_series_blocks", value)

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

    @max_recently_queried_series_disk_bytes_read.setter
    def max_recently_queried_series_disk_bytes_read(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_recently_queried_series_disk_bytes_read", value)

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

    @max_recently_queried_series_lookback.setter
    def max_recently_queried_series_lookback(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "max_recently_queried_series_lookback", value)

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

    @query_docs.setter
    def query_docs(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "query_docs", value)

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

    @query_require_exhaustive.setter
    def query_require_exhaustive(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "query_require_exhaustive", value)

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

    @query_series.setter
    def query_series(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "query_series", value)


@pulumi.input_type
class M3DbM3dbUserConfigM3Args:
    def __init__(__self__, *,
                 tag_options: Optional[pulumi.Input['M3DbM3dbUserConfigM3TagOptionsArgs']] = None):
        if tag_options is not None:
            pulumi.set(__self__, "tag_options", tag_options)

    @property
    @pulumi.getter(name="tagOptions")
    def tag_options(self) -> Optional[pulumi.Input['M3DbM3dbUserConfigM3TagOptionsArgs']]:
        return pulumi.get(self, "tag_options")

    @tag_options.setter
    def tag_options(self, value: Optional[pulumi.Input['M3DbM3dbUserConfigM3TagOptionsArgs']]):
        pulumi.set(self, "tag_options", value)


@pulumi.input_type
class M3DbM3dbUserConfigM3TagOptionsArgs:
    def __init__(__self__, *,
                 allow_tag_name_duplicates: Optional[pulumi.Input[bool]] = None,
                 allow_tag_value_empty: Optional[pulumi.Input[bool]] = None):
        if allow_tag_name_duplicates is not None:
            pulumi.set(__self__, "allow_tag_name_duplicates", allow_tag_name_duplicates)
        if allow_tag_value_empty is not None:
            pulumi.set(__self__, "allow_tag_value_empty", allow_tag_value_empty)

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

    @allow_tag_name_duplicates.setter
    def allow_tag_name_duplicates(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_tag_name_duplicates", value)

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

    @allow_tag_value_empty.setter
    def allow_tag_value_empty(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "allow_tag_value_empty", value)


@pulumi.input_type
class M3DbM3dbUserConfigNamespaceArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 type: pulumi.Input[str],
                 options: Optional[pulumi.Input['M3DbM3dbUserConfigNamespaceOptionsArgs']] = None,
                 resolution: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)
        if options is not None:
            pulumi.set(__self__, "options", options)
        if resolution is not None:
            pulumi.set(__self__, "resolution", resolution)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        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]:
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)

    @property
    @pulumi.getter
    def options(self) -> Optional[pulumi.Input['M3DbM3dbUserConfigNamespaceOptionsArgs']]:
        return pulumi.get(self, "options")

    @options.setter
    def options(self, value: Optional[pulumi.Input['M3DbM3dbUserConfigNamespaceOptionsArgs']]):
        pulumi.set(self, "options", value)

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

    @resolution.setter
    def resolution(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resolution", value)


@pulumi.input_type
class M3DbM3dbUserConfigNamespaceOptionsArgs:
    def __init__(__self__, *,
                 retention_options: Optional[pulumi.Input['M3DbM3dbUserConfigNamespaceOptionsRetentionOptionsArgs']] = None,
                 snapshot_enabled: Optional[pulumi.Input[bool]] = None,
                 writes_to_commitlog: Optional[pulumi.Input[bool]] = None):
        if retention_options is not None:
            pulumi.set(__self__, "retention_options", retention_options)
        if snapshot_enabled is not None:
            pulumi.set(__self__, "snapshot_enabled", snapshot_enabled)
        if writes_to_commitlog is not None:
            pulumi.set(__self__, "writes_to_commitlog", writes_to_commitlog)

    @property
    @pulumi.getter(name="retentionOptions")
    def retention_options(self) -> Optional[pulumi.Input['M3DbM3dbUserConfigNamespaceOptionsRetentionOptionsArgs']]:
        return pulumi.get(self, "retention_options")

    @retention_options.setter
    def retention_options(self, value: Optional[pulumi.Input['M3DbM3dbUserConfigNamespaceOptionsRetentionOptionsArgs']]):
        pulumi.set(self, "retention_options", value)

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

    @snapshot_enabled.setter
    def snapshot_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "snapshot_enabled", value)

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

    @writes_to_commitlog.setter
    def writes_to_commitlog(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "writes_to_commitlog", value)


@pulumi.input_type
class M3DbM3dbUserConfigNamespaceOptionsRetentionOptionsArgs:
    def __init__(__self__, *,
                 block_data_expiry_duration: Optional[pulumi.Input[str]] = None,
                 blocksize_duration: Optional[pulumi.Input[str]] = None,
                 buffer_future_duration: Optional[pulumi.Input[str]] = None,
                 buffer_past_duration: Optional[pulumi.Input[str]] = None,
                 retention_period_duration: Optional[pulumi.Input[str]] = None):
        if block_data_expiry_duration is not None:
            pulumi.set(__self__, "block_data_expiry_duration", block_data_expiry_duration)
        if blocksize_duration is not None:
            pulumi.set(__self__, "blocksize_duration", blocksize_duration)
        if buffer_future_duration is not None:
            pulumi.set(__self__, "buffer_future_duration", buffer_future_duration)
        if buffer_past_duration is not None:
            pulumi.set(__self__, "buffer_past_duration", buffer_past_duration)
        if retention_period_duration is not None:
            pulumi.set(__self__, "retention_period_duration", retention_period_duration)

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

    @block_data_expiry_duration.setter
    def block_data_expiry_duration(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "block_data_expiry_duration", value)

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

    @blocksize_duration.setter
    def blocksize_duration(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "blocksize_duration", value)

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

    @buffer_future_duration.setter
    def buffer_future_duration(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "buffer_future_duration", value)

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

    @buffer_past_duration.setter
    def buffer_past_duration(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "buffer_past_duration", value)

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

    @retention_period_duration.setter
    def retention_period_duration(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "retention_period_duration", value)


@pulumi.input_type
class M3DbM3dbUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 m3coordinator: Optional[pulumi.Input[bool]] = None):
        if m3coordinator is not None:
            pulumi.set(__self__, "m3coordinator", m3coordinator)

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

    @m3coordinator.setter
    def m3coordinator(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "m3coordinator", value)


@pulumi.input_type
class M3DbM3dbUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 m3coordinator: Optional[pulumi.Input[bool]] = None):
        if m3coordinator is not None:
            pulumi.set(__self__, "m3coordinator", m3coordinator)

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

    @m3coordinator.setter
    def m3coordinator(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "m3coordinator", value)


@pulumi.input_type
class M3DbM3dbUserConfigRulesArgs:
    def __init__(__self__, *,
                 mappings: Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingArgs']]]] = None):
        if mappings is not None:
            pulumi.set(__self__, "mappings", mappings)

    @property
    @pulumi.getter
    def mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingArgs']]]]:
        return pulumi.get(self, "mappings")

    @mappings.setter
    def mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingArgs']]]]):
        pulumi.set(self, "mappings", value)


@pulumi.input_type
class M3DbM3dbUserConfigRulesMappingArgs:
    def __init__(__self__, *,
                 filter: pulumi.Input[str],
                 aggregations: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 drop: Optional[pulumi.Input[bool]] = None,
                 name: Optional[pulumi.Input[str]] = None,
                 namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 namespaces_objects: Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingNamespacesObjectArgs']]]] = None,
                 namespaces_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingTagArgs']]]] = None):
        pulumi.set(__self__, "filter", filter)
        if aggregations is not None:
            pulumi.set(__self__, "aggregations", aggregations)
        if drop is not None:
            pulumi.set(__self__, "drop", drop)
        if name is not None:
            pulumi.set(__self__, "name", name)
        if namespaces is not None:
            warnings.warn("""This will be removed in v5.0.0 and replaced with namespaces_string instead.""", DeprecationWarning)
            pulumi.log.warn("""namespaces is deprecated: This will be removed in v5.0.0 and replaced with namespaces_string instead.""")
        if namespaces is not None:
            pulumi.set(__self__, "namespaces", namespaces)
        if namespaces_objects is not None:
            pulumi.set(__self__, "namespaces_objects", namespaces_objects)
        if namespaces_strings is not None:
            pulumi.set(__self__, "namespaces_strings", namespaces_strings)
        if tags is not None:
            pulumi.set(__self__, "tags", tags)

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

    @filter.setter
    def filter(self, value: pulumi.Input[str]):
        pulumi.set(self, "filter", value)

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

    @aggregations.setter
    def aggregations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "aggregations", value)

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

    @drop.setter
    def drop(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "drop", value)

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

    @name.setter
    def name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "name", value)

    @property
    @pulumi.getter
    def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        warnings.warn("""This will be removed in v5.0.0 and replaced with namespaces_string instead.""", DeprecationWarning)
        pulumi.log.warn("""namespaces is deprecated: This will be removed in v5.0.0 and replaced with namespaces_string instead.""")

        return pulumi.get(self, "namespaces")

    @namespaces.setter
    def namespaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "namespaces", value)

    @property
    @pulumi.getter(name="namespacesObjects")
    def namespaces_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingNamespacesObjectArgs']]]]:
        return pulumi.get(self, "namespaces_objects")

    @namespaces_objects.setter
    def namespaces_objects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingNamespacesObjectArgs']]]]):
        pulumi.set(self, "namespaces_objects", value)

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

    @namespaces_strings.setter
    def namespaces_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "namespaces_strings", value)

    @property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingTagArgs']]]]:
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingTagArgs']]]]):
        pulumi.set(self, "tags", value)


@pulumi.input_type
class M3DbM3dbUserConfigRulesMappingNamespacesObjectArgs:
    def __init__(__self__, *,
                 resolution: Optional[pulumi.Input[str]] = None,
                 retention: Optional[pulumi.Input[str]] = None):
        if resolution is not None:
            pulumi.set(__self__, "resolution", resolution)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)

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

    @resolution.setter
    def resolution(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "resolution", value)

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

    @retention.setter
    def retention(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "retention", value)


@pulumi.input_type
class M3DbM3dbUserConfigRulesMappingTagArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

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

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class M3DbServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[str],
                 source_service_name: pulumi.Input[str]):
        pulumi.set(__self__, "integration_type", integration_type)
        pulumi.set(__self__, "source_service_name", source_service_name)

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

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "integration_type", value)

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

    @source_service_name.setter
    def source_service_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "source_service_name", value)


@pulumi.input_type
class M3DbTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class MySqlComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[str]] = None,
                 host: Optional[pulumi.Input[str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 route: Optional[pulumi.Input[str]] = None,
                 ssl: Optional[pulumi.Input[bool]] = None,
                 usage: Optional[pulumi.Input[str]] = None):
        if component is not None:
            pulumi.set(__self__, "component", component)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if kafka_authentication_method is not None:
            pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if route is not None:
            pulumi.set(__self__, "route", route)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if usage is not None:
            pulumi.set(__self__, "usage", usage)

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

    @component.setter
    def component(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "component", value)

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

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

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

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kafka_authentication_method", 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
    def route(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route", value)

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

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl", value)

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

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "usage", value)


@pulumi.input_type
class MySqlMysqlArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class MySqlMysqlUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[str]] = None,
                 admin_password: Optional[pulumi.Input[str]] = None,
                 admin_username: Optional[pulumi.Input[str]] = None,
                 backup_hour: Optional[pulumi.Input[int]] = None,
                 backup_minute: Optional[pulumi.Input[int]] = None,
                 binlog_retention_period: Optional[pulumi.Input[int]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['MySqlMysqlUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 migration: Optional[pulumi.Input['MySqlMysqlUserConfigMigrationArgs']] = None,
                 mysql: Optional[pulumi.Input['MySqlMysqlUserConfigMysqlArgs']] = None,
                 mysql_version: Optional[pulumi.Input[str]] = None,
                 private_access: Optional[pulumi.Input['MySqlMysqlUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['MySqlMysqlUserConfigPrivatelinkAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[str]] = None,
                 public_access: Optional[pulumi.Input['MySqlMysqlUserConfigPublicAccessArgs']] = None,
                 recovery_target_time: Optional[pulumi.Input[str]] = None,
                 service_to_fork_from: Optional[pulumi.Input[str]] = None,
                 static_ips: Optional[pulumi.Input[bool]] = None):
        if additional_backup_regions is not None:
            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
        if admin_password is not None:
            pulumi.set(__self__, "admin_password", admin_password)
        if admin_username is not None:
            pulumi.set(__self__, "admin_username", admin_username)
        if backup_hour is not None:
            pulumi.set(__self__, "backup_hour", backup_hour)
        if backup_minute is not None:
            pulumi.set(__self__, "backup_minute", backup_minute)
        if binlog_retention_period is not None:
            pulumi.set(__self__, "binlog_retention_period", binlog_retention_period)
        if ip_filter_objects is not None:
            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
        if ip_filter_strings is not None:
            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
        if ip_filters is not None:
            warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        if migration is not None:
            pulumi.set(__self__, "migration", migration)
        if mysql is not None:
            pulumi.set(__self__, "mysql", mysql)
        if mysql_version is not None:
            pulumi.set(__self__, "mysql_version", mysql_version)
        if private_access is not None:
            pulumi.set(__self__, "private_access", private_access)
        if privatelink_access is not None:
            pulumi.set(__self__, "privatelink_access", privatelink_access)
        if project_to_fork_from is not None:
            pulumi.set(__self__, "project_to_fork_from", project_to_fork_from)
        if public_access is not None:
            pulumi.set(__self__, "public_access", public_access)
        if recovery_target_time is not None:
            pulumi.set(__self__, "recovery_target_time", recovery_target_time)
        if service_to_fork_from is not None:
            pulumi.set(__self__, "service_to_fork_from", service_to_fork_from)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)

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

    @additional_backup_regions.setter
    def additional_backup_regions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "additional_backup_regions", value)

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

    @admin_password.setter
    def admin_password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "admin_password", value)

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

    @admin_username.setter
    def admin_username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "admin_username", value)

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

    @backup_hour.setter
    def backup_hour(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "backup_hour", value)

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

    @backup_minute.setter
    def backup_minute(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "backup_minute", value)

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

    @binlog_retention_period.setter
    def binlog_retention_period(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "binlog_retention_period", value)

    @property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MySqlMysqlUserConfigIpFilterObjectArgs']]]]:
        return pulumi.get(self, "ip_filter_objects")

    @ip_filter_objects.setter
    def ip_filter_objects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MySqlMysqlUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

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

    @ip_filter_strings.setter
    def ip_filter_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @property
    @pulumi.getter(name="ipFilters")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
        pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")

        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filters", value)

    @property
    @pulumi.getter
    def migration(self) -> Optional[pulumi.Input['MySqlMysqlUserConfigMigrationArgs']]:
        return pulumi.get(self, "migration")

    @migration.setter
    def migration(self, value: Optional[pulumi.Input['MySqlMysqlUserConfigMigrationArgs']]):
        pulumi.set(self, "migration", value)

    @property
    @pulumi.getter
    def mysql(self) -> Optional[pulumi.Input['MySqlMysqlUserConfigMysqlArgs']]:
        return pulumi.get(self, "mysql")

    @mysql.setter
    def mysql(self, value: Optional[pulumi.Input['MySqlMysqlUserConfigMysqlArgs']]):
        pulumi.set(self, "mysql", value)

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

    @mysql_version.setter
    def mysql_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "mysql_version", value)

    @property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['MySqlMysqlUserConfigPrivateAccessArgs']]:
        return pulumi.get(self, "private_access")

    @private_access.setter
    def private_access(self, value: Optional[pulumi.Input['MySqlMysqlUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['MySqlMysqlUserConfigPrivatelinkAccessArgs']]:
        return pulumi.get(self, "privatelink_access")

    @privatelink_access.setter
    def privatelink_access(self, value: Optional[pulumi.Input['MySqlMysqlUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)

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

    @project_to_fork_from.setter
    def project_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "project_to_fork_from", value)

    @property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['MySqlMysqlUserConfigPublicAccessArgs']]:
        return pulumi.get(self, "public_access")

    @public_access.setter
    def public_access(self, value: Optional[pulumi.Input['MySqlMysqlUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

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

    @recovery_target_time.setter
    def recovery_target_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "recovery_target_time", value)

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

    @service_to_fork_from.setter
    def service_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_to_fork_from", value)

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

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "static_ips", value)


@pulumi.input_type
class MySqlMysqlUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

    @network.setter
    def network(self, value: pulumi.Input[str]):
        pulumi.set(self, "network", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class MySqlMysqlUserConfigMigrationArgs:
    def __init__(__self__, *,
                 host: pulumi.Input[str],
                 port: pulumi.Input[int],
                 dbname: Optional[pulumi.Input[str]] = None,
                 ignore_dbs: Optional[pulumi.Input[str]] = None,
                 method: Optional[pulumi.Input[str]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 ssl: Optional[pulumi.Input[bool]] = None,
                 username: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)
        if dbname is not None:
            pulumi.set(__self__, "dbname", dbname)
        if ignore_dbs is not None:
            pulumi.set(__self__, "ignore_dbs", ignore_dbs)
        if method is not None:
            pulumi.set(__self__, "method", method)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if username is not None:
            pulumi.set(__self__, "username", username)

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

    @host.setter
    def host(self, value: pulumi.Input[str]):
        pulumi.set(self, "host", value)

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

    @port.setter
    def port(self, value: pulumi.Input[int]):
        pulumi.set(self, "port", value)

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

    @dbname.setter
    def dbname(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dbname", value)

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

    @ignore_dbs.setter
    def ignore_dbs(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ignore_dbs", value)

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

    @method.setter
    def method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "method", value)

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

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

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

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl", value)

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

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)


@pulumi.input_type
class MySqlMysqlUserConfigMysqlArgs:
    def __init__(__self__, *,
                 connect_timeout: Optional[pulumi.Input[int]] = None,
                 default_time_zone: Optional[pulumi.Input[str]] = None,
                 group_concat_max_len: Optional[pulumi.Input[int]] = None,
                 information_schema_stats_expiry: Optional[pulumi.Input[int]] = None,
                 innodb_change_buffer_max_size: Optional[pulumi.Input[int]] = None,
                 innodb_flush_neighbors: Optional[pulumi.Input[int]] = None,
                 innodb_ft_min_token_size: Optional[pulumi.Input[int]] = None,
                 innodb_ft_server_stopword_table: Optional[pulumi.Input[str]] = None,
                 innodb_lock_wait_timeout: Optional[pulumi.Input[int]] = None,
                 innodb_log_buffer_size: Optional[pulumi.Input[int]] = None,
                 innodb_online_alter_log_max_size: Optional[pulumi.Input[int]] = None,
                 innodb_print_all_deadlocks: Optional[pulumi.Input[bool]] = None,
                 innodb_read_io_threads: Optional[pulumi.Input[int]] = None,
                 innodb_rollback_on_timeout: Optional[pulumi.Input[bool]] = None,
                 innodb_thread_concurrency: Optional[pulumi.Input[int]] = None,
                 innodb_write_io_threads: Optional[pulumi.Input[int]] = None,
                 interactive_timeout: Optional[pulumi.Input[int]] = None,
                 internal_tmp_mem_storage_engine: Optional[pulumi.Input[str]] = None,
                 long_query_time: Optional[pulumi.Input[float]] = None,
                 max_allowed_packet: Optional[pulumi.Input[int]] = None,
                 max_heap_table_size: Optional[pulumi.Input[int]] = None,
                 net_buffer_length: Optional[pulumi.Input[int]] = None,
                 net_read_timeout: Optional[pulumi.Input[int]] = None,
                 net_write_timeout: Optional[pulumi.Input[int]] = None,
                 slow_query_log: Optional[pulumi.Input[bool]] = None,
                 sort_buffer_size: Optional[pulumi.Input[int]] = None,
                 sql_mode: Optional[pulumi.Input[str]] = None,
                 sql_require_primary_key: Optional[pulumi.Input[bool]] = None,
                 tmp_table_size: Optional[pulumi.Input[int]] = None,
                 wait_timeout: Optional[pulumi.Input[int]] = None):
        if connect_timeout is not None:
            pulumi.set(__self__, "connect_timeout", connect_timeout)
        if default_time_zone is not None:
            pulumi.set(__self__, "default_time_zone", default_time_zone)
        if group_concat_max_len is not None:
            pulumi.set(__self__, "group_concat_max_len", group_concat_max_len)
        if information_schema_stats_expiry is not None:
            pulumi.set(__self__, "information_schema_stats_expiry", information_schema_stats_expiry)
        if innodb_change_buffer_max_size is not None:
            pulumi.set(__self__, "innodb_change_buffer_max_size", innodb_change_buffer_max_size)
        if innodb_flush_neighbors is not None:
            pulumi.set(__self__, "innodb_flush_neighbors", innodb_flush_neighbors)
        if innodb_ft_min_token_size is not None:
            pulumi.set(__self__, "innodb_ft_min_token_size", innodb_ft_min_token_size)
        if innodb_ft_server_stopword_table is not None:
            pulumi.set(__self__, "innodb_ft_server_stopword_table", innodb_ft_server_stopword_table)
        if innodb_lock_wait_timeout is not None:
            pulumi.set(__self__, "innodb_lock_wait_timeout", innodb_lock_wait_timeout)
        if innodb_log_buffer_size is not None:
            pulumi.set(__self__, "innodb_log_buffer_size", innodb_log_buffer_size)
        if innodb_online_alter_log_max_size is not None:
            pulumi.set(__self__, "innodb_online_alter_log_max_size", innodb_online_alter_log_max_size)
        if innodb_print_all_deadlocks is not None:
            pulumi.set(__self__, "innodb_print_all_deadlocks", innodb_print_all_deadlocks)
        if innodb_read_io_threads is not None:
            pulumi.set(__self__, "innodb_read_io_threads", innodb_read_io_threads)
        if innodb_rollback_on_timeout is not None:
            pulumi.set(__self__, "innodb_rollback_on_timeout", innodb_rollback_on_timeout)
        if innodb_thread_concurrency is not None:
            pulumi.set(__self__, "innodb_thread_concurrency", innodb_thread_concurrency)
        if innodb_write_io_threads is not None:
            pulumi.set(__self__, "innodb_write_io_threads", innodb_write_io_threads)
        if interactive_timeout is not None:
            pulumi.set(__self__, "interactive_timeout", interactive_timeout)
        if internal_tmp_mem_storage_engine is not None:
            pulumi.set(__self__, "internal_tmp_mem_storage_engine", internal_tmp_mem_storage_engine)
        if long_query_time is not None:
            pulumi.set(__self__, "long_query_time", long_query_time)
        if max_allowed_packet is not None:
            pulumi.set(__self__, "max_allowed_packet", max_allowed_packet)
        if max_heap_table_size is not None:
            pulumi.set(__self__, "max_heap_table_size", max_heap_table_size)
        if net_buffer_length is not None:
            pulumi.set(__self__, "net_buffer_length", net_buffer_length)
        if net_read_timeout is not None:
            pulumi.set(__self__, "net_read_timeout", net_read_timeout)
        if net_write_timeout is not None:
            pulumi.set(__self__, "net_write_timeout", net_write_timeout)
        if slow_query_log is not None:
            pulumi.set(__self__, "slow_query_log", slow_query_log)
        if sort_buffer_size is not None:
            pulumi.set(__self__, "sort_buffer_size", sort_buffer_size)
        if sql_mode is not None:
            pulumi.set(__self__, "sql_mode", sql_mode)
        if sql_require_primary_key is not None:
            pulumi.set(__self__, "sql_require_primary_key", sql_require_primary_key)
        if tmp_table_size is not None:
            pulumi.set(__self__, "tmp_table_size", tmp_table_size)
        if wait_timeout is not None:
            pulumi.set(__self__, "wait_timeout", wait_timeout)

    @property
    @pulumi.getter(name="connectTimeout")
    def connect_timeout(self) -> Optional[pulumi.Input[int]]:
        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="defaultTimeZone")
    def default_time_zone(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "default_time_zone")

    @default_time_zone.setter
    def default_time_zone(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "default_time_zone", value)

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

    @group_concat_max_len.setter
    def group_concat_max_len(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "group_concat_max_len", value)

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

    @information_schema_stats_expiry.setter
    def information_schema_stats_expiry(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "information_schema_stats_expiry", value)

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

    @innodb_change_buffer_max_size.setter
    def innodb_change_buffer_max_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "innodb_change_buffer_max_size", value)

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

    @innodb_flush_neighbors.setter
    def innodb_flush_neighbors(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "innodb_flush_neighbors", value)

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

    @innodb_ft_min_token_size.setter
    def innodb_ft_min_token_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "innodb_ft_min_token_size", value)

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

    @innodb_ft_server_stopword_table.setter
    def innodb_ft_server_stopword_table(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "innodb_ft_server_stopword_table", value)

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

    @innodb_lock_wait_timeout.setter
    def innodb_lock_wait_timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "innodb_lock_wait_timeout", value)

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

    @innodb_log_buffer_size.setter
    def innodb_log_buffer_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "innodb_log_buffer_size", value)

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

    @innodb_online_alter_log_max_size.setter
    def innodb_online_alter_log_max_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "innodb_online_alter_log_max_size", value)

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

    @innodb_print_all_deadlocks.setter
    def innodb_print_all_deadlocks(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "innodb_print_all_deadlocks", value)

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

    @innodb_read_io_threads.setter
    def innodb_read_io_threads(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "innodb_read_io_threads", value)

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

    @innodb_rollback_on_timeout.setter
    def innodb_rollback_on_timeout(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "innodb_rollback_on_timeout", value)

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

    @innodb_thread_concurrency.setter
    def innodb_thread_concurrency(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "innodb_thread_concurrency", value)

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

    @innodb_write_io_threads.setter
    def innodb_write_io_threads(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "innodb_write_io_threads", value)

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

    @interactive_timeout.setter
    def interactive_timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "interactive_timeout", value)

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

    @internal_tmp_mem_storage_engine.setter
    def internal_tmp_mem_storage_engine(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "internal_tmp_mem_storage_engine", value)

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

    @long_query_time.setter
    def long_query_time(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "long_query_time", value)

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

    @max_allowed_packet.setter
    def max_allowed_packet(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_allowed_packet", value)

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

    @max_heap_table_size.setter
    def max_heap_table_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_heap_table_size", value)

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

    @net_buffer_length.setter
    def net_buffer_length(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "net_buffer_length", value)

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

    @net_read_timeout.setter
    def net_read_timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "net_read_timeout", value)

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

    @net_write_timeout.setter
    def net_write_timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "net_write_timeout", value)

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

    @slow_query_log.setter
    def slow_query_log(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "slow_query_log", value)

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

    @sort_buffer_size.setter
    def sort_buffer_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "sort_buffer_size", value)

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

    @sql_mode.setter
    def sql_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sql_mode", value)

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

    @sql_require_primary_key.setter
    def sql_require_primary_key(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "sql_require_primary_key", value)

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

    @tmp_table_size.setter
    def tmp_table_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "tmp_table_size", value)

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

    @wait_timeout.setter
    def wait_timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "wait_timeout", value)


@pulumi.input_type
class MySqlMysqlUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 mysql: Optional[pulumi.Input[bool]] = None,
                 mysqlx: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        if mysql is not None:
            pulumi.set(__self__, "mysql", mysql)
        if mysqlx is not None:
            pulumi.set(__self__, "mysqlx", mysqlx)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

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

    @mysql.setter
    def mysql(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "mysql", value)

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

    @mysqlx.setter
    def mysqlx(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "mysqlx", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class MySqlMysqlUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 mysql: Optional[pulumi.Input[bool]] = None,
                 mysqlx: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        if mysql is not None:
            pulumi.set(__self__, "mysql", mysql)
        if mysqlx is not None:
            pulumi.set(__self__, "mysqlx", mysqlx)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

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

    @mysql.setter
    def mysql(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "mysql", value)

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

    @mysqlx.setter
    def mysqlx(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "mysqlx", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class MySqlMysqlUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 mysql: Optional[pulumi.Input[bool]] = None,
                 mysqlx: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        if mysql is not None:
            pulumi.set(__self__, "mysql", mysql)
        if mysqlx is not None:
            pulumi.set(__self__, "mysqlx", mysqlx)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

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

    @mysql.setter
    def mysql(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "mysql", value)

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

    @mysqlx.setter
    def mysqlx(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "mysqlx", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class MySqlServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[str],
                 source_service_name: pulumi.Input[str]):
        pulumi.set(__self__, "integration_type", integration_type)
        pulumi.set(__self__, "source_service_name", source_service_name)

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

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "integration_type", value)

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

    @source_service_name.setter
    def source_service_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "source_service_name", value)


@pulumi.input_type
class MySqlTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class OpenSearchComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[str]] = None,
                 host: Optional[pulumi.Input[str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 route: Optional[pulumi.Input[str]] = None,
                 ssl: Optional[pulumi.Input[bool]] = None,
                 usage: Optional[pulumi.Input[str]] = None):
        if component is not None:
            pulumi.set(__self__, "component", component)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if kafka_authentication_method is not None:
            pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if route is not None:
            pulumi.set(__self__, "route", route)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if usage is not None:
            pulumi.set(__self__, "usage", usage)

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

    @component.setter
    def component(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "component", value)

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

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

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

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kafka_authentication_method", 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
    def route(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route", value)

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

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl", value)

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

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "usage", value)


@pulumi.input_type
class OpenSearchOpensearchArgs:
    def __init__(__self__, *,
                 opensearch_dashboards_uri: Optional[pulumi.Input[str]] = None):
        if opensearch_dashboards_uri is not None:
            pulumi.set(__self__, "opensearch_dashboards_uri", opensearch_dashboards_uri)

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

    @opensearch_dashboards_uri.setter
    def opensearch_dashboards_uri(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "opensearch_dashboards_uri", value)


@pulumi.input_type
class OpenSearchOpensearchUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[str]] = None,
                 custom_domain: Optional[pulumi.Input[str]] = None,
                 disable_replication_factor_adjustment: Optional[pulumi.Input[bool]] = None,
                 index_patterns: Optional[pulumi.Input[Sequence[pulumi.Input['OpenSearchOpensearchUserConfigIndexPatternArgs']]]] = None,
                 index_template: Optional[pulumi.Input['OpenSearchOpensearchUserConfigIndexTemplateArgs']] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['OpenSearchOpensearchUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 keep_index_refresh_interval: Optional[pulumi.Input[bool]] = None,
                 max_index_count: Optional[pulumi.Input[int]] = None,
                 openid: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpenidArgs']] = None,
                 opensearch: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchArgs']] = None,
                 opensearch_dashboards: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchDashboardsArgs']] = None,
                 opensearch_version: Optional[pulumi.Input[str]] = None,
                 private_access: Optional[pulumi.Input['OpenSearchOpensearchUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['OpenSearchOpensearchUserConfigPrivatelinkAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[str]] = None,
                 public_access: Optional[pulumi.Input['OpenSearchOpensearchUserConfigPublicAccessArgs']] = None,
                 recovery_basebackup_name: Optional[pulumi.Input[str]] = None,
                 saml: Optional[pulumi.Input['OpenSearchOpensearchUserConfigSamlArgs']] = None,
                 service_to_fork_from: Optional[pulumi.Input[str]] = None,
                 static_ips: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[str] custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name.
        :param pulumi.Input[bool] disable_replication_factor_adjustment: Disable automatic replication factor adjustment for multi-node services. By default, Aiven ensures all indexes are replicated at least to two nodes. Note: Due to potential data loss in case of losing a service node, this setting can no longer be activated.
        :param pulumi.Input[Sequence[pulumi.Input['OpenSearchOpensearchUserConfigIndexPatternArgs']]] index_patterns: Index patterns.
        :param pulumi.Input['OpenSearchOpensearchUserConfigIndexTemplateArgs'] index_template: Template settings for all new indexes.
        :param pulumi.Input[Sequence[pulumi.Input['OpenSearchOpensearchUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input[bool] keep_index_refresh_interval: Aiven automation resets index.refresh_interval to default value for every index to be sure that indices are always visible to search. If it doesn't fit your case, you can disable this by setting up this flag to true.
        :param pulumi.Input[int] max_index_count: Use index_patterns instead. The default value is `0`.
        :param pulumi.Input['OpenSearchOpensearchUserConfigOpenidArgs'] openid: OpenSearch OpenID Connect Configuration.
        :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchArgs'] opensearch: OpenSearch settings.
        :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchDashboardsArgs'] opensearch_dashboards: OpenSearch Dashboards settings.
        :param pulumi.Input[str] opensearch_version: OpenSearch major version.
        :param pulumi.Input['OpenSearchOpensearchUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks.
        :param pulumi.Input['OpenSearchOpensearchUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink.
        :param pulumi.Input[str] project_to_fork_from: Name of another project to fork a service from. This has effect only when a new service is being created.
        :param pulumi.Input['OpenSearchOpensearchUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet.
        :param pulumi.Input[str] recovery_basebackup_name: Name of the basebackup to restore in forked service.
        :param pulumi.Input['OpenSearchOpensearchUserConfigSamlArgs'] saml: OpenSearch SAML configuration.
        :param pulumi.Input[str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created.
        :param pulumi.Input[bool] static_ips: Use static public IP addresses.
        """
        if additional_backup_regions is not None:
            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
        if custom_domain is not None:
            pulumi.set(__self__, "custom_domain", custom_domain)
        if disable_replication_factor_adjustment is not None:
            warnings.warn("""Usage of this field is discouraged.""", DeprecationWarning)
            pulumi.log.warn("""disable_replication_factor_adjustment is deprecated: Usage of this field is discouraged.""")
        if disable_replication_factor_adjustment is not None:
            pulumi.set(__self__, "disable_replication_factor_adjustment", disable_replication_factor_adjustment)
        if index_patterns is not None:
            pulumi.set(__self__, "index_patterns", index_patterns)
        if index_template is not None:
            pulumi.set(__self__, "index_template", index_template)
        if ip_filter_objects is not None:
            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
        if ip_filter_strings is not None:
            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
        if ip_filters is not None:
            warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        if keep_index_refresh_interval is not None:
            pulumi.set(__self__, "keep_index_refresh_interval", keep_index_refresh_interval)
        if max_index_count is not None:
            warnings.warn("""Usage of this field is discouraged.""", DeprecationWarning)
            pulumi.log.warn("""max_index_count is deprecated: Usage of this field is discouraged.""")
        if max_index_count is not None:
            pulumi.set(__self__, "max_index_count", max_index_count)
        if openid is not None:
            pulumi.set(__self__, "openid", openid)
        if opensearch is not None:
            pulumi.set(__self__, "opensearch", opensearch)
        if opensearch_dashboards is not None:
            pulumi.set(__self__, "opensearch_dashboards", opensearch_dashboards)
        if opensearch_version is not None:
            pulumi.set(__self__, "opensearch_version", opensearch_version)
        if private_access is not None:
            pulumi.set(__self__, "private_access", private_access)
        if privatelink_access is not None:
            pulumi.set(__self__, "privatelink_access", privatelink_access)
        if project_to_fork_from is not None:
            pulumi.set(__self__, "project_to_fork_from", project_to_fork_from)
        if public_access is not None:
            pulumi.set(__self__, "public_access", public_access)
        if recovery_basebackup_name is not None:
            pulumi.set(__self__, "recovery_basebackup_name", recovery_basebackup_name)
        if saml is not None:
            pulumi.set(__self__, "saml", saml)
        if service_to_fork_from is not None:
            pulumi.set(__self__, "service_to_fork_from", service_to_fork_from)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)

    @property
    @pulumi.getter(name="additionalBackupRegions")
    def additional_backup_regions(self) -> Optional[pulumi.Input[str]]:
        """
        Additional Cloud Regions for Backup Replication.
        """
        return pulumi.get(self, "additional_backup_regions")

    @additional_backup_regions.setter
    def additional_backup_regions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @property
    @pulumi.getter(name="customDomain")
    def custom_domain(self) -> Optional[pulumi.Input[str]]:
        """
        Serve the web frontend using a custom CNAME pointing to the Aiven DNS name.
        """
        return pulumi.get(self, "custom_domain")

    @custom_domain.setter
    def custom_domain(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "custom_domain", value)

    @property
    @pulumi.getter(name="disableReplicationFactorAdjustment")
    def disable_replication_factor_adjustment(self) -> Optional[pulumi.Input[bool]]:
        """
        Disable automatic replication factor adjustment for multi-node services. By default, Aiven ensures all indexes are replicated at least to two nodes. Note: Due to potential data loss in case of losing a service node, this setting can no longer be activated.
        """
        warnings.warn("""Usage of this field is discouraged.""", DeprecationWarning)
        pulumi.log.warn("""disable_replication_factor_adjustment is deprecated: Usage of this field is discouraged.""")

        return pulumi.get(self, "disable_replication_factor_adjustment")

    @disable_replication_factor_adjustment.setter
    def disable_replication_factor_adjustment(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable_replication_factor_adjustment", value)

    @property
    @pulumi.getter(name="indexPatterns")
    def index_patterns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OpenSearchOpensearchUserConfigIndexPatternArgs']]]]:
        """
        Index patterns.
        """
        return pulumi.get(self, "index_patterns")

    @index_patterns.setter
    def index_patterns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OpenSearchOpensearchUserConfigIndexPatternArgs']]]]):
        pulumi.set(self, "index_patterns", value)

    @property
    @pulumi.getter(name="indexTemplate")
    def index_template(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigIndexTemplateArgs']]:
        """
        Template settings for all new indexes.
        """
        return pulumi.get(self, "index_template")

    @index_template.setter
    def index_template(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigIndexTemplateArgs']]):
        pulumi.set(self, "index_template", value)

    @property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['OpenSearchOpensearchUserConfigIpFilterObjectArgs']]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        return pulumi.get(self, "ip_filter_objects")

    @ip_filter_objects.setter
    def ip_filter_objects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['OpenSearchOpensearchUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        return pulumi.get(self, "ip_filter_strings")

    @ip_filter_strings.setter
    def ip_filter_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @property
    @pulumi.getter(name="ipFilters")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
        pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")

        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filters", value)

    @property
    @pulumi.getter(name="keepIndexRefreshInterval")
    def keep_index_refresh_interval(self) -> Optional[pulumi.Input[bool]]:
        """
        Aiven automation resets index.refresh_interval to default value for every index to be sure that indices are always visible to search. If it doesn't fit your case, you can disable this by setting up this flag to true.
        """
        return pulumi.get(self, "keep_index_refresh_interval")

    @keep_index_refresh_interval.setter
    def keep_index_refresh_interval(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "keep_index_refresh_interval", value)

    @property
    @pulumi.getter(name="maxIndexCount")
    def max_index_count(self) -> Optional[pulumi.Input[int]]:
        """
        Use index_patterns instead. The default value is `0`.
        """
        warnings.warn("""Usage of this field is discouraged.""", DeprecationWarning)
        pulumi.log.warn("""max_index_count is deprecated: Usage of this field is discouraged.""")

        return pulumi.get(self, "max_index_count")

    @max_index_count.setter
    def max_index_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_index_count", value)

    @property
    @pulumi.getter
    def openid(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpenidArgs']]:
        """
        OpenSearch OpenID Connect Configuration.
        """
        return pulumi.get(self, "openid")

    @openid.setter
    def openid(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpenidArgs']]):
        pulumi.set(self, "openid", value)

    @property
    @pulumi.getter
    def opensearch(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchArgs']]:
        """
        OpenSearch settings.
        """
        return pulumi.get(self, "opensearch")

    @opensearch.setter
    def opensearch(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchArgs']]):
        pulumi.set(self, "opensearch", value)

    @property
    @pulumi.getter(name="opensearchDashboards")
    def opensearch_dashboards(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchDashboardsArgs']]:
        """
        OpenSearch Dashboards settings.
        """
        return pulumi.get(self, "opensearch_dashboards")

    @opensearch_dashboards.setter
    def opensearch_dashboards(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchDashboardsArgs']]):
        pulumi.set(self, "opensearch_dashboards", value)

    @property
    @pulumi.getter(name="opensearchVersion")
    def opensearch_version(self) -> Optional[pulumi.Input[str]]:
        """
        OpenSearch major version.
        """
        return pulumi.get(self, "opensearch_version")

    @opensearch_version.setter
    def opensearch_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "opensearch_version", value)

    @property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigPrivateAccessArgs']]:
        """
        Allow access to selected service ports from private networks.
        """
        return pulumi.get(self, "private_access")

    @private_access.setter
    def private_access(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigPrivatelinkAccessArgs']]:
        """
        Allow access to selected service components through Privatelink.
        """
        return pulumi.get(self, "privatelink_access")

    @privatelink_access.setter
    def privatelink_access(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)

    @property
    @pulumi.getter(name="projectToForkFrom")
    def project_to_fork_from(self) -> Optional[pulumi.Input[str]]:
        """
        Name of another project to fork a service from. This has effect only when a new service is being created.
        """
        return pulumi.get(self, "project_to_fork_from")

    @project_to_fork_from.setter
    def project_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "project_to_fork_from", value)

    @property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigPublicAccessArgs']]:
        """
        Allow access to selected service ports from the public Internet.
        """
        return pulumi.get(self, "public_access")

    @public_access.setter
    def public_access(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

    @property
    @pulumi.getter(name="recoveryBasebackupName")
    def recovery_basebackup_name(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the basebackup to restore in forked service.
        """
        return pulumi.get(self, "recovery_basebackup_name")

    @recovery_basebackup_name.setter
    def recovery_basebackup_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "recovery_basebackup_name", value)

    @property
    @pulumi.getter
    def saml(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigSamlArgs']]:
        """
        OpenSearch SAML configuration.
        """
        return pulumi.get(self, "saml")

    @saml.setter
    def saml(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigSamlArgs']]):
        pulumi.set(self, "saml", value)

    @property
    @pulumi.getter(name="serviceToForkFrom")
    def service_to_fork_from(self) -> Optional[pulumi.Input[str]]:
        """
        Name of another service to fork from. This has effect only when a new service is being created.
        """
        return pulumi.get(self, "service_to_fork_from")

    @service_to_fork_from.setter
    def service_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_to_fork_from", value)

    @property
    @pulumi.getter(name="staticIps")
    def static_ips(self) -> Optional[pulumi.Input[bool]]:
        """
        Use static public IP addresses.
        """
        return pulumi.get(self, "static_ips")

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "static_ips", value)


@pulumi.input_type
class OpenSearchOpensearchUserConfigIndexPatternArgs:
    def __init__(__self__, *,
                 max_index_count: pulumi.Input[int],
                 pattern: pulumi.Input[str],
                 sorting_algorithm: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "max_index_count", max_index_count)
        pulumi.set(__self__, "pattern", pattern)
        if sorting_algorithm is not None:
            pulumi.set(__self__, "sorting_algorithm", sorting_algorithm)

    @property
    @pulumi.getter(name="maxIndexCount")
    def max_index_count(self) -> pulumi.Input[int]:
        return pulumi.get(self, "max_index_count")

    @max_index_count.setter
    def max_index_count(self, value: pulumi.Input[int]):
        pulumi.set(self, "max_index_count", value)

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

    @pattern.setter
    def pattern(self, value: pulumi.Input[str]):
        pulumi.set(self, "pattern", value)

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

    @sorting_algorithm.setter
    def sorting_algorithm(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sorting_algorithm", value)


@pulumi.input_type
class OpenSearchOpensearchUserConfigIndexTemplateArgs:
    def __init__(__self__, *,
                 mapping_nested_objects_limit: Optional[pulumi.Input[int]] = None,
                 number_of_replicas: Optional[pulumi.Input[int]] = None,
                 number_of_shards: Optional[pulumi.Input[int]] = None):
        if mapping_nested_objects_limit is not None:
            pulumi.set(__self__, "mapping_nested_objects_limit", mapping_nested_objects_limit)
        if number_of_replicas is not None:
            pulumi.set(__self__, "number_of_replicas", number_of_replicas)
        if number_of_shards is not None:
            pulumi.set(__self__, "number_of_shards", number_of_shards)

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

    @mapping_nested_objects_limit.setter
    def mapping_nested_objects_limit(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "mapping_nested_objects_limit", value)

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

    @number_of_replicas.setter
    def number_of_replicas(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "number_of_replicas", value)

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

    @number_of_shards.setter
    def number_of_shards(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "number_of_shards", value)


@pulumi.input_type
class OpenSearchOpensearchUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

    @network.setter
    def network(self, value: pulumi.Input[str]):
        pulumi.set(self, "network", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class OpenSearchOpensearchUserConfigOpenidArgs:
    def __init__(__self__, *,
                 client_id: pulumi.Input[str],
                 client_secret: pulumi.Input[str],
                 connect_url: pulumi.Input[str],
                 enabled: Optional[pulumi.Input[bool]] = None,
                 header: Optional[pulumi.Input[str]] = None,
                 jwt_header: Optional[pulumi.Input[str]] = None,
                 jwt_url_parameter: Optional[pulumi.Input[str]] = None,
                 refresh_rate_limit_count: Optional[pulumi.Input[int]] = None,
                 refresh_rate_limit_time_window_ms: Optional[pulumi.Input[int]] = None,
                 roles_key: Optional[pulumi.Input[str]] = None,
                 scope: Optional[pulumi.Input[str]] = None,
                 subject_key: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        pulumi.set(__self__, "connect_url", connect_url)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if header is not None:
            pulumi.set(__self__, "header", header)
        if jwt_header is not None:
            pulumi.set(__self__, "jwt_header", jwt_header)
        if jwt_url_parameter is not None:
            pulumi.set(__self__, "jwt_url_parameter", jwt_url_parameter)
        if refresh_rate_limit_count is not None:
            pulumi.set(__self__, "refresh_rate_limit_count", refresh_rate_limit_count)
        if refresh_rate_limit_time_window_ms is not None:
            pulumi.set(__self__, "refresh_rate_limit_time_window_ms", refresh_rate_limit_time_window_ms)
        if roles_key is not None:
            pulumi.set(__self__, "roles_key", roles_key)
        if scope is not None:
            pulumi.set(__self__, "scope", scope)
        if subject_key is not None:
            pulumi.set(__self__, "subject_key", subject_key)

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

    @client_id.setter
    def client_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_id", value)

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

    @client_secret.setter
    def client_secret(self, value: pulumi.Input[str]):
        pulumi.set(self, "client_secret", value)

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

    @connect_url.setter
    def connect_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "connect_url", value)

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

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

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

    @header.setter
    def header(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "header", value)

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

    @jwt_header.setter
    def jwt_header(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "jwt_header", value)

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

    @jwt_url_parameter.setter
    def jwt_url_parameter(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "jwt_url_parameter", value)

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

    @refresh_rate_limit_count.setter
    def refresh_rate_limit_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "refresh_rate_limit_count", value)

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

    @refresh_rate_limit_time_window_ms.setter
    def refresh_rate_limit_time_window_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "refresh_rate_limit_time_window_ms", value)

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

    @roles_key.setter
    def roles_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "roles_key", value)

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

    @scope.setter
    def scope(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "scope", value)

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

    @subject_key.setter
    def subject_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subject_key", value)


@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchArgs:
    def __init__(__self__, *,
                 action_auto_create_index_enabled: Optional[pulumi.Input[bool]] = None,
                 action_destructive_requires_name: Optional[pulumi.Input[bool]] = None,
                 cluster_max_shards_per_node: Optional[pulumi.Input[int]] = None,
                 cluster_routing_allocation_node_concurrent_recoveries: Optional[pulumi.Input[int]] = None,
                 email_sender_name: Optional[pulumi.Input[str]] = None,
                 email_sender_password: Optional[pulumi.Input[str]] = None,
                 email_sender_username: Optional[pulumi.Input[str]] = None,
                 http_max_content_length: Optional[pulumi.Input[int]] = None,
                 http_max_header_size: Optional[pulumi.Input[int]] = None,
                 http_max_initial_line_length: Optional[pulumi.Input[int]] = None,
                 indices_fielddata_cache_size: Optional[pulumi.Input[int]] = None,
                 indices_memory_index_buffer_size: Optional[pulumi.Input[int]] = None,
                 indices_queries_cache_size: Optional[pulumi.Input[int]] = None,
                 indices_query_bool_max_clause_count: Optional[pulumi.Input[int]] = None,
                 indices_recovery_max_bytes_per_sec: Optional[pulumi.Input[int]] = None,
                 indices_recovery_max_concurrent_file_chunks: Optional[pulumi.Input[int]] = None,
                 override_main_response_version: Optional[pulumi.Input[bool]] = None,
                 reindex_remote_whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 script_max_compilations_rate: Optional[pulumi.Input[str]] = None,
                 search_max_buckets: Optional[pulumi.Input[int]] = None,
                 thread_pool_analyze_queue_size: Optional[pulumi.Input[int]] = None,
                 thread_pool_analyze_size: Optional[pulumi.Input[int]] = None,
                 thread_pool_force_merge_size: Optional[pulumi.Input[int]] = None,
                 thread_pool_get_queue_size: Optional[pulumi.Input[int]] = None,
                 thread_pool_get_size: Optional[pulumi.Input[int]] = None,
                 thread_pool_search_queue_size: Optional[pulumi.Input[int]] = None,
                 thread_pool_search_size: Optional[pulumi.Input[int]] = None,
                 thread_pool_search_throttled_queue_size: Optional[pulumi.Input[int]] = None,
                 thread_pool_search_throttled_size: Optional[pulumi.Input[int]] = None,
                 thread_pool_write_queue_size: Optional[pulumi.Input[int]] = None,
                 thread_pool_write_size: Optional[pulumi.Input[int]] = None):
        if action_auto_create_index_enabled is not None:
            pulumi.set(__self__, "action_auto_create_index_enabled", action_auto_create_index_enabled)
        if action_destructive_requires_name is not None:
            pulumi.set(__self__, "action_destructive_requires_name", action_destructive_requires_name)
        if cluster_max_shards_per_node is not None:
            pulumi.set(__self__, "cluster_max_shards_per_node", cluster_max_shards_per_node)
        if cluster_routing_allocation_node_concurrent_recoveries is not None:
            pulumi.set(__self__, "cluster_routing_allocation_node_concurrent_recoveries", cluster_routing_allocation_node_concurrent_recoveries)
        if email_sender_name is not None:
            pulumi.set(__self__, "email_sender_name", email_sender_name)
        if email_sender_password is not None:
            pulumi.set(__self__, "email_sender_password", email_sender_password)
        if email_sender_username is not None:
            pulumi.set(__self__, "email_sender_username", email_sender_username)
        if http_max_content_length is not None:
            pulumi.set(__self__, "http_max_content_length", http_max_content_length)
        if http_max_header_size is not None:
            pulumi.set(__self__, "http_max_header_size", http_max_header_size)
        if http_max_initial_line_length is not None:
            pulumi.set(__self__, "http_max_initial_line_length", http_max_initial_line_length)
        if indices_fielddata_cache_size is not None:
            pulumi.set(__self__, "indices_fielddata_cache_size", indices_fielddata_cache_size)
        if indices_memory_index_buffer_size is not None:
            pulumi.set(__self__, "indices_memory_index_buffer_size", indices_memory_index_buffer_size)
        if indices_queries_cache_size is not None:
            pulumi.set(__self__, "indices_queries_cache_size", indices_queries_cache_size)
        if indices_query_bool_max_clause_count is not None:
            pulumi.set(__self__, "indices_query_bool_max_clause_count", indices_query_bool_max_clause_count)
        if indices_recovery_max_bytes_per_sec is not None:
            pulumi.set(__self__, "indices_recovery_max_bytes_per_sec", indices_recovery_max_bytes_per_sec)
        if indices_recovery_max_concurrent_file_chunks is not None:
            pulumi.set(__self__, "indices_recovery_max_concurrent_file_chunks", indices_recovery_max_concurrent_file_chunks)
        if override_main_response_version is not None:
            pulumi.set(__self__, "override_main_response_version", override_main_response_version)
        if reindex_remote_whitelists is not None:
            pulumi.set(__self__, "reindex_remote_whitelists", reindex_remote_whitelists)
        if script_max_compilations_rate is not None:
            pulumi.set(__self__, "script_max_compilations_rate", script_max_compilations_rate)
        if search_max_buckets is not None:
            pulumi.set(__self__, "search_max_buckets", search_max_buckets)
        if thread_pool_analyze_queue_size is not None:
            pulumi.set(__self__, "thread_pool_analyze_queue_size", thread_pool_analyze_queue_size)
        if thread_pool_analyze_size is not None:
            pulumi.set(__self__, "thread_pool_analyze_size", thread_pool_analyze_size)
        if thread_pool_force_merge_size is not None:
            pulumi.set(__self__, "thread_pool_force_merge_size", thread_pool_force_merge_size)
        if thread_pool_get_queue_size is not None:
            pulumi.set(__self__, "thread_pool_get_queue_size", thread_pool_get_queue_size)
        if thread_pool_get_size is not None:
            pulumi.set(__self__, "thread_pool_get_size", thread_pool_get_size)
        if thread_pool_search_queue_size is not None:
            pulumi.set(__self__, "thread_pool_search_queue_size", thread_pool_search_queue_size)
        if thread_pool_search_size is not None:
            pulumi.set(__self__, "thread_pool_search_size", thread_pool_search_size)
        if thread_pool_search_throttled_queue_size is not None:
            pulumi.set(__self__, "thread_pool_search_throttled_queue_size", thread_pool_search_throttled_queue_size)
        if thread_pool_search_throttled_size is not None:
            pulumi.set(__self__, "thread_pool_search_throttled_size", thread_pool_search_throttled_size)
        if thread_pool_write_queue_size is not None:
            pulumi.set(__self__, "thread_pool_write_queue_size", thread_pool_write_queue_size)
        if thread_pool_write_size is not None:
            pulumi.set(__self__, "thread_pool_write_size", thread_pool_write_size)

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

    @action_auto_create_index_enabled.setter
    def action_auto_create_index_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "action_auto_create_index_enabled", value)

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

    @action_destructive_requires_name.setter
    def action_destructive_requires_name(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "action_destructive_requires_name", value)

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

    @cluster_max_shards_per_node.setter
    def cluster_max_shards_per_node(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "cluster_max_shards_per_node", value)

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

    @cluster_routing_allocation_node_concurrent_recoveries.setter
    def cluster_routing_allocation_node_concurrent_recoveries(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "cluster_routing_allocation_node_concurrent_recoveries", value)

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

    @email_sender_name.setter
    def email_sender_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "email_sender_name", value)

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

    @email_sender_password.setter
    def email_sender_password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "email_sender_password", value)

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

    @email_sender_username.setter
    def email_sender_username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "email_sender_username", value)

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

    @http_max_content_length.setter
    def http_max_content_length(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "http_max_content_length", value)

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

    @http_max_header_size.setter
    def http_max_header_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "http_max_header_size", value)

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

    @http_max_initial_line_length.setter
    def http_max_initial_line_length(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "http_max_initial_line_length", value)

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

    @indices_fielddata_cache_size.setter
    def indices_fielddata_cache_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "indices_fielddata_cache_size", value)

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

    @indices_memory_index_buffer_size.setter
    def indices_memory_index_buffer_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "indices_memory_index_buffer_size", value)

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

    @indices_queries_cache_size.setter
    def indices_queries_cache_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "indices_queries_cache_size", value)

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

    @indices_query_bool_max_clause_count.setter
    def indices_query_bool_max_clause_count(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "indices_query_bool_max_clause_count", value)

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

    @indices_recovery_max_bytes_per_sec.setter
    def indices_recovery_max_bytes_per_sec(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "indices_recovery_max_bytes_per_sec", value)

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

    @indices_recovery_max_concurrent_file_chunks.setter
    def indices_recovery_max_concurrent_file_chunks(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "indices_recovery_max_concurrent_file_chunks", value)

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

    @override_main_response_version.setter
    def override_main_response_version(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "override_main_response_version", value)

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

    @reindex_remote_whitelists.setter
    def reindex_remote_whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "reindex_remote_whitelists", value)

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

    @script_max_compilations_rate.setter
    def script_max_compilations_rate(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "script_max_compilations_rate", value)

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

    @search_max_buckets.setter
    def search_max_buckets(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "search_max_buckets", value)

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

    @thread_pool_analyze_queue_size.setter
    def thread_pool_analyze_queue_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "thread_pool_analyze_queue_size", value)

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

    @thread_pool_analyze_size.setter
    def thread_pool_analyze_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "thread_pool_analyze_size", value)

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

    @thread_pool_force_merge_size.setter
    def thread_pool_force_merge_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "thread_pool_force_merge_size", value)

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

    @thread_pool_get_queue_size.setter
    def thread_pool_get_queue_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "thread_pool_get_queue_size", value)

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

    @thread_pool_get_size.setter
    def thread_pool_get_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "thread_pool_get_size", value)

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

    @thread_pool_search_queue_size.setter
    def thread_pool_search_queue_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "thread_pool_search_queue_size", value)

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

    @thread_pool_search_size.setter
    def thread_pool_search_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "thread_pool_search_size", value)

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

    @thread_pool_search_throttled_queue_size.setter
    def thread_pool_search_throttled_queue_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "thread_pool_search_throttled_queue_size", value)

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

    @thread_pool_search_throttled_size.setter
    def thread_pool_search_throttled_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "thread_pool_search_throttled_size", value)

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

    @thread_pool_write_queue_size.setter
    def thread_pool_write_queue_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "thread_pool_write_queue_size", value)

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

    @thread_pool_write_size.setter
    def thread_pool_write_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "thread_pool_write_size", value)


@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchDashboardsArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[bool]] = None,
                 max_old_space_size: Optional[pulumi.Input[int]] = None,
                 opensearch_request_timeout: Optional[pulumi.Input[int]] = None):
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if max_old_space_size is not None:
            pulumi.set(__self__, "max_old_space_size", max_old_space_size)
        if opensearch_request_timeout is not None:
            pulumi.set(__self__, "opensearch_request_timeout", opensearch_request_timeout)

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

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enabled", value)

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

    @max_old_space_size.setter
    def max_old_space_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_old_space_size", value)

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

    @opensearch_request_timeout.setter
    def opensearch_request_timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "opensearch_request_timeout", value)


@pulumi.input_type
class OpenSearchOpensearchUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 opensearch: Optional[pulumi.Input[bool]] = None,
                 opensearch_dashboards: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] opensearch: OpenSearch server provided values
        """
        if opensearch is not None:
            pulumi.set(__self__, "opensearch", opensearch)
        if opensearch_dashboards is not None:
            pulumi.set(__self__, "opensearch_dashboards", opensearch_dashboards)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @property
    @pulumi.getter
    def opensearch(self) -> Optional[pulumi.Input[bool]]:
        """
        OpenSearch server provided values
        """
        return pulumi.get(self, "opensearch")

    @opensearch.setter
    def opensearch(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "opensearch", value)

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

    @opensearch_dashboards.setter
    def opensearch_dashboards(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "opensearch_dashboards", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class OpenSearchOpensearchUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 opensearch: Optional[pulumi.Input[bool]] = None,
                 opensearch_dashboards: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] opensearch: OpenSearch server provided values
        """
        if opensearch is not None:
            pulumi.set(__self__, "opensearch", opensearch)
        if opensearch_dashboards is not None:
            pulumi.set(__self__, "opensearch_dashboards", opensearch_dashboards)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @property
    @pulumi.getter
    def opensearch(self) -> Optional[pulumi.Input[bool]]:
        """
        OpenSearch server provided values
        """
        return pulumi.get(self, "opensearch")

    @opensearch.setter
    def opensearch(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "opensearch", value)

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

    @opensearch_dashboards.setter
    def opensearch_dashboards(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "opensearch_dashboards", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class OpenSearchOpensearchUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 opensearch: Optional[pulumi.Input[bool]] = None,
                 opensearch_dashboards: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] opensearch: OpenSearch server provided values
        """
        if opensearch is not None:
            pulumi.set(__self__, "opensearch", opensearch)
        if opensearch_dashboards is not None:
            pulumi.set(__self__, "opensearch_dashboards", opensearch_dashboards)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @property
    @pulumi.getter
    def opensearch(self) -> Optional[pulumi.Input[bool]]:
        """
        OpenSearch server provided values
        """
        return pulumi.get(self, "opensearch")

    @opensearch.setter
    def opensearch(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "opensearch", value)

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

    @opensearch_dashboards.setter
    def opensearch_dashboards(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "opensearch_dashboards", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class OpenSearchOpensearchUserConfigSamlArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[bool],
                 idp_entity_id: pulumi.Input[str],
                 idp_metadata_url: pulumi.Input[str],
                 sp_entity_id: pulumi.Input[str],
                 idp_pemtrustedcas_content: Optional[pulumi.Input[str]] = None,
                 roles_key: Optional[pulumi.Input[str]] = None,
                 subject_key: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "idp_entity_id", idp_entity_id)
        pulumi.set(__self__, "idp_metadata_url", idp_metadata_url)
        pulumi.set(__self__, "sp_entity_id", sp_entity_id)
        if idp_pemtrustedcas_content is not None:
            pulumi.set(__self__, "idp_pemtrustedcas_content", idp_pemtrustedcas_content)
        if roles_key is not None:
            pulumi.set(__self__, "roles_key", roles_key)
        if subject_key is not None:
            pulumi.set(__self__, "subject_key", subject_key)

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

    @enabled.setter
    def enabled(self, value: pulumi.Input[bool]):
        pulumi.set(self, "enabled", value)

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

    @idp_entity_id.setter
    def idp_entity_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "idp_entity_id", value)

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

    @idp_metadata_url.setter
    def idp_metadata_url(self, value: pulumi.Input[str]):
        pulumi.set(self, "idp_metadata_url", value)

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

    @sp_entity_id.setter
    def sp_entity_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "sp_entity_id", value)

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

    @idp_pemtrustedcas_content.setter
    def idp_pemtrustedcas_content(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "idp_pemtrustedcas_content", value)

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

    @roles_key.setter
    def roles_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "roles_key", value)

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

    @subject_key.setter
    def subject_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "subject_key", value)


@pulumi.input_type
class OpenSearchServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[str],
                 source_service_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] integration_type: Type of the service integration. The only supported value at the moment is `read_replica`
        :param pulumi.Input[str] source_service_name: Name of the source service
        """
        pulumi.set(__self__, "integration_type", integration_type)
        pulumi.set(__self__, "source_service_name", source_service_name)

    @property
    @pulumi.getter(name="integrationType")
    def integration_type(self) -> pulumi.Input[str]:
        """
        Type of the service integration. The only supported value at the moment is `read_replica`
        """
        return pulumi.get(self, "integration_type")

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "integration_type", value)

    @property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[str]:
        """
        Name of the source service
        """
        return pulumi.get(self, "source_service_name")

    @source_service_name.setter
    def source_service_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "source_service_name", value)


@pulumi.input_type
class OpenSearchTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: Service tag key
        :param pulumi.Input[str] value: Service tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        Service tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class OrganizationTimeoutsArgs:
    def __init__(__self__, *,
                 create: Optional[pulumi.Input[str]] = None,
                 delete: Optional[pulumi.Input[str]] = None,
                 read: Optional[pulumi.Input[str]] = None,
                 update: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] create: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
        :param pulumi.Input[str] delete: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
        :param pulumi.Input[str] read: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Read operations occur during any refresh or planning operation when refresh is enabled.
        :param pulumi.Input[str] update: A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
        """
        if create is not None:
            pulumi.set(__self__, "create", create)
        if delete is not None:
            pulumi.set(__self__, "delete", delete)
        if read is not None:
            pulumi.set(__self__, "read", read)
        if update is not None:
            pulumi.set(__self__, "update", update)

    @property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[str]]:
        """
        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
        """
        return pulumi.get(self, "create")

    @create.setter
    def create(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "create", value)

    @property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[str]]:
        """
        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Setting a timeout for a Delete operation is only applicable if changes are saved into state before the destroy operation occurs.
        """
        return pulumi.get(self, "delete")

    @delete.setter
    def delete(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "delete", value)

    @property
    @pulumi.getter
    def read(self) -> Optional[pulumi.Input[str]]:
        """
        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours). Read operations occur during any refresh or planning operation when refresh is enabled.
        """
        return pulumi.get(self, "read")

    @read.setter
    def read(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "read", value)

    @property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[str]]:
        """
        A string that can be [parsed as a duration](https://pkg.go.dev/time#ParseDuration) consisting of numbers and unit suffixes, such as "30s" or "2h45m". Valid time units are "s" (seconds), "m" (minutes), "h" (hours).
        """
        return pulumi.get(self, "update")

    @update.setter
    def update(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "update", value)


@pulumi.input_type
class PgComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[str]] = None,
                 host: Optional[pulumi.Input[str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 route: Optional[pulumi.Input[str]] = None,
                 ssl: Optional[pulumi.Input[bool]] = None,
                 usage: Optional[pulumi.Input[str]] = None):
        if component is not None:
            pulumi.set(__self__, "component", component)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if kafka_authentication_method is not None:
            pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if route is not None:
            pulumi.set(__self__, "route", route)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if usage is not None:
            pulumi.set(__self__, "usage", usage)

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

    @component.setter
    def component(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "component", value)

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

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

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

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kafka_authentication_method", 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
    def route(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route", value)

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

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl", value)

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

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "usage", value)


@pulumi.input_type
class PgPgArgs:
    def __init__(__self__, *,
                 dbname: Optional[pulumi.Input[str]] = None,
                 host: Optional[pulumi.Input[str]] = None,
                 max_connections: Optional[pulumi.Input[int]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 replica_uri: Optional[pulumi.Input[str]] = None,
                 sslmode: Optional[pulumi.Input[str]] = None,
                 uri: Optional[pulumi.Input[str]] = None,
                 user: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] dbname: Primary PostgreSQL database name
        :param pulumi.Input[str] host: PostgreSQL master node host IP or name
        :param pulumi.Input[int] max_connections: Connection limit
        :param pulumi.Input[str] password: PostgreSQL admin user password
        :param pulumi.Input[int] port: PostgreSQL port
        :param pulumi.Input[str] replica_uri: PostgreSQL replica URI for services with a replica
        :param pulumi.Input[str] sslmode: PostgreSQL sslmode setting (currently always "require")
        :param pulumi.Input[str] uri: PostgreSQL master connection URI
        :param pulumi.Input[str] user: PostgreSQL admin user name
        """
        if dbname is not None:
            pulumi.set(__self__, "dbname", dbname)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if max_connections is not None:
            pulumi.set(__self__, "max_connections", max_connections)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if replica_uri is not None:
            pulumi.set(__self__, "replica_uri", replica_uri)
        if sslmode is not None:
            pulumi.set(__self__, "sslmode", sslmode)
        if uri is not None:
            pulumi.set(__self__, "uri", uri)
        if user is not None:
            pulumi.set(__self__, "user", user)

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

    @dbname.setter
    def dbname(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dbname", value)

    @property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[str]]:
        """
        PostgreSQL master node host IP or name
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

    @property
    @pulumi.getter(name="maxConnections")
    def max_connections(self) -> Optional[pulumi.Input[int]]:
        """
        Connection limit
        """
        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
    def password(self) -> Optional[pulumi.Input[str]]:
        """
        PostgreSQL admin 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 port(self) -> Optional[pulumi.Input[int]]:
        """
        PostgreSQL port
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter(name="replicaUri")
    def replica_uri(self) -> Optional[pulumi.Input[str]]:
        """
        PostgreSQL replica URI for services with a replica
        """
        return pulumi.get(self, "replica_uri")

    @replica_uri.setter
    def replica_uri(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "replica_uri", value)

    @property
    @pulumi.getter
    def sslmode(self) -> Optional[pulumi.Input[str]]:
        """
        PostgreSQL sslmode setting (currently always "require")
        """
        return pulumi.get(self, "sslmode")

    @sslmode.setter
    def sslmode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sslmode", value)

    @property
    @pulumi.getter
    def uri(self) -> Optional[pulumi.Input[str]]:
        """
        PostgreSQL master connection URI
        """
        return pulumi.get(self, "uri")

    @uri.setter
    def uri(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "uri", value)

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

    @user.setter
    def user(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "user", value)


@pulumi.input_type
class PgPgUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[str]] = None,
                 admin_password: Optional[pulumi.Input[str]] = None,
                 admin_username: Optional[pulumi.Input[str]] = None,
                 backup_hour: Optional[pulumi.Input[int]] = None,
                 backup_minute: Optional[pulumi.Input[int]] = None,
                 enable_ipv6: Optional[pulumi.Input[bool]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['PgPgUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 migration: Optional[pulumi.Input['PgPgUserConfigMigrationArgs']] = None,
                 pg: Optional[pulumi.Input['PgPgUserConfigPgArgs']] = None,
                 pg_read_replica: Optional[pulumi.Input[bool]] = None,
                 pg_service_to_fork_from: Optional[pulumi.Input[str]] = None,
                 pg_stat_monitor_enable: Optional[pulumi.Input[bool]] = None,
                 pg_version: Optional[pulumi.Input[str]] = None,
                 pgbouncer: Optional[pulumi.Input['PgPgUserConfigPgbouncerArgs']] = None,
                 pglookout: Optional[pulumi.Input['PgPgUserConfigPglookoutArgs']] = None,
                 private_access: Optional[pulumi.Input['PgPgUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['PgPgUserConfigPrivatelinkAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[str]] = None,
                 public_access: Optional[pulumi.Input['PgPgUserConfigPublicAccessArgs']] = None,
                 recovery_target_time: Optional[pulumi.Input[str]] = None,
                 service_to_fork_from: Optional[pulumi.Input[str]] = None,
                 shared_buffers_percentage: Optional[pulumi.Input[float]] = None,
                 static_ips: Optional[pulumi.Input[bool]] = None,
                 synchronous_replication: Optional[pulumi.Input[str]] = None,
                 timescaledb: Optional[pulumi.Input['PgPgUserConfigTimescaledbArgs']] = None,
                 variant: Optional[pulumi.Input[str]] = None,
                 work_mem: Optional[pulumi.Input[int]] = None):
        """
        :param pulumi.Input[str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[str] admin_password: Custom password for admin user. Defaults to random string. This must be set only when a new service is being created.
        :param pulumi.Input[str] admin_username: Custom username for admin user. This must be set only when a new service is being created.
        :param pulumi.Input[int] backup_hour: The hour of day (in UTC) when backup for the service is started. New backup is only started if previous backup has already completed.
        :param pulumi.Input[int] backup_minute: The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed.
        :param pulumi.Input[bool] enable_ipv6: Register AAAA DNS records for the service, and allow IPv6 packets to service ports.
        :param pulumi.Input[Sequence[pulumi.Input['PgPgUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        :param pulumi.Input['PgPgUserConfigMigrationArgs'] migration: Migrate data from existing server.
        :param pulumi.Input['PgPgUserConfigPgArgs'] pg: postgresql.conf configuration values.
        :param pulumi.Input[bool] pg_read_replica: Use read_replica service integration instead.
        :param pulumi.Input[str] pg_service_to_fork_from: Name of the PG Service from which to fork (deprecated, use service*to*fork_from). This has effect only when a new service is being created.
        :param pulumi.Input[bool] pg_stat_monitor_enable: Enable the pg*stat*monitor extension. Enabling this extension will cause the cluster to be restarted.When this extension is enabled, pg*stat*statements results for utility commands are unreliable. The default value is `false`.
        :param pulumi.Input[str] pg_version: PostgreSQL major version.
        :param pulumi.Input['PgPgUserConfigPgbouncerArgs'] pgbouncer: PGBouncer connection pooling settings.
        :param pulumi.Input['PgPgUserConfigPglookoutArgs'] pglookout: PGLookout settings.
        :param pulumi.Input['PgPgUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks.
        :param pulumi.Input['PgPgUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink.
        :param pulumi.Input[str] project_to_fork_from: Name of another project to fork a service from. This has effect only when a new service is being created.
        :param pulumi.Input['PgPgUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet.
        :param pulumi.Input[str] recovery_target_time: Recovery target time when forking a service. This has effect only when a new service is being created.
        :param pulumi.Input[str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created.
        :param pulumi.Input[float] shared_buffers_percentage: Percentage of total RAM that the database server uses for shared memory buffers. Valid range is 20-60 (float), which corresponds to 20% - 60%. This setting adjusts the shared_buffers configuration value.
        :param pulumi.Input[bool] static_ips: Use static public IP addresses.
        :param pulumi.Input[str] synchronous_replication: Synchronous replication type. Note that the service plan also needs to support synchronous replication.
        :param pulumi.Input['PgPgUserConfigTimescaledbArgs'] timescaledb: TimescaleDB extension configuration values.
        :param pulumi.Input[str] variant: Variant of the PostgreSQL service, may affect the features that are exposed by default.
        :param pulumi.Input[int] work_mem: Sets the maximum amount of memory to be used by a query operation (such as a sort or hash table) before writing to temporary disk files, in MB. Default is 1MB + 0.075% of total RAM (up to 32MB).
        """
        if additional_backup_regions is not None:
            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
        if admin_password is not None:
            pulumi.set(__self__, "admin_password", admin_password)
        if admin_username is not None:
            pulumi.set(__self__, "admin_username", admin_username)
        if backup_hour is not None:
            pulumi.set(__self__, "backup_hour", backup_hour)
        if backup_minute is not None:
            pulumi.set(__self__, "backup_minute", backup_minute)
        if enable_ipv6 is not None:
            pulumi.set(__self__, "enable_ipv6", enable_ipv6)
        if ip_filter_objects is not None:
            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
        if ip_filter_strings is not None:
            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
        if ip_filters is not None:
            warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        if migration is not None:
            pulumi.set(__self__, "migration", migration)
        if pg is not None:
            pulumi.set(__self__, "pg", pg)
        if pg_read_replica is not None:
            warnings.warn("""Usage of this field is discouraged.""", DeprecationWarning)
            pulumi.log.warn("""pg_read_replica is deprecated: Usage of this field is discouraged.""")
        if pg_read_replica is not None:
            pulumi.set(__self__, "pg_read_replica", pg_read_replica)
        if pg_service_to_fork_from is not None:
            warnings.warn("""Usage of this field is discouraged.""", DeprecationWarning)
            pulumi.log.warn("""pg_service_to_fork_from is deprecated: Usage of this field is discouraged.""")
        if pg_service_to_fork_from is not None:
            pulumi.set(__self__, "pg_service_to_fork_from", pg_service_to_fork_from)
        if pg_stat_monitor_enable is not None:
            pulumi.set(__self__, "pg_stat_monitor_enable", pg_stat_monitor_enable)
        if pg_version is not None:
            pulumi.set(__self__, "pg_version", pg_version)
        if pgbouncer is not None:
            pulumi.set(__self__, "pgbouncer", pgbouncer)
        if pglookout is not None:
            pulumi.set(__self__, "pglookout", pglookout)
        if private_access is not None:
            pulumi.set(__self__, "private_access", private_access)
        if privatelink_access is not None:
            pulumi.set(__self__, "privatelink_access", privatelink_access)
        if project_to_fork_from is not None:
            pulumi.set(__self__, "project_to_fork_from", project_to_fork_from)
        if public_access is not None:
            pulumi.set(__self__, "public_access", public_access)
        if recovery_target_time is not None:
            pulumi.set(__self__, "recovery_target_time", recovery_target_time)
        if service_to_fork_from is not None:
            pulumi.set(__self__, "service_to_fork_from", service_to_fork_from)
        if shared_buffers_percentage is not None:
            pulumi.set(__self__, "shared_buffers_percentage", shared_buffers_percentage)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)
        if synchronous_replication is not None:
            pulumi.set(__self__, "synchronous_replication", synchronous_replication)
        if timescaledb is not None:
            pulumi.set(__self__, "timescaledb", timescaledb)
        if variant is not None:
            pulumi.set(__self__, "variant", variant)
        if work_mem is not None:
            pulumi.set(__self__, "work_mem", work_mem)

    @property
    @pulumi.getter(name="additionalBackupRegions")
    def additional_backup_regions(self) -> Optional[pulumi.Input[str]]:
        """
        Additional Cloud Regions for Backup Replication.
        """
        return pulumi.get(self, "additional_backup_regions")

    @additional_backup_regions.setter
    def additional_backup_regions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @property
    @pulumi.getter(name="adminPassword")
    def admin_password(self) -> Optional[pulumi.Input[str]]:
        """
        Custom password for admin user. Defaults to random string. This must be set only when a new service is being created.
        """
        return pulumi.get(self, "admin_password")

    @admin_password.setter
    def admin_password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "admin_password", value)

    @property
    @pulumi.getter(name="adminUsername")
    def admin_username(self) -> Optional[pulumi.Input[str]]:
        """
        Custom username for admin user. This must be set only when a new service is being created.
        """
        return pulumi.get(self, "admin_username")

    @admin_username.setter
    def admin_username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "admin_username", value)

    @property
    @pulumi.getter(name="backupHour")
    def backup_hour(self) -> Optional[pulumi.Input[int]]:
        """
        The hour of day (in UTC) when backup for the service is started. New backup is only started if previous backup has already completed.
        """
        return pulumi.get(self, "backup_hour")

    @backup_hour.setter
    def backup_hour(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "backup_hour", value)

    @property
    @pulumi.getter(name="backupMinute")
    def backup_minute(self) -> Optional[pulumi.Input[int]]:
        """
        The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed.
        """
        return pulumi.get(self, "backup_minute")

    @backup_minute.setter
    def backup_minute(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "backup_minute", value)

    @property
    @pulumi.getter(name="enableIpv6")
    def enable_ipv6(self) -> Optional[pulumi.Input[bool]]:
        """
        Register AAAA DNS records for the service, and allow IPv6 packets to service ports.
        """
        return pulumi.get(self, "enable_ipv6")

    @enable_ipv6.setter
    def enable_ipv6(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "enable_ipv6", value)

    @property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PgPgUserConfigIpFilterObjectArgs']]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        return pulumi.get(self, "ip_filter_objects")

    @ip_filter_objects.setter
    def ip_filter_objects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PgPgUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        return pulumi.get(self, "ip_filter_strings")

    @ip_filter_strings.setter
    def ip_filter_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @property
    @pulumi.getter(name="ipFilters")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. '10.20.0.0/16'.
        """
        warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
        pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")

        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filters", value)

    @property
    @pulumi.getter
    def migration(self) -> Optional[pulumi.Input['PgPgUserConfigMigrationArgs']]:
        """
        Migrate data from existing server.
        """
        return pulumi.get(self, "migration")

    @migration.setter
    def migration(self, value: Optional[pulumi.Input['PgPgUserConfigMigrationArgs']]):
        pulumi.set(self, "migration", value)

    @property
    @pulumi.getter
    def pg(self) -> Optional[pulumi.Input['PgPgUserConfigPgArgs']]:
        """
        postgresql.conf configuration values.
        """
        return pulumi.get(self, "pg")

    @pg.setter
    def pg(self, value: Optional[pulumi.Input['PgPgUserConfigPgArgs']]):
        pulumi.set(self, "pg", value)

    @property
    @pulumi.getter(name="pgReadReplica")
    def pg_read_replica(self) -> Optional[pulumi.Input[bool]]:
        """
        Use read_replica service integration instead.
        """
        warnings.warn("""Usage of this field is discouraged.""", DeprecationWarning)
        pulumi.log.warn("""pg_read_replica is deprecated: Usage of this field is discouraged.""")

        return pulumi.get(self, "pg_read_replica")

    @pg_read_replica.setter
    def pg_read_replica(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "pg_read_replica", value)

    @property
    @pulumi.getter(name="pgServiceToForkFrom")
    def pg_service_to_fork_from(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the PG Service from which to fork (deprecated, use service*to*fork_from). This has effect only when a new service is being created.
        """
        warnings.warn("""Usage of this field is discouraged.""", DeprecationWarning)
        pulumi.log.warn("""pg_service_to_fork_from is deprecated: Usage of this field is discouraged.""")

        return pulumi.get(self, "pg_service_to_fork_from")

    @pg_service_to_fork_from.setter
    def pg_service_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pg_service_to_fork_from", value)

    @property
    @pulumi.getter(name="pgStatMonitorEnable")
    def pg_stat_monitor_enable(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable the pg*stat*monitor extension. Enabling this extension will cause the cluster to be restarted.When this extension is enabled, pg*stat*statements results for utility commands are unreliable. The default value is `false`.
        """
        return pulumi.get(self, "pg_stat_monitor_enable")

    @pg_stat_monitor_enable.setter
    def pg_stat_monitor_enable(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "pg_stat_monitor_enable", value)

    @property
    @pulumi.getter(name="pgVersion")
    def pg_version(self) -> Optional[pulumi.Input[str]]:
        """
        PostgreSQL major version.
        """
        return pulumi.get(self, "pg_version")

    @pg_version.setter
    def pg_version(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pg_version", value)

    @property
    @pulumi.getter
    def pgbouncer(self) -> Optional[pulumi.Input['PgPgUserConfigPgbouncerArgs']]:
        """
        PGBouncer connection pooling settings.
        """
        return pulumi.get(self, "pgbouncer")

    @pgbouncer.setter
    def pgbouncer(self, value: Optional[pulumi.Input['PgPgUserConfigPgbouncerArgs']]):
        pulumi.set(self, "pgbouncer", value)

    @property
    @pulumi.getter
    def pglookout(self) -> Optional[pulumi.Input['PgPgUserConfigPglookoutArgs']]:
        """
        PGLookout settings.
        """
        return pulumi.get(self, "pglookout")

    @pglookout.setter
    def pglookout(self, value: Optional[pulumi.Input['PgPgUserConfigPglookoutArgs']]):
        pulumi.set(self, "pglookout", value)

    @property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['PgPgUserConfigPrivateAccessArgs']]:
        """
        Allow access to selected service ports from private networks.
        """
        return pulumi.get(self, "private_access")

    @private_access.setter
    def private_access(self, value: Optional[pulumi.Input['PgPgUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['PgPgUserConfigPrivatelinkAccessArgs']]:
        """
        Allow access to selected service components through Privatelink.
        """
        return pulumi.get(self, "privatelink_access")

    @privatelink_access.setter
    def privatelink_access(self, value: Optional[pulumi.Input['PgPgUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)

    @property
    @pulumi.getter(name="projectToForkFrom")
    def project_to_fork_from(self) -> Optional[pulumi.Input[str]]:
        """
        Name of another project to fork a service from. This has effect only when a new service is being created.
        """
        return pulumi.get(self, "project_to_fork_from")

    @project_to_fork_from.setter
    def project_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "project_to_fork_from", value)

    @property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['PgPgUserConfigPublicAccessArgs']]:
        """
        Allow access to selected service ports from the public Internet.
        """
        return pulumi.get(self, "public_access")

    @public_access.setter
    def public_access(self, value: Optional[pulumi.Input['PgPgUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

    @property
    @pulumi.getter(name="recoveryTargetTime")
    def recovery_target_time(self) -> Optional[pulumi.Input[str]]:
        """
        Recovery target time when forking a service. This has effect only when a new service is being created.
        """
        return pulumi.get(self, "recovery_target_time")

    @recovery_target_time.setter
    def recovery_target_time(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "recovery_target_time", value)

    @property
    @pulumi.getter(name="serviceToForkFrom")
    def service_to_fork_from(self) -> Optional[pulumi.Input[str]]:
        """
        Name of another service to fork from. This has effect only when a new service is being created.
        """
        return pulumi.get(self, "service_to_fork_from")

    @service_to_fork_from.setter
    def service_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_to_fork_from", value)

    @property
    @pulumi.getter(name="sharedBuffersPercentage")
    def shared_buffers_percentage(self) -> Optional[pulumi.Input[float]]:
        """
        Percentage of total RAM that the database server uses for shared memory buffers. Valid range is 20-60 (float), which corresponds to 20% - 60%. This setting adjusts the shared_buffers configuration value.
        """
        return pulumi.get(self, "shared_buffers_percentage")

    @shared_buffers_percentage.setter
    def shared_buffers_percentage(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "shared_buffers_percentage", value)

    @property
    @pulumi.getter(name="staticIps")
    def static_ips(self) -> Optional[pulumi.Input[bool]]:
        """
        Use static public IP addresses.
        """
        return pulumi.get(self, "static_ips")

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "static_ips", value)

    @property
    @pulumi.getter(name="synchronousReplication")
    def synchronous_replication(self) -> Optional[pulumi.Input[str]]:
        """
        Synchronous replication type. Note that the service plan also needs to support synchronous replication.
        """
        return pulumi.get(self, "synchronous_replication")

    @synchronous_replication.setter
    def synchronous_replication(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "synchronous_replication", value)

    @property
    @pulumi.getter
    def timescaledb(self) -> Optional[pulumi.Input['PgPgUserConfigTimescaledbArgs']]:
        """
        TimescaleDB extension configuration values.
        """
        return pulumi.get(self, "timescaledb")

    @timescaledb.setter
    def timescaledb(self, value: Optional[pulumi.Input['PgPgUserConfigTimescaledbArgs']]):
        pulumi.set(self, "timescaledb", value)

    @property
    @pulumi.getter
    def variant(self) -> Optional[pulumi.Input[str]]:
        """
        Variant of the PostgreSQL service, may affect the features that are exposed by default.
        """
        return pulumi.get(self, "variant")

    @variant.setter
    def variant(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "variant", value)

    @property
    @pulumi.getter(name="workMem")
    def work_mem(self) -> Optional[pulumi.Input[int]]:
        """
        Sets the maximum amount of memory to be used by a query operation (such as a sort or hash table) before writing to temporary disk files, in MB. Default is 1MB + 0.075% of total RAM (up to 32MB).
        """
        return pulumi.get(self, "work_mem")

    @work_mem.setter
    def work_mem(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "work_mem", value)


@pulumi.input_type
class PgPgUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

    @network.setter
    def network(self, value: pulumi.Input[str]):
        pulumi.set(self, "network", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class PgPgUserConfigMigrationArgs:
    def __init__(__self__, *,
                 host: pulumi.Input[str],
                 port: pulumi.Input[int],
                 dbname: Optional[pulumi.Input[str]] = None,
                 ignore_dbs: Optional[pulumi.Input[str]] = None,
                 method: Optional[pulumi.Input[str]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 ssl: Optional[pulumi.Input[bool]] = None,
                 username: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)
        if dbname is not None:
            pulumi.set(__self__, "dbname", dbname)
        if ignore_dbs is not None:
            pulumi.set(__self__, "ignore_dbs", ignore_dbs)
        if method is not None:
            pulumi.set(__self__, "method", method)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if username is not None:
            pulumi.set(__self__, "username", username)

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

    @host.setter
    def host(self, value: pulumi.Input[str]):
        pulumi.set(self, "host", value)

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

    @port.setter
    def port(self, value: pulumi.Input[int]):
        pulumi.set(self, "port", value)

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

    @dbname.setter
    def dbname(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dbname", value)

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

    @ignore_dbs.setter
    def ignore_dbs(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ignore_dbs", value)

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

    @method.setter
    def method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "method", value)

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

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

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

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl", value)

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

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)


@pulumi.input_type
class PgPgUserConfigPgArgs:
    def __init__(__self__, *,
                 autovacuum_analyze_scale_factor: Optional[pulumi.Input[float]] = None,
                 autovacuum_analyze_threshold: Optional[pulumi.Input[int]] = None,
                 autovacuum_freeze_max_age: Optional[pulumi.Input[int]] = None,
                 autovacuum_max_workers: Optional[pulumi.Input[int]] = None,
                 autovacuum_naptime: Optional[pulumi.Input[int]] = None,
                 autovacuum_vacuum_cost_delay: Optional[pulumi.Input[int]] = None,
                 autovacuum_vacuum_cost_limit: Optional[pulumi.Input[int]] = None,
                 autovacuum_vacuum_scale_factor: Optional[pulumi.Input[float]] = None,
                 autovacuum_vacuum_threshold: Optional[pulumi.Input[int]] = None,
                 bgwriter_delay: Optional[pulumi.Input[int]] = None,
                 bgwriter_flush_after: Optional[pulumi.Input[int]] = None,
                 bgwriter_lru_maxpages: Optional[pulumi.Input[int]] = None,
                 bgwriter_lru_multiplier: Optional[pulumi.Input[float]] = None,
                 deadlock_timeout: Optional[pulumi.Input[int]] = None,
                 default_toast_compression: Optional[pulumi.Input[str]] = None,
                 idle_in_transaction_session_timeout: Optional[pulumi.Input[int]] = None,
                 jit: Optional[pulumi.Input[bool]] = None,
                 log_autovacuum_min_duration: Optional[pulumi.Input[int]] = None,
                 log_error_verbosity: Optional[pulumi.Input[str]] = None,
                 log_line_prefix: Optional[pulumi.Input[str]] = None,
                 log_min_duration_statement: Optional[pulumi.Input[int]] = None,
                 log_temp_files: Optional[pulumi.Input[int]] = None,
                 max_files_per_process: Optional[pulumi.Input[int]] = None,
                 max_locks_per_transaction: Optional[pulumi.Input[int]] = None,
                 max_logical_replication_workers: Optional[pulumi.Input[int]] = None,
                 max_parallel_workers: Optional[pulumi.Input[int]] = None,
                 max_parallel_workers_per_gather: Optional[pulumi.Input[int]] = None,
                 max_pred_locks_per_transaction: Optional[pulumi.Input[int]] = None,
                 max_prepared_transactions: Optional[pulumi.Input[int]] = None,
                 max_replication_slots: Optional[pulumi.Input[int]] = None,
                 max_slot_wal_keep_size: Optional[pulumi.Input[int]] = None,
                 max_stack_depth: Optional[pulumi.Input[int]] = None,
                 max_standby_archive_delay: Optional[pulumi.Input[int]] = None,
                 max_standby_streaming_delay: Optional[pulumi.Input[int]] = None,
                 max_wal_senders: Optional[pulumi.Input[int]] = None,
                 max_worker_processes: Optional[pulumi.Input[int]] = None,
                 pg_partman_bgw_dot_interval: Optional[pulumi.Input[int]] = None,
                 pg_partman_bgw_dot_role: Optional[pulumi.Input[str]] = None,
                 pg_stat_monitor_dot_pgsm_enable_query_plan: Optional[pulumi.Input[bool]] = None,
                 pg_stat_monitor_dot_pgsm_max_buckets: Optional[pulumi.Input[int]] = None,
                 pg_stat_statements_dot_track: Optional[pulumi.Input[str]] = None,
                 temp_file_limit: Optional[pulumi.Input[int]] = None,
                 timezone: Optional[pulumi.Input[str]] = None,
                 track_activity_query_size: Optional[pulumi.Input[int]] = None,
                 track_commit_timestamp: Optional[pulumi.Input[str]] = None,
                 track_functions: Optional[pulumi.Input[str]] = None,
                 track_io_timing: Optional[pulumi.Input[str]] = None,
                 wal_sender_timeout: Optional[pulumi.Input[int]] = None,
                 wal_writer_delay: Optional[pulumi.Input[int]] = None):
        if autovacuum_analyze_scale_factor is not None:
            pulumi.set(__self__, "autovacuum_analyze_scale_factor", autovacuum_analyze_scale_factor)
        if autovacuum_analyze_threshold is not None:
            pulumi.set(__self__, "autovacuum_analyze_threshold", autovacuum_analyze_threshold)
        if autovacuum_freeze_max_age is not None:
            pulumi.set(__self__, "autovacuum_freeze_max_age", autovacuum_freeze_max_age)
        if autovacuum_max_workers is not None:
            pulumi.set(__self__, "autovacuum_max_workers", autovacuum_max_workers)
        if autovacuum_naptime is not None:
            pulumi.set(__self__, "autovacuum_naptime", autovacuum_naptime)
        if autovacuum_vacuum_cost_delay is not None:
            pulumi.set(__self__, "autovacuum_vacuum_cost_delay", autovacuum_vacuum_cost_delay)
        if autovacuum_vacuum_cost_limit is not None:
            pulumi.set(__self__, "autovacuum_vacuum_cost_limit", autovacuum_vacuum_cost_limit)
        if autovacuum_vacuum_scale_factor is not None:
            pulumi.set(__self__, "autovacuum_vacuum_scale_factor", autovacuum_vacuum_scale_factor)
        if autovacuum_vacuum_threshold is not None:
            pulumi.set(__self__, "autovacuum_vacuum_threshold", autovacuum_vacuum_threshold)
        if bgwriter_delay is not None:
            pulumi.set(__self__, "bgwriter_delay", bgwriter_delay)
        if bgwriter_flush_after is not None:
            pulumi.set(__self__, "bgwriter_flush_after", bgwriter_flush_after)
        if bgwriter_lru_maxpages is not None:
            pulumi.set(__self__, "bgwriter_lru_maxpages", bgwriter_lru_maxpages)
        if bgwriter_lru_multiplier is not None:
            pulumi.set(__self__, "bgwriter_lru_multiplier", bgwriter_lru_multiplier)
        if deadlock_timeout is not None:
            pulumi.set(__self__, "deadlock_timeout", deadlock_timeout)
        if default_toast_compression is not None:
            pulumi.set(__self__, "default_toast_compression", default_toast_compression)
        if idle_in_transaction_session_timeout is not None:
            pulumi.set(__self__, "idle_in_transaction_session_timeout", idle_in_transaction_session_timeout)
        if jit is not None:
            pulumi.set(__self__, "jit", jit)
        if log_autovacuum_min_duration is not None:
            pulumi.set(__self__, "log_autovacuum_min_duration", log_autovacuum_min_duration)
        if log_error_verbosity is not None:
            pulumi.set(__self__, "log_error_verbosity", log_error_verbosity)
        if log_line_prefix is not None:
            pulumi.set(__self__, "log_line_prefix", log_line_prefix)
        if log_min_duration_statement is not None:
            pulumi.set(__self__, "log_min_duration_statement", log_min_duration_statement)
        if log_temp_files is not None:
            pulumi.set(__self__, "log_temp_files", log_temp_files)
        if max_files_per_process is not None:
            pulumi.set(__self__, "max_files_per_process", max_files_per_process)
        if max_locks_per_transaction is not None:
            pulumi.set(__self__, "max_locks_per_transaction", max_locks_per_transaction)
        if max_logical_replication_workers is not None:
            pulumi.set(__self__, "max_logical_replication_workers", max_logical_replication_workers)
        if max_parallel_workers is not None:
            pulumi.set(__self__, "max_parallel_workers", max_parallel_workers)
        if max_parallel_workers_per_gather is not None:
            pulumi.set(__self__, "max_parallel_workers_per_gather", max_parallel_workers_per_gather)
        if max_pred_locks_per_transaction is not None:
            pulumi.set(__self__, "max_pred_locks_per_transaction", max_pred_locks_per_transaction)
        if max_prepared_transactions is not None:
            pulumi.set(__self__, "max_prepared_transactions", max_prepared_transactions)
        if max_replication_slots is not None:
            pulumi.set(__self__, "max_replication_slots", max_replication_slots)
        if max_slot_wal_keep_size is not None:
            pulumi.set(__self__, "max_slot_wal_keep_size", max_slot_wal_keep_size)
        if max_stack_depth is not None:
            pulumi.set(__self__, "max_stack_depth", max_stack_depth)
        if max_standby_archive_delay is not None:
            pulumi.set(__self__, "max_standby_archive_delay", max_standby_archive_delay)
        if max_standby_streaming_delay is not None:
            pulumi.set(__self__, "max_standby_streaming_delay", max_standby_streaming_delay)
        if max_wal_senders is not None:
            pulumi.set(__self__, "max_wal_senders", max_wal_senders)
        if max_worker_processes is not None:
            pulumi.set(__self__, "max_worker_processes", max_worker_processes)
        if pg_partman_bgw_dot_interval is not None:
            pulumi.set(__self__, "pg_partman_bgw_dot_interval", pg_partman_bgw_dot_interval)
        if pg_partman_bgw_dot_role is not None:
            pulumi.set(__self__, "pg_partman_bgw_dot_role", pg_partman_bgw_dot_role)
        if pg_stat_monitor_dot_pgsm_enable_query_plan is not None:
            pulumi.set(__self__, "pg_stat_monitor_dot_pgsm_enable_query_plan", pg_stat_monitor_dot_pgsm_enable_query_plan)
        if pg_stat_monitor_dot_pgsm_max_buckets is not None:
            pulumi.set(__self__, "pg_stat_monitor_dot_pgsm_max_buckets", pg_stat_monitor_dot_pgsm_max_buckets)
        if pg_stat_statements_dot_track is not None:
            pulumi.set(__self__, "pg_stat_statements_dot_track", pg_stat_statements_dot_track)
        if temp_file_limit is not None:
            pulumi.set(__self__, "temp_file_limit", temp_file_limit)
        if timezone is not None:
            pulumi.set(__self__, "timezone", timezone)
        if track_activity_query_size is not None:
            pulumi.set(__self__, "track_activity_query_size", track_activity_query_size)
        if track_commit_timestamp is not None:
            pulumi.set(__self__, "track_commit_timestamp", track_commit_timestamp)
        if track_functions is not None:
            pulumi.set(__self__, "track_functions", track_functions)
        if track_io_timing is not None:
            pulumi.set(__self__, "track_io_timing", track_io_timing)
        if wal_sender_timeout is not None:
            pulumi.set(__self__, "wal_sender_timeout", wal_sender_timeout)
        if wal_writer_delay is not None:
            pulumi.set(__self__, "wal_writer_delay", wal_writer_delay)

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

    @autovacuum_analyze_scale_factor.setter
    def autovacuum_analyze_scale_factor(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "autovacuum_analyze_scale_factor", value)

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

    @autovacuum_analyze_threshold.setter
    def autovacuum_analyze_threshold(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "autovacuum_analyze_threshold", value)

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

    @autovacuum_freeze_max_age.setter
    def autovacuum_freeze_max_age(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "autovacuum_freeze_max_age", value)

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

    @autovacuum_max_workers.setter
    def autovacuum_max_workers(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "autovacuum_max_workers", value)

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

    @autovacuum_naptime.setter
    def autovacuum_naptime(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "autovacuum_naptime", value)

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

    @autovacuum_vacuum_cost_delay.setter
    def autovacuum_vacuum_cost_delay(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "autovacuum_vacuum_cost_delay", value)

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

    @autovacuum_vacuum_cost_limit.setter
    def autovacuum_vacuum_cost_limit(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "autovacuum_vacuum_cost_limit", value)

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

    @autovacuum_vacuum_scale_factor.setter
    def autovacuum_vacuum_scale_factor(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "autovacuum_vacuum_scale_factor", value)

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

    @autovacuum_vacuum_threshold.setter
    def autovacuum_vacuum_threshold(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "autovacuum_vacuum_threshold", value)

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

    @bgwriter_delay.setter
    def bgwriter_delay(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "bgwriter_delay", value)

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

    @bgwriter_flush_after.setter
    def bgwriter_flush_after(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "bgwriter_flush_after", value)

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

    @bgwriter_lru_maxpages.setter
    def bgwriter_lru_maxpages(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "bgwriter_lru_maxpages", value)

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

    @bgwriter_lru_multiplier.setter
    def bgwriter_lru_multiplier(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "bgwriter_lru_multiplier", value)

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

    @deadlock_timeout.setter
    def deadlock_timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "deadlock_timeout", value)

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

    @default_toast_compression.setter
    def default_toast_compression(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "default_toast_compression", value)

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

    @idle_in_transaction_session_timeout.setter
    def idle_in_transaction_session_timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "idle_in_transaction_session_timeout", value)

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

    @jit.setter
    def jit(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "jit", value)

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

    @log_autovacuum_min_duration.setter
    def log_autovacuum_min_duration(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_autovacuum_min_duration", value)

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

    @log_error_verbosity.setter
    def log_error_verbosity(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "log_error_verbosity", value)

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

    @log_line_prefix.setter
    def log_line_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "log_line_prefix", value)

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

    @log_min_duration_statement.setter
    def log_min_duration_statement(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_min_duration_statement", value)

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

    @log_temp_files.setter
    def log_temp_files(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "log_temp_files", value)

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

    @max_files_per_process.setter
    def max_files_per_process(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_files_per_process", value)

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

    @max_locks_per_transaction.setter
    def max_locks_per_transaction(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_locks_per_transaction", value)

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

    @max_logical_replication_workers.setter
    def max_logical_replication_workers(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_logical_replication_workers", value)

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

    @max_parallel_workers.setter
    def max_parallel_workers(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_parallel_workers", value)

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

    @max_parallel_workers_per_gather.setter
    def max_parallel_workers_per_gather(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_parallel_workers_per_gather", value)

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

    @max_pred_locks_per_transaction.setter
    def max_pred_locks_per_transaction(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_pred_locks_per_transaction", value)

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

    @max_prepared_transactions.setter
    def max_prepared_transactions(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_prepared_transactions", value)

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

    @max_replication_slots.setter
    def max_replication_slots(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_replication_slots", value)

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

    @max_slot_wal_keep_size.setter
    def max_slot_wal_keep_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_slot_wal_keep_size", value)

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

    @max_stack_depth.setter
    def max_stack_depth(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_stack_depth", value)

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

    @max_standby_archive_delay.setter
    def max_standby_archive_delay(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_standby_archive_delay", value)

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

    @max_standby_streaming_delay.setter
    def max_standby_streaming_delay(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_standby_streaming_delay", value)

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

    @max_wal_senders.setter
    def max_wal_senders(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_wal_senders", value)

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

    @max_worker_processes.setter
    def max_worker_processes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_worker_processes", value)

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

    @pg_partman_bgw_dot_interval.setter
    def pg_partman_bgw_dot_interval(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "pg_partman_bgw_dot_interval", value)

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

    @pg_partman_bgw_dot_role.setter
    def pg_partman_bgw_dot_role(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pg_partman_bgw_dot_role", value)

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

    @pg_stat_monitor_dot_pgsm_enable_query_plan.setter
    def pg_stat_monitor_dot_pgsm_enable_query_plan(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "pg_stat_monitor_dot_pgsm_enable_query_plan", value)

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

    @pg_stat_monitor_dot_pgsm_max_buckets.setter
    def pg_stat_monitor_dot_pgsm_max_buckets(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "pg_stat_monitor_dot_pgsm_max_buckets", value)

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

    @pg_stat_statements_dot_track.setter
    def pg_stat_statements_dot_track(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "pg_stat_statements_dot_track", value)

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

    @temp_file_limit.setter
    def temp_file_limit(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "temp_file_limit", 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="trackActivityQuerySize")
    def track_activity_query_size(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "track_activity_query_size")

    @track_activity_query_size.setter
    def track_activity_query_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "track_activity_query_size", value)

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

    @track_commit_timestamp.setter
    def track_commit_timestamp(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "track_commit_timestamp", value)

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

    @track_functions.setter
    def track_functions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "track_functions", value)

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

    @track_io_timing.setter
    def track_io_timing(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "track_io_timing", value)

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

    @wal_sender_timeout.setter
    def wal_sender_timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "wal_sender_timeout", value)

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

    @wal_writer_delay.setter
    def wal_writer_delay(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "wal_writer_delay", value)


@pulumi.input_type
class PgPgUserConfigPgbouncerArgs:
    def __init__(__self__, *,
                 autodb_idle_timeout: Optional[pulumi.Input[int]] = None,
                 autodb_max_db_connections: Optional[pulumi.Input[int]] = None,
                 autodb_pool_mode: Optional[pulumi.Input[str]] = None,
                 autodb_pool_size: Optional[pulumi.Input[int]] = None,
                 ignore_startup_parameters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 min_pool_size: Optional[pulumi.Input[int]] = None,
                 server_idle_timeout: Optional[pulumi.Input[int]] = None,
                 server_lifetime: Optional[pulumi.Input[int]] = None,
                 server_reset_query_always: Optional[pulumi.Input[bool]] = None):
        if autodb_idle_timeout is not None:
            pulumi.set(__self__, "autodb_idle_timeout", autodb_idle_timeout)
        if autodb_max_db_connections is not None:
            pulumi.set(__self__, "autodb_max_db_connections", autodb_max_db_connections)
        if autodb_pool_mode is not None:
            pulumi.set(__self__, "autodb_pool_mode", autodb_pool_mode)
        if autodb_pool_size is not None:
            pulumi.set(__self__, "autodb_pool_size", autodb_pool_size)
        if ignore_startup_parameters is not None:
            pulumi.set(__self__, "ignore_startup_parameters", ignore_startup_parameters)
        if min_pool_size is not None:
            pulumi.set(__self__, "min_pool_size", min_pool_size)
        if server_idle_timeout is not None:
            pulumi.set(__self__, "server_idle_timeout", server_idle_timeout)
        if server_lifetime is not None:
            pulumi.set(__self__, "server_lifetime", server_lifetime)
        if server_reset_query_always is not None:
            pulumi.set(__self__, "server_reset_query_always", server_reset_query_always)

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

    @autodb_idle_timeout.setter
    def autodb_idle_timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "autodb_idle_timeout", value)

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

    @autodb_max_db_connections.setter
    def autodb_max_db_connections(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "autodb_max_db_connections", value)

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

    @autodb_pool_mode.setter
    def autodb_pool_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "autodb_pool_mode", value)

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

    @autodb_pool_size.setter
    def autodb_pool_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "autodb_pool_size", value)

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

    @ignore_startup_parameters.setter
    def ignore_startup_parameters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ignore_startup_parameters", value)

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

    @min_pool_size.setter
    def min_pool_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "min_pool_size", value)

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

    @server_idle_timeout.setter
    def server_idle_timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "server_idle_timeout", value)

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

    @server_lifetime.setter
    def server_lifetime(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "server_lifetime", value)

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

    @server_reset_query_always.setter
    def server_reset_query_always(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "server_reset_query_always", value)


@pulumi.input_type
class PgPgUserConfigPglookoutArgs:
    def __init__(__self__, *,
                 max_failover_replication_time_lag: Optional[pulumi.Input[int]] = None):
        if max_failover_replication_time_lag is not None:
            pulumi.set(__self__, "max_failover_replication_time_lag", max_failover_replication_time_lag)

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

    @max_failover_replication_time_lag.setter
    def max_failover_replication_time_lag(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_failover_replication_time_lag", value)


@pulumi.input_type
class PgPgUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 pg: Optional[pulumi.Input[bool]] = None,
                 pgbouncer: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] pg: PostgreSQL specific server provided values
        """
        if pg is not None:
            pulumi.set(__self__, "pg", pg)
        if pgbouncer is not None:
            pulumi.set(__self__, "pgbouncer", pgbouncer)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @property
    @pulumi.getter
    def pg(self) -> Optional[pulumi.Input[bool]]:
        """
        PostgreSQL specific server provided values
        """
        return pulumi.get(self, "pg")

    @pg.setter
    def pg(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "pg", value)

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

    @pgbouncer.setter
    def pgbouncer(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "pgbouncer", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class PgPgUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 pg: Optional[pulumi.Input[bool]] = None,
                 pgbouncer: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] pg: PostgreSQL specific server provided values
        """
        if pg is not None:
            pulumi.set(__self__, "pg", pg)
        if pgbouncer is not None:
            pulumi.set(__self__, "pgbouncer", pgbouncer)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @property
    @pulumi.getter
    def pg(self) -> Optional[pulumi.Input[bool]]:
        """
        PostgreSQL specific server provided values
        """
        return pulumi.get(self, "pg")

    @pg.setter
    def pg(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "pg", value)

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

    @pgbouncer.setter
    def pgbouncer(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "pgbouncer", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class PgPgUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 pg: Optional[pulumi.Input[bool]] = None,
                 pgbouncer: Optional[pulumi.Input[bool]] = None,
                 prometheus: Optional[pulumi.Input[bool]] = None):
        """
        :param pulumi.Input[bool] pg: PostgreSQL specific server provided values
        """
        if pg is not None:
            pulumi.set(__self__, "pg", pg)
        if pgbouncer is not None:
            pulumi.set(__self__, "pgbouncer", pgbouncer)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @property
    @pulumi.getter
    def pg(self) -> Optional[pulumi.Input[bool]]:
        """
        PostgreSQL specific server provided values
        """
        return pulumi.get(self, "pg")

    @pg.setter
    def pg(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "pg", value)

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

    @pgbouncer.setter
    def pgbouncer(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "pgbouncer", value)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)


@pulumi.input_type
class PgPgUserConfigTimescaledbArgs:
    def __init__(__self__, *,
                 max_background_workers: Optional[pulumi.Input[int]] = None):
        if max_background_workers is not None:
            pulumi.set(__self__, "max_background_workers", max_background_workers)

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

    @max_background_workers.setter
    def max_background_workers(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_background_workers", value)


@pulumi.input_type
class PgServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[str],
                 source_service_name: pulumi.Input[str]):
        """
        :param pulumi.Input[str] integration_type: Type of the service integration. The only supported value at the moment is `read_replica`
        :param pulumi.Input[str] source_service_name: Name of the source service
        """
        pulumi.set(__self__, "integration_type", integration_type)
        pulumi.set(__self__, "source_service_name", source_service_name)

    @property
    @pulumi.getter(name="integrationType")
    def integration_type(self) -> pulumi.Input[str]:
        """
        Type of the service integration. The only supported value at the moment is `read_replica`
        """
        return pulumi.get(self, "integration_type")

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "integration_type", value)

    @property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[str]:
        """
        Name of the source service
        """
        return pulumi.get(self, "source_service_name")

    @source_service_name.setter
    def source_service_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "source_service_name", value)


@pulumi.input_type
class PgTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: Service tag key
        :param pulumi.Input[str] value: Service tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        Service tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class ProjectTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        """
        :param pulumi.Input[str] key: Project tag key
        :param pulumi.Input[str] value: Project tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @property
    @pulumi.getter
    def key(self) -> pulumi.Input[str]:
        """
        Project tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class RedisComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[str]] = None,
                 host: Optional[pulumi.Input[str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[str]] = None,
                 port: Optional[pulumi.Input[int]] = None,
                 route: Optional[pulumi.Input[str]] = None,
                 ssl: Optional[pulumi.Input[bool]] = None,
                 usage: Optional[pulumi.Input[str]] = None):
        if component is not None:
            pulumi.set(__self__, "component", component)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if kafka_authentication_method is not None:
            pulumi.set(__self__, "kafka_authentication_method", kafka_authentication_method)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if route is not None:
            pulumi.set(__self__, "route", route)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if usage is not None:
            pulumi.set(__self__, "usage", usage)

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

    @component.setter
    def component(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "component", value)

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

    @host.setter
    def host(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "host", value)

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

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "kafka_authentication_method", 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
    def route(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "route", value)

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

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl", value)

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

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "usage", value)


@pulumi.input_type
class RedisRediArgs:
    def __init__(__self__):
        pass


@pulumi.input_type
class RedisRedisUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['RedisRedisUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 migration: Optional[pulumi.Input['RedisRedisUserConfigMigrationArgs']] = None,
                 private_access: Optional[pulumi.Input['RedisRedisUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['RedisRedisUserConfigPrivatelinkAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[str]] = None,
                 public_access: Optional[pulumi.Input['RedisRedisUserConfigPublicAccessArgs']] = None,
                 recovery_basebackup_name: Optional[pulumi.Input[str]] = None,
                 redis_acl_channels_default: Optional[pulumi.Input[str]] = None,
                 redis_io_threads: Optional[pulumi.Input[int]] = None,
                 redis_lfu_decay_time: Optional[pulumi.Input[int]] = None,
                 redis_lfu_log_factor: Optional[pulumi.Input[int]] = None,
                 redis_maxmemory_policy: Optional[pulumi.Input[str]] = None,
                 redis_notify_keyspace_events: Optional[pulumi.Input[str]] = None,
                 redis_number_of_databases: Optional[pulumi.Input[int]] = None,
                 redis_persistence: Optional[pulumi.Input[str]] = None,
                 redis_pubsub_client_output_buffer_limit: Optional[pulumi.Input[int]] = None,
                 redis_ssl: Optional[pulumi.Input[bool]] = None,
                 redis_timeout: Optional[pulumi.Input[int]] = None,
                 service_to_fork_from: Optional[pulumi.Input[str]] = None,
                 static_ips: Optional[pulumi.Input[bool]] = None):
        if additional_backup_regions is not None:
            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
        if ip_filter_objects is not None:
            pulumi.set(__self__, "ip_filter_objects", ip_filter_objects)
        if ip_filter_strings is not None:
            pulumi.set(__self__, "ip_filter_strings", ip_filter_strings)
        if ip_filters is not None:
            warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        if migration is not None:
            pulumi.set(__self__, "migration", migration)
        if private_access is not None:
            pulumi.set(__self__, "private_access", private_access)
        if privatelink_access is not None:
            pulumi.set(__self__, "privatelink_access", privatelink_access)
        if project_to_fork_from is not None:
            pulumi.set(__self__, "project_to_fork_from", project_to_fork_from)
        if public_access is not None:
            pulumi.set(__self__, "public_access", public_access)
        if recovery_basebackup_name is not None:
            pulumi.set(__self__, "recovery_basebackup_name", recovery_basebackup_name)
        if redis_acl_channels_default is not None:
            pulumi.set(__self__, "redis_acl_channels_default", redis_acl_channels_default)
        if redis_io_threads is not None:
            pulumi.set(__self__, "redis_io_threads", redis_io_threads)
        if redis_lfu_decay_time is not None:
            pulumi.set(__self__, "redis_lfu_decay_time", redis_lfu_decay_time)
        if redis_lfu_log_factor is not None:
            pulumi.set(__self__, "redis_lfu_log_factor", redis_lfu_log_factor)
        if redis_maxmemory_policy is not None:
            pulumi.set(__self__, "redis_maxmemory_policy", redis_maxmemory_policy)
        if redis_notify_keyspace_events is not None:
            pulumi.set(__self__, "redis_notify_keyspace_events", redis_notify_keyspace_events)
        if redis_number_of_databases is not None:
            pulumi.set(__self__, "redis_number_of_databases", redis_number_of_databases)
        if redis_persistence is not None:
            pulumi.set(__self__, "redis_persistence", redis_persistence)
        if redis_pubsub_client_output_buffer_limit is not None:
            pulumi.set(__self__, "redis_pubsub_client_output_buffer_limit", redis_pubsub_client_output_buffer_limit)
        if redis_ssl is not None:
            pulumi.set(__self__, "redis_ssl", redis_ssl)
        if redis_timeout is not None:
            pulumi.set(__self__, "redis_timeout", redis_timeout)
        if service_to_fork_from is not None:
            pulumi.set(__self__, "service_to_fork_from", service_to_fork_from)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)

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

    @additional_backup_regions.setter
    def additional_backup_regions(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RedisRedisUserConfigIpFilterObjectArgs']]]]:
        return pulumi.get(self, "ip_filter_objects")

    @ip_filter_objects.setter
    def ip_filter_objects(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['RedisRedisUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

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

    @ip_filter_strings.setter
    def ip_filter_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @property
    @pulumi.getter(name="ipFilters")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        warnings.warn("""This will be removed in v5.0.0 and replaced with ip_filter_string instead.""", DeprecationWarning)
        pulumi.log.warn("""ip_filters is deprecated: This will be removed in v5.0.0 and replaced with ip_filter_string instead.""")

        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "ip_filters", value)

    @property
    @pulumi.getter
    def migration(self) -> Optional[pulumi.Input['RedisRedisUserConfigMigrationArgs']]:
        return pulumi.get(self, "migration")

    @migration.setter
    def migration(self, value: Optional[pulumi.Input['RedisRedisUserConfigMigrationArgs']]):
        pulumi.set(self, "migration", value)

    @property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['RedisRedisUserConfigPrivateAccessArgs']]:
        return pulumi.get(self, "private_access")

    @private_access.setter
    def private_access(self, value: Optional[pulumi.Input['RedisRedisUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['RedisRedisUserConfigPrivatelinkAccessArgs']]:
        return pulumi.get(self, "privatelink_access")

    @privatelink_access.setter
    def privatelink_access(self, value: Optional[pulumi.Input['RedisRedisUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)

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

    @project_to_fork_from.setter
    def project_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "project_to_fork_from", value)

    @property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['RedisRedisUserConfigPublicAccessArgs']]:
        return pulumi.get(self, "public_access")

    @public_access.setter
    def public_access(self, value: Optional[pulumi.Input['RedisRedisUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

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

    @recovery_basebackup_name.setter
    def recovery_basebackup_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "recovery_basebackup_name", value)

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

    @redis_acl_channels_default.setter
    def redis_acl_channels_default(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "redis_acl_channels_default", value)

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

    @redis_io_threads.setter
    def redis_io_threads(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "redis_io_threads", value)

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

    @redis_lfu_decay_time.setter
    def redis_lfu_decay_time(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "redis_lfu_decay_time", value)

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

    @redis_lfu_log_factor.setter
    def redis_lfu_log_factor(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "redis_lfu_log_factor", value)

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

    @redis_maxmemory_policy.setter
    def redis_maxmemory_policy(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "redis_maxmemory_policy", value)

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

    @redis_notify_keyspace_events.setter
    def redis_notify_keyspace_events(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "redis_notify_keyspace_events", value)

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

    @redis_number_of_databases.setter
    def redis_number_of_databases(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "redis_number_of_databases", value)

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

    @redis_persistence.setter
    def redis_persistence(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "redis_persistence", value)

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

    @redis_pubsub_client_output_buffer_limit.setter
    def redis_pubsub_client_output_buffer_limit(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "redis_pubsub_client_output_buffer_limit", value)

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

    @redis_ssl.setter
    def redis_ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "redis_ssl", value)

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

    @redis_timeout.setter
    def redis_timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "redis_timeout", value)

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

    @service_to_fork_from.setter
    def service_to_fork_from(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "service_to_fork_from", value)

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

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "static_ips", value)


@pulumi.input_type
class RedisRedisUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[str],
                 description: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

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

    @network.setter
    def network(self, value: pulumi.Input[str]):
        pulumi.set(self, "network", value)

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

    @description.setter
    def description(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "description", value)


@pulumi.input_type
class RedisRedisUserConfigMigrationArgs:
    def __init__(__self__, *,
                 host: pulumi.Input[str],
                 port: pulumi.Input[int],
                 dbname: Optional[pulumi.Input[str]] = None,
                 ignore_dbs: Optional[pulumi.Input[str]] = None,
                 method: Optional[pulumi.Input[str]] = None,
                 password: Optional[pulumi.Input[str]] = None,
                 ssl: Optional[pulumi.Input[bool]] = None,
                 username: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)
        if dbname is not None:
            pulumi.set(__self__, "dbname", dbname)
        if ignore_dbs is not None:
            pulumi.set(__self__, "ignore_dbs", ignore_dbs)
        if method is not None:
            pulumi.set(__self__, "method", method)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if username is not None:
            pulumi.set(__self__, "username", username)

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

    @host.setter
    def host(self, value: pulumi.Input[str]):
        pulumi.set(self, "host", value)

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

    @port.setter
    def port(self, value: pulumi.Input[int]):
        pulumi.set(self, "port", value)

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

    @dbname.setter
    def dbname(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "dbname", value)

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

    @ignore_dbs.setter
    def ignore_dbs(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ignore_dbs", value)

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

    @method.setter
    def method(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "method", value)

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

    @password.setter
    def password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "password", value)

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

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "ssl", value)

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

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)


@pulumi.input_type
class RedisRedisUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 prometheus: Optional[pulumi.Input[bool]] = None,
                 redis: Optional[pulumi.Input[bool]] = None):
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)
        if redis is not None:
            pulumi.set(__self__, "redis", redis)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)

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

    @redis.setter
    def redis(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "redis", value)


@pulumi.input_type
class RedisRedisUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 prometheus: Optional[pulumi.Input[bool]] = None,
                 redis: Optional[pulumi.Input[bool]] = None):
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)
        if redis is not None:
            pulumi.set(__self__, "redis", redis)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)

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

    @redis.setter
    def redis(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "redis", value)


@pulumi.input_type
class RedisRedisUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 prometheus: Optional[pulumi.Input[bool]] = None,
                 redis: Optional[pulumi.Input[bool]] = None):
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)
        if redis is not None:
            pulumi.set(__self__, "redis", redis)

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

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "prometheus", value)

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

    @redis.setter
    def redis(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "redis", value)


@pulumi.input_type
class RedisServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[str],
                 source_service_name: pulumi.Input[str]):
        pulumi.set(__self__, "integration_type", integration_type)
        pulumi.set(__self__, "source_service_name", source_service_name)

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

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[str]):
        pulumi.set(self, "integration_type", value)

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

    @source_service_name.setter
    def source_service_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "source_service_name", value)


@pulumi.input_type
class RedisTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[str],
                 value: pulumi.Input[str]):
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

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

    @key.setter
    def key(self, value: pulumi.Input[str]):
        pulumi.set(self, "key", value)

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

    @value.setter
    def value(self, value: pulumi.Input[str]):
        pulumi.set(self, "value", value)


@pulumi.input_type
class ServiceIntegrationClickhouseKafkaUserConfigArgs:
    def __init__(__self__, *,
                 tables: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableArgs']]] tables: Tables to create.
        """
        if tables is not None:
            pulumi.set(__self__, "tables", tables)

    @property
    @pulumi.getter
    def tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableArgs']]]]:
        """
        Tables to create.
        """
        return pulumi.get(self, "tables")

    @tables.setter
    def tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableArgs']]]]):
        pulumi.set(self, "tables", value)


@pulumi.input_type
class ServiceIntegrationClickhouseKafkaUserConfigTableArgs:
    def __init__(__self__, *,
                 data_format: pulumi.Input[str],
                 group_name: pulumi.Input[str],
                 name: pulumi.Input[str],
                 auto_offset_reset: Optional[pulumi.Input[str]] = None,
                 columns: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs']]]] = None,
                 date_time_input_format: Optional[pulumi.Input[str]] = None,
                 handle_error_mode: Optional[pulumi.Input[str]] = None,
                 max_block_size: Optional[pulumi.Input[int]] = None,
                 max_rows_per_message: Optional[pulumi.Input[int]] = None,
                 num_consumers: Optional[pulumi.Input[int]] = None,
                 poll_max_batch_size: Optional[pulumi.Input[int]] = None,
                 skip_broken_messages: Optional[pulumi.Input[int]] = None,
                 topics: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs']]]] = None):
        pulumi.set(__self__, "data_format", data_format)
        pulumi.set(__self__, "group_name", group_name)
        pulumi.set(__self__, "name", name)
        if auto_offset_reset is not None:
            pulumi.set(__self__, "auto_offset_reset", auto_offset_reset)
        if columns is not None:
            pulumi.set(__self__, "columns", columns)
        if date_time_input_format is not None:
            pulumi.set(__self__, "date_time_input_format", date_time_input_format)
        if handle_error_mode is not None:
            pulumi.set(__self__, "handle_error_mode", handle_error_mode)
        if max_block_size is not None:
            pulumi.set(__self__, "max_block_size", max_block_size)
        if max_rows_per_message is not None:
            pulumi.set(__self__, "max_rows_per_message", max_rows_per_message)
        if num_consumers is not None:
            pulumi.set(__self__, "num_consumers", num_consumers)
        if poll_max_batch_size is not None:
            pulumi.set(__self__, "poll_max_batch_size", poll_max_batch_size)
        if skip_broken_messages is not None:
            pulumi.set(__self__, "skip_broken_messages", skip_broken_messages)
        if topics is not None:
            pulumi.set(__self__, "topics", topics)

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

    @data_format.setter
    def data_format(self, value: pulumi.Input[str]):
        pulumi.set(self, "data_format", value)

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

    @group_name.setter
    def group_name(self, value: pulumi.Input[str]):
        pulumi.set(self, "group_name", value)

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

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)

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

    @auto_offset_reset.setter
    def auto_offset_reset(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "auto_offset_reset", value)

    @property
    @pulumi.getter
    def columns(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs']]]]:
        return pulumi.get(self, "columns")

    @columns.setter
    def columns(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs']]]]):
        pulumi.set(self, "columns", value)

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

    @date_time_input_format.setter
    def date_time_input_format(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "date_time_input_format", value)

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

    @handle_error_mode.setter
    def handle_error_mode(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "handle_error_mode", value)

    @property
    @pulumi.getter(name="maxBlockSize")
    def max_block_size(self) -> Optional[pulumi.Input[int]]:
        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="maxRowsPerMessage")
    def max_rows_per_message(self) -> Optional[pulumi.Input[int]]:
        return pulumi.get(self, "max_rows_per_message")

    @max_rows_per_message.setter
    def max_rows_per_message(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_rows_per_message", value)

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

    @num_consumers.setter
    def num_consumers(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "num_consumers", value)

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

    @poll_max_batch_size.setter
    def poll_max_batch_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "poll_max_batch_size", value)

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

    @skip_broken_messages.setter
    def skip_broken_messages(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "skip_broken_messages", value)

    @property
    @pulumi.getter
    def topics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs']]]]:
        return pulumi.get(self, "topics")

    @topics.setter
    def topics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs']]]]):
        pulumi.set(self, "topics", value)


@pulumi.input_type
class ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str],
                 type: pulumi.Input[str]):
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)

    @property
    @pulumi.getter
    def name(self) -> pulumi.Input[str]:
        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]:
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[str]):
        pulumi.set(self, "type", value)


@pulumi.input_type
class ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[str]):
        pulumi.set(__self__, "name", name)

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

    @name.setter
    def name(self, value: pulumi.Input[str]):
        pulumi.set(self, "name", value)


@pulumi.input_type
class ServiceIntegrationClickhousePostgresqlUserConfigArgs:
    def __init__(__self__, *,
                 databases: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhousePostgresqlUserConfigDatabaseArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhousePostgresqlUserConfigDatabaseArgs']]] databases: Databases to expose.
        """
        if databases is not None:
            pulumi.set(__self__, "databases", databases)

    @property
    @pulumi.getter
    def databases(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhousePostgresqlUserConfigDatabaseArgs']]]]:
        """
        Databases to expose.
        """
        return pulumi.get(self, "databases")

    @databases.setter
    def databases(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhousePostgresqlUserConfigDatabaseArgs']]]]):
        pulumi.set(self, "databases", value)


@pulumi.input_type
class ServiceIntegrationClickhousePostgresqlUserConfigDatabaseArgs:
    def __init__(__self__, *,
                 database: Optional[pulumi.Input[str]] = None,
                 schema: Optional[pulumi.Input[str]] = None):
        if database is not None:
            pulumi.set(__self__, "database", database)
        if schema is not None:
            pulumi.set(__self__, "schema", schema)

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

    @database.setter
    def database(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "database", value)

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

    @schema.setter
    def schema(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "schema", value)


@pulumi.input_type
class ServiceIntegrationDatadogUserConfigArgs:
    def __init__(__self__, *,
                 datadog_dbm_enabled: Optional[pulumi.Input[bool]] = None,
                 datadog_tags: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationDatadogUserConfigDatadogTagArgs']]]] = None,
                 exclude_consumer_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 exclude_topics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 include_consumer_groups: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 include_topics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 kafka_custom_metrics: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                 max_jmx_metrics: Optional[pulumi.Input[int]] = None,
                 opensearch: Optional[pulumi.Input['ServiceIntegrationDatadogUserConfigOpensearchArgs']] = None,
                 redis: Optional[pulumi.Input['ServiceIntegrationDatadogUserConfigRedisArgs']] = None):
        """
        :param pulumi.Input[bool] datadog_dbm_enabled: Enable Datadog Database Monitoring.
        :param pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationDatadogUserConfigDatadogTagArgs']]] datadog_tags: Custom tags provided by user.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] exclude_consumer_groups: List of custom metrics.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] exclude_topics: List of topics to exclude.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] include_consumer_groups: List of custom metrics.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] include_topics: List of topics to include.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] kafka_custom_metrics: List of custom metrics.
        :param pulumi.Input[int] max_jmx_metrics: Maximum number of JMX metrics to send.
        :param pulumi.Input['ServiceIntegrationDatadogUserConfigOpensearchArgs'] opensearch: Datadog Opensearch Options.
        :param pulumi.Input['ServiceIntegrationDatadogUserConfigRedisArgs'] redis: Datadog Redis Options.
        """
        if datadog_dbm_enabled is not None:
            pulumi.set(__self__, "datadog_dbm_enabled", datadog_dbm_enabled)
        if datadog_tags is not None:
            pulumi.set(__self__, "datadog_tags", datadog_tags)
        if exclude_consumer_groups is not None:
            pulumi.set(__self__, "exclude_consumer_groups", exclude_consumer_groups)
        if exclude_topics is not None:
            pulumi.set(__self__, "exclude_topics", exclude_topics)
        if include_consumer_groups is not None:
            pulumi.set(__self__, "include_consumer_groups", include_consumer_groups)
        if include_topics is not None:
            pulumi.set(__self__, "include_topics", include_topics)
        if kafka_custom_metrics is not None:
            pulumi.set(__self__, "kafka_custom_metrics", kafka_custom_metrics)
        if max_jmx_metrics is not None:
            pulumi.set(__self__, "max_jmx_metrics", max_jmx_metrics)
        if opensearch is not None:
            pulumi.set(__self__, "opensearch", opensearch)
        if redis is not None:
            pulumi.set(__self__, "redis", redis)

    @property
    @pulumi.getter(name="datadogDbmEnabled")
    def datadog_dbm_enabled(self) -> Optional[pulumi.Input[bool]]:
        """
        Enable Datadog Database Monitoring.
        """
        return pulumi.get(self, "datadog_dbm_enabled")

    @datadog_dbm_enabled.setter
    def datadog_dbm_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "datadog_dbm_enabled", value)

    @property
    @pulumi.getter(name="datadogTags")
    def datadog_tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationDatadogUserConfigDatadogTagArgs']]]]:
        """
        Custom tags provided by user.
        """
        return pulumi.get(self, "datadog_tags")

    @datadog_tags.setter
    def datadog_tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationDatadogUserConfigDatadogTagArgs']]]]):
        pulumi.set(self, "datadog_tags", value)

    @property
    @pulumi.getter(name="excludeConsumerGroups")
    def exclude_consumer_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of custom metrics.
        """
        return pulumi.get(self, "exclude_consumer_groups")

    @exclude_consumer_groups.setter
    def exclude_consumer_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "exclude_consumer_groups", value)

    @property
    @pulumi.getter(name="excludeTopics")
    def exclude_topics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of topics to exclude.
        """
        return pulumi.get(self, "exclude_topics")

    @exclude_topics.setter
    def exclude_topics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "exclude_topics", value)

    @property
    @pulumi.getter(name="includeConsumerGroups")
    def include_consumer_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of custom metrics.
        """
        return pulumi.get(self, "include_consumer_groups")

    @include_consumer_groups.setter
    def include_consumer_groups(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "include_consumer_groups", value)

    @property
    @pulumi.getter(name="includeTopics")
    def include_topics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of topics to include.
        """
        return pulumi.get(self, "include_topics")

    @include_topics.setter
    def include_topics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "include_topics", value)

    @property
    @pulumi.getter(name="kafkaCustomMetrics")
    def kafka_custom_metrics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        List of custom metrics.
        """
        return pulumi.get(self, "kafka_custom_metrics")

    @kafka_custom_metrics.setter
    def kafka_custom_metrics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "kafka_custom_metrics", value)

    @property
    @pulumi.getter(name="maxJmxMetrics")
    def max_jmx_metrics(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum number of JMX metrics to send.
        """
        return pulumi.get(self, "max_jmx_metrics")

    @max_jmx_metrics.setter
    def max_jmx_metrics(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_jmx_metrics", value)

    @property
    @pulumi.getter
    def opensearch(self) -> Optional[pulumi.Input['ServiceIntegrationDatadogUserConfigOpensearchArgs']]:
        """
        Datadog Opensearch Options.
        """
        return pulumi.get(self, "opensearch")

    @opensearch.setter
    def opensearch(self, value: Optional[pulumi.Input['ServiceIntegrationDatadogUserConfigOpensearchArgs']]):
        pulumi.set(self, "opensearch", value)

    @property
    @pulumi.getter
    def redis(self) -> Optional[pulumi.Input['ServiceIntegrationDatadogUserConfigRedisArgs']]:
        """
        Datadog Redis Options.
        """
        return pulumi.get(self, "redis")

    @redis.setter
    def redis(self, value: Optional[pulumi.Input['ServiceIntegrationDatadogUserConfigRedisArgs']]):
        pulumi.set(self, "redis", value)


@pulumi.input_type
class ServiceIntegrationDatadogUserConfigDatadogTagArgs:
    def __init__(__self__, *,
                 tag: pulumi.Input[str],
                 comment: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "tag", tag)
        if comment is not None:
            pulumi.set(__self__, "comment", comment)

    @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
    def comment(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "comment")

    @comment.setter
    def comment(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "comment", value)


@pulumi.input_type
class ServiceIntegrationDatadogUserConfigOpensearchArgs:
    def __init__(__self__, *,
                 index_stats_enabled: Optional[pulumi.Input[bool]] = None,
                 pending_task_stats_enabled: Optional[pulumi.Input[bool]] = None,
                 pshard_stats_enabled: Optional[pulumi.Input[bool]] = None):
        if index_stats_enabled is not None:
            pulumi.set(__self__, "index_stats_enabled", index_stats_enabled)
        if pending_task_stats_enabled is not None:
            pulumi.set(__self__, "pending_task_stats_enabled", pending_task_stats_enabled)
        if pshard_stats_enabled is not None:
            pulumi.set(__self__, "pshard_stats_enabled", pshard_stats_enabled)

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

    @index_stats_enabled.setter
    def index_stats_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "index_stats_enabled", value)

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

    @pending_task_stats_enabled.setter
    def pending_task_stats_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "pending_task_stats_enabled", value)

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

    @pshard_stats_enabled.setter
    def pshard_stats_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "pshard_stats_enabled", value)


@pulumi.input_type
class ServiceIntegrationDatadogUserConfigRedisArgs:
    def __init__(__self__, *,
                 command_stats_enabled: Optional[pulumi.Input[bool]] = None):
        if command_stats_enabled is not None:
            pulumi.set(__self__, "command_stats_enabled", command_stats_enabled)

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

    @command_stats_enabled.setter
    def command_stats_enabled(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "command_stats_enabled", value)


@pulumi.input_type
class ServiceIntegrationEndpointDatadogUserConfigArgs:
    def __init__(__self__, *,
                 datadog_api_key: pulumi.Input[str],
                 datadog_tags: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationEndpointDatadogUserConfigDatadogTagArgs']]]] = None,
                 disable_consumer_stats: Optional[pulumi.Input[bool]] = None,
                 kafka_consumer_check_instances: Optional[pulumi.Input[int]] = None,
                 kafka_consumer_stats_timeout: Optional[pulumi.Input[int]] = None,
                 max_partition_contexts: Optional[pulumi.Input[int]] = None,
                 site: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] datadog_api_key: Datadog API key.
        :param pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationEndpointDatadogUserConfigDatadogTagArgs']]] datadog_tags: Custom tags provided by user.
        :param pulumi.Input[bool] disable_consumer_stats: Disable consumer group metrics.
        :param pulumi.Input[int] kafka_consumer_check_instances: Number of separate instances to fetch kafka consumer statistics with.
        :param pulumi.Input[int] kafka_consumer_stats_timeout: Number of seconds that datadog will wait to get consumer statistics from brokers.
        :param pulumi.Input[int] max_partition_contexts: Maximum number of partition contexts to send.
        :param pulumi.Input[str] site: Datadog intake site. Defaults to datadoghq.com.
        """
        pulumi.set(__self__, "datadog_api_key", datadog_api_key)
        if datadog_tags is not None:
            pulumi.set(__self__, "datadog_tags", datadog_tags)
        if disable_consumer_stats is not None:
            pulumi.set(__self__, "disable_consumer_stats", disable_consumer_stats)
        if kafka_consumer_check_instances is not None:
            pulumi.set(__self__, "kafka_consumer_check_instances", kafka_consumer_check_instances)
        if kafka_consumer_stats_timeout is not None:
            pulumi.set(__self__, "kafka_consumer_stats_timeout", kafka_consumer_stats_timeout)
        if max_partition_contexts is not None:
            pulumi.set(__self__, "max_partition_contexts", max_partition_contexts)
        if site is not None:
            pulumi.set(__self__, "site", site)

    @property
    @pulumi.getter(name="datadogApiKey")
    def datadog_api_key(self) -> pulumi.Input[str]:
        """
        Datadog API key.
        """
        return pulumi.get(self, "datadog_api_key")

    @datadog_api_key.setter
    def datadog_api_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "datadog_api_key", value)

    @property
    @pulumi.getter(name="datadogTags")
    def datadog_tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationEndpointDatadogUserConfigDatadogTagArgs']]]]:
        """
        Custom tags provided by user.
        """
        return pulumi.get(self, "datadog_tags")

    @datadog_tags.setter
    def datadog_tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationEndpointDatadogUserConfigDatadogTagArgs']]]]):
        pulumi.set(self, "datadog_tags", value)

    @property
    @pulumi.getter(name="disableConsumerStats")
    def disable_consumer_stats(self) -> Optional[pulumi.Input[bool]]:
        """
        Disable consumer group metrics.
        """
        return pulumi.get(self, "disable_consumer_stats")

    @disable_consumer_stats.setter
    def disable_consumer_stats(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "disable_consumer_stats", value)

    @property
    @pulumi.getter(name="kafkaConsumerCheckInstances")
    def kafka_consumer_check_instances(self) -> Optional[pulumi.Input[int]]:
        """
        Number of separate instances to fetch kafka consumer statistics with.
        """
        return pulumi.get(self, "kafka_consumer_check_instances")

    @kafka_consumer_check_instances.setter
    def kafka_consumer_check_instances(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "kafka_consumer_check_instances", value)

    @property
    @pulumi.getter(name="kafkaConsumerStatsTimeout")
    def kafka_consumer_stats_timeout(self) -> Optional[pulumi.Input[int]]:
        """
        Number of seconds that datadog will wait to get consumer statistics from brokers.
        """
        return pulumi.get(self, "kafka_consumer_stats_timeout")

    @kafka_consumer_stats_timeout.setter
    def kafka_consumer_stats_timeout(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "kafka_consumer_stats_timeout", value)

    @property
    @pulumi.getter(name="maxPartitionContexts")
    def max_partition_contexts(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum number of partition contexts to send.
        """
        return pulumi.get(self, "max_partition_contexts")

    @max_partition_contexts.setter
    def max_partition_contexts(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "max_partition_contexts", value)

    @property
    @pulumi.getter
    def site(self) -> Optional[pulumi.Input[str]]:
        """
        Datadog intake site. Defaults to datadoghq.com.
        """
        return pulumi.get(self, "site")

    @site.setter
    def site(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "site", value)


@pulumi.input_type
class ServiceIntegrationEndpointDatadogUserConfigDatadogTagArgs:
    def __init__(__self__, *,
                 tag: pulumi.Input[str],
                 comment: Optional[pulumi.Input[str]] = None):
        pulumi.set(__self__, "tag", tag)
        if comment is not None:
            pulumi.set(__self__, "comment", comment)

    @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
    def comment(self) -> Optional[pulumi.Input[str]]:
        return pulumi.get(self, "comment")

    @comment.setter
    def comment(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "comment", value)


@pulumi.input_type
class ServiceIntegrationEndpointExternalAwsCloudwatchLogsUserConfigArgs:
    def __init__(__self__, *,
                 access_key: pulumi.Input[str],
                 region: pulumi.Input[str],
                 secret_key: pulumi.Input[str],
                 log_group_name: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] access_key: AWS access key. Required permissions are logs:CreateLogGroup, logs:CreateLogStream, logs:PutLogEvents and logs:DescribeLogStreams.
        :param pulumi.Input[str] region: AWS region.
        :param pulumi.Input[str] secret_key: AWS secret key.
        :param pulumi.Input[str] log_group_name: AWS CloudWatch log group name.
        """
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "secret_key", secret_key)
        if log_group_name is not None:
            pulumi.set(__self__, "log_group_name", log_group_name)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> pulumi.Input[str]:
        """
        AWS access key. Required permissions are logs:CreateLogGroup, logs:CreateLogStream, logs:PutLogEvents and logs:DescribeLogStreams.
        """
        return pulumi.get(self, "access_key")

    @access_key.setter
    def access_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "access_key", value)

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

    @region.setter
    def region(self, value: pulumi.Input[str]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> pulumi.Input[str]:
        """
        AWS secret key.
        """
        return pulumi.get(self, "secret_key")

    @secret_key.setter
    def secret_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret_key", value)

    @property
    @pulumi.getter(name="logGroupName")
    def log_group_name(self) -> Optional[pulumi.Input[str]]:
        """
        AWS CloudWatch log group name.
        """
        return pulumi.get(self, "log_group_name")

    @log_group_name.setter
    def log_group_name(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "log_group_name", value)


@pulumi.input_type
class ServiceIntegrationEndpointExternalAwsCloudwatchMetricsUserConfigArgs:
    def __init__(__self__, *,
                 access_key: pulumi.Input[str],
                 namespace: pulumi.Input[str],
                 region: pulumi.Input[str],
                 secret_key: pulumi.Input[str]):
        """
        :param pulumi.Input[str] access_key: AWS access key. Required permissions are cloudwatch:PutMetricData.
        :param pulumi.Input[str] namespace: AWS CloudWatch Metrics Namespace.
        :param pulumi.Input[str] region: AWS region.
        :param pulumi.Input[str] secret_key: AWS secret key.
        """
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "secret_key", secret_key)

    @property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> pulumi.Input[str]:
        """
        AWS access key. Required permissions are cloudwatch:PutMetricData.
        """
        return pulumi.get(self, "access_key")

    @access_key.setter
    def access_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "access_key", value)

    @property
    @pulumi.getter
    def namespace(self) -> pulumi.Input[str]:
        """
        AWS CloudWatch Metrics Namespace.
        """
        return pulumi.get(self, "namespace")

    @namespace.setter
    def namespace(self, value: pulumi.Input[str]):
        pulumi.set(self, "namespace", value)

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

    @region.setter
    def region(self, value: pulumi.Input[str]):
        pulumi.set(self, "region", value)

    @property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> pulumi.Input[str]:
        """
        AWS secret key.
        """
        return pulumi.get(self, "secret_key")

    @secret_key.setter
    def secret_key(self, value: pulumi.Input[str]):
        pulumi.set(self, "secret_key", value)


@pulumi.input_type
class ServiceIntegrationEndpointExternalElasticsearchLogsUserConfigArgs:
    def __init__(__self__, *,
                 index_prefix: pulumi.Input[str],
                 url: pulumi.Input[str],
                 ca: Optional[pulumi.Input[str]] = None,
                 index_days_max: Optional[pulumi.Input[int]] = None,
                 timeout: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[str] index_prefix: Elasticsearch index prefix. The default value is `logs`.
        :param pulumi.Input[str] url: Elasticsearch connection URL.
        :param pulumi.Input[str] ca: PEM encoded CA certificate.
        :param pulumi.Input[int] index_days_max: Maximum number of days of logs to keep. The default value is `3`.
        :param pulumi.Input[float] timeout: Elasticsearch request timeout limit. The default value is `10.0`.
        """
        pulumi.set(__self__, "index_prefix", index_prefix)
        pulumi.set(__self__, "url", url)
        if ca is not None:
            pulumi.set(__self__, "ca", ca)
        if index_days_max is not None:
            pulumi.set(__self__, "index_days_max", index_days_max)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="indexPrefix")
    def index_prefix(self) -> pulumi.Input[str]:
        """
        Elasticsearch index prefix. The default value is `logs`.
        """
        return pulumi.get(self, "index_prefix")

    @index_prefix.setter
    def index_prefix(self, value: pulumi.Input[str]):
        pulumi.set(self, "index_prefix", value)

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[str]:
        """
        Elasticsearch connection URL.
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[str]):
        pulumi.set(self, "url", value)

    @property
    @pulumi.getter
    def ca(self) -> Optional[pulumi.Input[str]]:
        """
        PEM encoded CA certificate.
        """
        return pulumi.get(self, "ca")

    @ca.setter
    def ca(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ca", value)

    @property
    @pulumi.getter(name="indexDaysMax")
    def index_days_max(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum number of days of logs to keep. The default value is `3`.
        """
        return pulumi.get(self, "index_days_max")

    @index_days_max.setter
    def index_days_max(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "index_days_max", value)

    @property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input[float]]:
        """
        Elasticsearch request timeout limit. The default value is `10.0`.
        """
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "timeout", value)


@pulumi.input_type
class ServiceIntegrationEndpointExternalGoogleCloudLoggingUserConfigArgs:
    def __init__(__self__, *,
                 log_id: pulumi.Input[str],
                 project_id: pulumi.Input[str],
                 service_account_credentials: pulumi.Input[str]):
        """
        :param pulumi.Input[str] log_id: Google Cloud Logging log id.
        :param pulumi.Input[str] project_id: GCP project id.
        :param pulumi.Input[str] service_account_credentials: This is a JSON object with the fields documented in https://cloud.google.com/iam/docs/creating-managing-service-account-keys .
        """
        pulumi.set(__self__, "log_id", log_id)
        pulumi.set(__self__, "project_id", project_id)
        pulumi.set(__self__, "service_account_credentials", service_account_credentials)

    @property
    @pulumi.getter(name="logId")
    def log_id(self) -> pulumi.Input[str]:
        """
        Google Cloud Logging log id.
        """
        return pulumi.get(self, "log_id")

    @log_id.setter
    def log_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "log_id", value)

    @property
    @pulumi.getter(name="projectId")
    def project_id(self) -> pulumi.Input[str]:
        """
        GCP project id.
        """
        return pulumi.get(self, "project_id")

    @project_id.setter
    def project_id(self, value: pulumi.Input[str]):
        pulumi.set(self, "project_id", value)

    @property
    @pulumi.getter(name="serviceAccountCredentials")
    def service_account_credentials(self) -> pulumi.Input[str]:
        """
        This is a JSON object with the fields documented in https://cloud.google.com/iam/docs/creating-managing-service-account-keys .
        """
        return pulumi.get(self, "service_account_credentials")

    @service_account_credentials.setter
    def service_account_credentials(self, value: pulumi.Input[str]):
        pulumi.set(self, "service_account_credentials", value)


@pulumi.input_type
class ServiceIntegrationEndpointExternalKafkaUserConfigArgs:
    def __init__(__self__, *,
                 bootstrap_servers: pulumi.Input[str],
                 security_protocol: pulumi.Input[str],
                 sasl_mechanism: Optional[pulumi.Input[str]] = None,
                 sasl_plain_password: Optional[pulumi.Input[str]] = None,
                 sasl_plain_username: Optional[pulumi.Input[str]] = None,
                 ssl_ca_cert: Optional[pulumi.Input[str]] = None,
                 ssl_client_cert: Optional[pulumi.Input[str]] = None,
                 ssl_client_key: Optional[pulumi.Input[str]] = None,
                 ssl_endpoint_identification_algorithm: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] bootstrap_servers: Bootstrap servers.
        :param pulumi.Input[str] security_protocol: Security protocol.
        :param pulumi.Input[str] sasl_mechanism: SASL mechanism used for connections to the Kafka server.
        :param pulumi.Input[str] sasl_plain_password: Password for SASL PLAIN mechanism in the Kafka server.
        :param pulumi.Input[str] sasl_plain_username: Username for SASL PLAIN mechanism in the Kafka server.
        :param pulumi.Input[str] ssl_ca_cert: PEM-encoded CA certificate.
        :param pulumi.Input[str] ssl_client_cert: PEM-encoded client certificate.
        :param pulumi.Input[str] ssl_client_key: PEM-encoded client key.
        :param pulumi.Input[str] ssl_endpoint_identification_algorithm: The endpoint identification algorithm to validate server hostname using server certificate.
        """
        pulumi.set(__self__, "bootstrap_servers", bootstrap_servers)
        pulumi.set(__self__, "security_protocol", security_protocol)
        if sasl_mechanism is not None:
            pulumi.set(__self__, "sasl_mechanism", sasl_mechanism)
        if sasl_plain_password is not None:
            pulumi.set(__self__, "sasl_plain_password", sasl_plain_password)
        if sasl_plain_username is not None:
            pulumi.set(__self__, "sasl_plain_username", sasl_plain_username)
        if ssl_ca_cert is not None:
            pulumi.set(__self__, "ssl_ca_cert", ssl_ca_cert)
        if ssl_client_cert is not None:
            pulumi.set(__self__, "ssl_client_cert", ssl_client_cert)
        if ssl_client_key is not None:
            pulumi.set(__self__, "ssl_client_key", ssl_client_key)
        if ssl_endpoint_identification_algorithm is not None:
            pulumi.set(__self__, "ssl_endpoint_identification_algorithm", ssl_endpoint_identification_algorithm)

    @property
    @pulumi.getter(name="bootstrapServers")
    def bootstrap_servers(self) -> pulumi.Input[str]:
        """
        Bootstrap servers.
        """
        return pulumi.get(self, "bootstrap_servers")

    @bootstrap_servers.setter
    def bootstrap_servers(self, value: pulumi.Input[str]):
        pulumi.set(self, "bootstrap_servers", value)

    @property
    @pulumi.getter(name="securityProtocol")
    def security_protocol(self) -> pulumi.Input[str]:
        """
        Security protocol.
        """
        return pulumi.get(self, "security_protocol")

    @security_protocol.setter
    def security_protocol(self, value: pulumi.Input[str]):
        pulumi.set(self, "security_protocol", value)

    @property
    @pulumi.getter(name="saslMechanism")
    def sasl_mechanism(self) -> Optional[pulumi.Input[str]]:
        """
        SASL mechanism used for connections to the Kafka server.
        """
        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="saslPlainPassword")
    def sasl_plain_password(self) -> Optional[pulumi.Input[str]]:
        """
        Password for SASL PLAIN mechanism in the Kafka server.
        """
        return pulumi.get(self, "sasl_plain_password")

    @sasl_plain_password.setter
    def sasl_plain_password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sasl_plain_password", value)

    @property
    @pulumi.getter(name="saslPlainUsername")
    def sasl_plain_username(self) -> Optional[pulumi.Input[str]]:
        """
        Username for SASL PLAIN mechanism in the Kafka server.
        """
        return pulumi.get(self, "sasl_plain_username")

    @sasl_plain_username.setter
    def sasl_plain_username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sasl_plain_username", value)

    @property
    @pulumi.getter(name="sslCaCert")
    def ssl_ca_cert(self) -> Optional[pulumi.Input[str]]:
        """
        PEM-encoded CA certificate.
        """
        return pulumi.get(self, "ssl_ca_cert")

    @ssl_ca_cert.setter
    def ssl_ca_cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssl_ca_cert", value)

    @property
    @pulumi.getter(name="sslClientCert")
    def ssl_client_cert(self) -> Optional[pulumi.Input[str]]:
        """
        PEM-encoded client certificate.
        """
        return pulumi.get(self, "ssl_client_cert")

    @ssl_client_cert.setter
    def ssl_client_cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssl_client_cert", value)

    @property
    @pulumi.getter(name="sslClientKey")
    def ssl_client_key(self) -> Optional[pulumi.Input[str]]:
        """
        PEM-encoded client key.
        """
        return pulumi.get(self, "ssl_client_key")

    @ssl_client_key.setter
    def ssl_client_key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssl_client_key", value)

    @property
    @pulumi.getter(name="sslEndpointIdentificationAlgorithm")
    def ssl_endpoint_identification_algorithm(self) -> Optional[pulumi.Input[str]]:
        """
        The endpoint identification algorithm to validate server hostname using server certificate.
        """
        return pulumi.get(self, "ssl_endpoint_identification_algorithm")

    @ssl_endpoint_identification_algorithm.setter
    def ssl_endpoint_identification_algorithm(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ssl_endpoint_identification_algorithm", value)


@pulumi.input_type
class ServiceIntegrationEndpointExternalOpensearchLogsUserConfigArgs:
    def __init__(__self__, *,
                 index_prefix: pulumi.Input[str],
                 url: pulumi.Input[str],
                 ca: Optional[pulumi.Input[str]] = None,
                 index_days_max: Optional[pulumi.Input[int]] = None,
                 timeout: Optional[pulumi.Input[float]] = None):
        """
        :param pulumi.Input[str] index_prefix: OpenSearch index prefix. The default value is `logs`.
        :param pulumi.Input[str] url: OpenSearch connection URL.
        :param pulumi.Input[str] ca: PEM encoded CA certificate.
        :param pulumi.Input[int] index_days_max: Maximum number of days of logs to keep. The default value is `3`.
        :param pulumi.Input[float] timeout: OpenSearch request timeout limit. The default value is `10.0`.
        """
        pulumi.set(__self__, "index_prefix", index_prefix)
        pulumi.set(__self__, "url", url)
        if ca is not None:
            pulumi.set(__self__, "ca", ca)
        if index_days_max is not None:
            pulumi.set(__self__, "index_days_max", index_days_max)
        if timeout is not None:
            pulumi.set(__self__, "timeout", timeout)

    @property
    @pulumi.getter(name="indexPrefix")
    def index_prefix(self) -> pulumi.Input[str]:
        """
        OpenSearch index prefix. The default value is `logs`.
        """
        return pulumi.get(self, "index_prefix")

    @index_prefix.setter
    def index_prefix(self, value: pulumi.Input[str]):
        pulumi.set(self, "index_prefix", value)

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[str]:
        """
        OpenSearch connection URL.
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[str]):
        pulumi.set(self, "url", value)

    @property
    @pulumi.getter
    def ca(self) -> Optional[pulumi.Input[str]]:
        """
        PEM encoded CA certificate.
        """
        return pulumi.get(self, "ca")

    @ca.setter
    def ca(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ca", value)

    @property
    @pulumi.getter(name="indexDaysMax")
    def index_days_max(self) -> Optional[pulumi.Input[int]]:
        """
        Maximum number of days of logs to keep. The default value is `3`.
        """
        return pulumi.get(self, "index_days_max")

    @index_days_max.setter
    def index_days_max(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "index_days_max", value)

    @property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input[float]]:
        """
        OpenSearch request timeout limit. The default value is `10.0`.
        """
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input[float]]):
        pulumi.set(self, "timeout", value)


@pulumi.input_type
class ServiceIntegrationEndpointExternalSchemaRegistryUserConfigArgs:
    def __init__(__self__, *,
                 authentication: pulumi.Input[str],
                 url: pulumi.Input[str],
                 basic_auth_password: Optional[pulumi.Input[str]] = None,
                 basic_auth_username: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] authentication: Authentication method.
        :param pulumi.Input[str] url: Schema Registry URL.
        :param pulumi.Input[str] basic_auth_password: Basic authentication password.
        :param pulumi.Input[str] basic_auth_username: Basic authentication user name.
        """
        pulumi.set(__self__, "authentication", authentication)
        pulumi.set(__self__, "url", url)
        if basic_auth_password is not None:
            pulumi.set(__self__, "basic_auth_password", basic_auth_password)
        if basic_auth_username is not None:
            pulumi.set(__self__, "basic_auth_username", basic_auth_username)

    @property
    @pulumi.getter
    def authentication(self) -> pulumi.Input[str]:
        """
        Authentication method.
        """
        return pulumi.get(self, "authentication")

    @authentication.setter
    def authentication(self, value: pulumi.Input[str]):
        pulumi.set(self, "authentication", value)

    @property
    @pulumi.getter
    def url(self) -> pulumi.Input[str]:
        """
        Schema Registry URL.
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[str]):
        pulumi.set(self, "url", value)

    @property
    @pulumi.getter(name="basicAuthPassword")
    def basic_auth_password(self) -> Optional[pulumi.Input[str]]:
        """
        Basic authentication password.
        """
        return pulumi.get(self, "basic_auth_password")

    @basic_auth_password.setter
    def basic_auth_password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "basic_auth_password", value)

    @property
    @pulumi.getter(name="basicAuthUsername")
    def basic_auth_username(self) -> Optional[pulumi.Input[str]]:
        """
        Basic authentication user name.
        """
        return pulumi.get(self, "basic_auth_username")

    @basic_auth_username.setter
    def basic_auth_username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "basic_auth_username", value)


@pulumi.input_type
class ServiceIntegrationEndpointJolokiaUserConfigArgs:
    def __init__(__self__, *,
                 basic_auth_password: Optional[pulumi.Input[str]] = None,
                 basic_auth_username: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] basic_auth_password: Jolokia basic authentication password.
        :param pulumi.Input[str] basic_auth_username: Jolokia basic authentication username.
        """
        if basic_auth_password is not None:
            pulumi.set(__self__, "basic_auth_password", basic_auth_password)
        if basic_auth_username is not None:
            pulumi.set(__self__, "basic_auth_username", basic_auth_username)

    @property
    @pulumi.getter(name="basicAuthPassword")
    def basic_auth_password(self) -> Optional[pulumi.Input[str]]:
        """
        Jolokia basic authentication password.
        """
        return pulumi.get(self, "basic_auth_password")

    @basic_auth_password.setter
    def basic_auth_password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "basic_auth_password", value)

    @property
    @pulumi.getter(name="basicAuthUsername")
    def basic_auth_username(self) -> Optional[pulumi.Input[str]]:
        """
        Jolokia basic authentication username.
        """
        return pulumi.get(self, "basic_auth_username")

    @basic_auth_username.setter
    def basic_auth_username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "basic_auth_username", value)


@pulumi.input_type
class ServiceIntegrationEndpointPrometheusUserConfigArgs:
    def __init__(__self__, *,
                 basic_auth_password: Optional[pulumi.Input[str]] = None,
                 basic_auth_username: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] basic_auth_password: Prometheus basic authentication password.
        :param pulumi.Input[str] basic_auth_username: Prometheus basic authentication username.
        """
        if basic_auth_password is not None:
            pulumi.set(__self__, "basic_auth_password", basic_auth_password)
        if basic_auth_username is not None:
            pulumi.set(__self__, "basic_auth_username", basic_auth_username)

    @property
    @pulumi.getter(name="basicAuthPassword")
    def basic_auth_password(self) -> Optional[pulumi.Input[str]]:
        """
        Prometheus basic authentication password.
        """
        return pulumi.get(self, "basic_auth_password")

    @basic_auth_password.setter
    def basic_auth_password(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "basic_auth_password", value)

    @property
    @pulumi.getter(name="basicAuthUsername")
    def basic_auth_username(self) -> Optional[pulumi.Input[str]]:
        """
        Prometheus basic authentication username.
        """
        return pulumi.get(self, "basic_auth_username")

    @basic_auth_username.setter
    def basic_auth_username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "basic_auth_username", value)


@pulumi.input_type
class ServiceIntegrationEndpointRsyslogUserConfigArgs:
    def __init__(__self__, *,
                 format: pulumi.Input[str],
                 port: pulumi.Input[int],
                 server: pulumi.Input[str],
                 tls: pulumi.Input[bool],
                 ca: Optional[pulumi.Input[str]] = None,
                 cert: Optional[pulumi.Input[str]] = None,
                 key: Optional[pulumi.Input[str]] = None,
                 logline: Optional[pulumi.Input[str]] = None,
                 sd: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] format: message format. The default value is `rfc5424`.
        :param pulumi.Input[int] port: rsyslog server port. The default value is `514`.
        :param pulumi.Input[str] server: rsyslog server IP address or hostname.
        :param pulumi.Input[bool] tls: Require TLS. The default value is `true`.
        :param pulumi.Input[str] ca: PEM encoded CA certificate.
        :param pulumi.Input[str] cert: PEM encoded client certificate.
        :param pulumi.Input[str] key: PEM encoded client key.
        :param pulumi.Input[str] logline: custom syslog message format.
        :param pulumi.Input[str] sd: Structured data block for log message.
        """
        pulumi.set(__self__, "format", format)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "server", server)
        pulumi.set(__self__, "tls", tls)
        if ca is not None:
            pulumi.set(__self__, "ca", ca)
        if cert is not None:
            pulumi.set(__self__, "cert", cert)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if logline is not None:
            pulumi.set(__self__, "logline", logline)
        if sd is not None:
            pulumi.set(__self__, "sd", sd)

    @property
    @pulumi.getter
    def format(self) -> pulumi.Input[str]:
        """
        message format. The default value is `rfc5424`.
        """
        return pulumi.get(self, "format")

    @format.setter
    def format(self, value: pulumi.Input[str]):
        pulumi.set(self, "format", value)

    @property
    @pulumi.getter
    def port(self) -> pulumi.Input[int]:
        """
        rsyslog server port. The default value is `514`.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: pulumi.Input[int]):
        pulumi.set(self, "port", value)

    @property
    @pulumi.getter
    def server(self) -> pulumi.Input[str]:
        """
        rsyslog server IP address or hostname.
        """
        return pulumi.get(self, "server")

    @server.setter
    def server(self, value: pulumi.Input[str]):
        pulumi.set(self, "server", value)

    @property
    @pulumi.getter
    def tls(self) -> pulumi.Input[bool]:
        """
        Require TLS. The default value is `true`.
        """
        return pulumi.get(self, "tls")

    @tls.setter
    def tls(self, value: pulumi.Input[bool]):
        pulumi.set(self, "tls", value)

    @property
    @pulumi.getter
    def ca(self) -> Optional[pulumi.Input[str]]:
        """
        PEM encoded CA certificate.
        """
        return pulumi.get(self, "ca")

    @ca.setter
    def ca(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ca", value)

    @property
    @pulumi.getter
    def cert(self) -> Optional[pulumi.Input[str]]:
        """
        PEM encoded client certificate.
        """
        return pulumi.get(self, "cert")

    @cert.setter
    def cert(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cert", value)

    @property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[str]]:
        """
        PEM encoded client key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "key", value)

    @property
    @pulumi.getter
    def logline(self) -> Optional[pulumi.Input[str]]:
        """
        custom syslog message format.
        """
        return pulumi.get(self, "logline")

    @logline.setter
    def logline(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "logline", value)

    @property
    @pulumi.getter
    def sd(self) -> Optional[pulumi.Input[str]]:
        """
        Structured data block for log message.
        """
        return pulumi.get(self, "sd")

    @sd.setter
    def sd(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "sd", value)


@pulumi.input_type
class ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigArgs:
    def __init__(__self__, *,
                 dropped_metrics: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricArgs']]]] = None,
                 extra_metrics: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricArgs']]] dropped_metrics: Metrics to not send to AWS CloudWatch (takes precedence over extra*metrics).
        :param pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricArgs']]] extra_metrics: Metrics to allow through to AWS CloudWatch (in addition to default metrics).
        """
        if dropped_metrics is not None:
            pulumi.set(__self__, "dropped_metrics", dropped_metrics)
        if extra_metrics is not None:
            pulumi.set(__self__, "extra_metrics", extra_metrics)

    @property
    @pulumi.getter(name="droppedMetrics")
    def dropped_metrics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricArgs']]]]:
        """
        Metrics to not send to AWS CloudWatch (takes precedence over extra*metrics).
        """
        return pulumi.get(self, "dropped_metrics")

    @dropped_metrics.setter
    def dropped_metrics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricArgs']]]]):
        pulumi.set(self, "dropped_metrics", value)

    @property
    @pulumi.getter(name="extraMetrics")
    def extra_metrics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricArgs']]]]:
        """
        Metrics to allow through to AWS CloudWatch (in addition to default metrics).
        """
        return pulumi.get(self, "extra_metrics")

    @extra_metrics.setter
    def extra_metrics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricArgs']]]]):
        pulumi.set(self, "extra_metrics", value)


@pulumi.input_type
class ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricArgs:
    def __init__(__self__, *,
                 field: pulumi.Input[str],
                 metric: pulumi.Input[str]):
        pulumi.set(__self__, "field", field)
        pulumi.set(__self__, "metric", metric)

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

    @field.setter
    def field(self, value: pulumi.Input[str]):
        pulumi.set(self, "field", value)

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

    @metric.setter
    def metric(self, value: pulumi.Input[str]):
        pulumi.set(self, "metric", value)


@pulumi.input_type
class ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricArgs:
    def __init__(__self__, *,
                 field: pulumi.Input[str],
                 metric: pulumi.Input[str]):
        pulumi.set(__self__, "field", field)
        pulumi.set(__self__, "metric", metric)

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

    @field.setter
    def field(self, value: pulumi.Input[str]):
        pulumi.set(self, "field", value)

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

    @metric.setter
    def metric(self, value: pulumi.Input[str]):
        pulumi.set(self, "metric", value)


@pulumi.input_type
class ServiceIntegrationKafkaConnectUserConfigArgs:
    def __init__(__self__, *,
                 kafka_connect: Optional[pulumi.Input['ServiceIntegrationKafkaConnectUserConfigKafkaConnectArgs']] = None):
        """
        :param pulumi.Input['ServiceIntegrationKafkaConnectUserConfigKafkaConnectArgs'] kafka_connect: Kafka Connect service configuration values.
        """
        if kafka_connect is not None:
            pulumi.set(__self__, "kafka_connect", kafka_connect)

    @property
    @pulumi.getter(name="kafkaConnect")
    def kafka_connect(self) -> Optional[pulumi.Input['ServiceIntegrationKafkaConnectUserConfigKafkaConnectArgs']]:
        """
        Kafka Connect service configuration values.
        """
        return pulumi.get(self, "kafka_connect")

    @kafka_connect.setter
    def kafka_connect(self, value: Optional[pulumi.Input['ServiceIntegrationKafkaConnectUserConfigKafkaConnectArgs']]):
        pulumi.set(self, "kafka_connect", value)


@pulumi.input_type
class ServiceIntegrationKafkaConnectUserConfigKafkaConnectArgs:
    def __init__(__self__, *,
                 config_storage_topic: Optional[pulumi.Input[str]] = None,
                 group_id: Optional[pulumi.Input[str]] = None,
                 offset_storage_topic: Optional[pulumi.Input[str]] = None,
                 status_storage_topic: Optional[pulumi.Input[str]] = None):
        if config_storage_topic is not None:
            pulumi.set(__self__, "config_storage_topic", config_storage_topic)
        if group_id is not None:
            pulumi.set(__self__, "group_id", group_id)
        if offset_storage_topic is not None:
            pulumi.set(__self__, "offset_storage_topic", offset_storage_topic)
        if status_storage_topic is not None:
            pulumi.set(__self__, "status_storage_topic", status_storage_topic)

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

    @config_storage_topic.setter
    def config_storage_topic(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "config_storage_topic", value)

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

    @group_id.setter
    def group_id(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "group_id", value)

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

    @offset_storage_topic.setter
    def offset_storage_topic(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "offset_storage_topic", value)

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

    @status_storage_topic.setter
    def status_storage_topic(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "status_storage_topic", value)


@pulumi.input_type
class ServiceIntegrationKafkaLogsUserConfigArgs:
    def __init__(__self__, *,
                 kafka_topic: pulumi.Input[str],
                 selected_log_fields: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[str] kafka_topic: Topic name.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] selected_log_fields: The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
        """
        pulumi.set(__self__, "kafka_topic", kafka_topic)
        if selected_log_fields is not None:
            pulumi.set(__self__, "selected_log_fields", selected_log_fields)

    @property
    @pulumi.getter(name="kafkaTopic")
    def kafka_topic(self) -> pulumi.Input[str]:
        """
        Topic name.
        """
        return pulumi.get(self, "kafka_topic")

    @kafka_topic.setter
    def kafka_topic(self, value: pulumi.Input[str]):
        pulumi.set(self, "kafka_topic", value)

    @property
    @pulumi.getter(name="selectedLogFields")
    def selected_log_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
        """
        return pulumi.get(self, "selected_log_fields")

    @selected_log_fields.setter
    def selected_log_fields(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "selected_log_fields", value)


@pulumi.input_type
class ServiceIntegrationKafkaMirrormakerUserConfigArgs:
    def __init__(__self__, *,
                 cluster_alias: Optional[pulumi.Input[str]] = None,
                 kafka_mirrormaker: Optional[pulumi.Input['ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgs']] = None):
        """
        :param pulumi.Input[str] cluster_alias: The alias under which the Kafka cluster is known to MirrorMaker. Can contain the following symbols: ASCII alphanumerics, '.', '_', and '-'.
        :param pulumi.Input['ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgs'] kafka_mirrormaker: Kafka MirrorMaker configuration values.
        """
        if cluster_alias is not None:
            pulumi.set(__self__, "cluster_alias", cluster_alias)
        if kafka_mirrormaker is not None:
            pulumi.set(__self__, "kafka_mirrormaker", kafka_mirrormaker)

    @property
    @pulumi.getter(name="clusterAlias")
    def cluster_alias(self) -> Optional[pulumi.Input[str]]:
        """
        The alias under which the Kafka cluster is known to MirrorMaker. Can contain the following symbols: ASCII alphanumerics, '.', '_', and '-'.
        """
        return pulumi.get(self, "cluster_alias")

    @cluster_alias.setter
    def cluster_alias(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "cluster_alias", value)

    @property
    @pulumi.getter(name="kafkaMirrormaker")
    def kafka_mirrormaker(self) -> Optional[pulumi.Input['ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgs']]:
        """
        Kafka MirrorMaker configuration values.
        """
        return pulumi.get(self, "kafka_mirrormaker")

    @kafka_mirrormaker.setter
    def kafka_mirrormaker(self, value: Optional[pulumi.Input['ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgs']]):
        pulumi.set(self, "kafka_mirrormaker", value)


@pulumi.input_type
class ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgs:
    def __init__(__self__, *,
                 consumer_fetch_min_bytes: Optional[pulumi.Input[int]] = None,
                 producer_batch_size: Optional[pulumi.Input[int]] = None,
                 producer_buffer_memory: Optional[pulumi.Input[int]] = None,
                 producer_compression_type: Optional[pulumi.Input[str]] = None,
                 producer_linger_ms: Optional[pulumi.Input[int]] = None,
                 producer_max_request_size: Optional[pulumi.Input[int]] = None):
        if consumer_fetch_min_bytes is not None:
            pulumi.set(__self__, "consumer_fetch_min_bytes", consumer_fetch_min_bytes)
        if producer_batch_size is not None:
            pulumi.set(__self__, "producer_batch_size", producer_batch_size)
        if producer_buffer_memory is not None:
            pulumi.set(__self__, "producer_buffer_memory", producer_buffer_memory)
        if producer_compression_type is not None:
            pulumi.set(__self__, "producer_compression_type", producer_compression_type)
        if producer_linger_ms is not None:
            pulumi.set(__self__, "producer_linger_ms", producer_linger_ms)
        if producer_max_request_size is not None:
            pulumi.set(__self__, "producer_max_request_size", producer_max_request_size)

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

    @consumer_fetch_min_bytes.setter
    def consumer_fetch_min_bytes(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "consumer_fetch_min_bytes", value)

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

    @producer_batch_size.setter
    def producer_batch_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "producer_batch_size", value)

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

    @producer_buffer_memory.setter
    def producer_buffer_memory(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "producer_buffer_memory", value)

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

    @producer_compression_type.setter
    def producer_compression_type(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "producer_compression_type", value)

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

    @producer_linger_ms.setter
    def producer_linger_ms(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "producer_linger_ms", value)

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

    @producer_max_request_size.setter
    def producer_max_request_size(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "producer_max_request_size", value)


@pulumi.input_type
class ServiceIntegrationLogsUserConfigArgs:
    def __init__(__self__, *,
                 elasticsearch_index_days_max: Optional[pulumi.Input[int]] = None,
                 elasticsearch_index_prefix: Optional[pulumi.Input[str]] = None,
                 selected_log_fields: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
        """
        :param pulumi.Input[int] elasticsearch_index_days_max: Elasticsearch index retention limit. The default value is `3`.
        :param pulumi.Input[str] elasticsearch_index_prefix: Elasticsearch index prefix. The default value is `logs`.
        :param pulumi.Input[Sequence[pulumi.Input[str]]] selected_log_fields: The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
        """
        if elasticsearch_index_days_max is not None:
            pulumi.set(__self__, "elasticsearch_index_days_max", elasticsearch_index_days_max)
        if elasticsearch_index_prefix is not None:
            pulumi.set(__self__, "elasticsearch_index_prefix", elasticsearch_index_prefix)
        if selected_log_fields is not None:
            pulumi.set(__self__, "selected_log_fields", selected_log_fields)

    @property
    @pulumi.getter(name="elasticsearchIndexDaysMax")
    def elasticsearch_index_days_max(self) -> Optional[pulumi.Input[int]]:
        """
        Elasticsearch index retention limit. The default value is `3`.
        """
        return pulumi.get(self, "elasticsearch_index_days_max")

    @elasticsearch_index_days_max.setter
    def elasticsearch_index_days_max(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "elasticsearch_index_days_max", value)

    @property
    @pulumi.getter(name="elasticsearchIndexPrefix")
    def elasticsearch_index_prefix(self) -> Optional[pulumi.Input[str]]:
        """
        Elasticsearch index prefix. The default value is `logs`.
        """
        return pulumi.get(self, "elasticsearch_index_prefix")

    @elasticsearch_index_prefix.setter
    def elasticsearch_index_prefix(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "elasticsearch_index_prefix", value)

    @property
    @pulumi.getter(name="selectedLogFields")
    def selected_log_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
        """
        The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
        """
        return pulumi.get(self, "selected_log_fields")

    @selected_log_fields.setter
    def selected_log_fields(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
        pulumi.set(self, "selected_log_fields", value)


@pulumi.input_type
class ServiceIntegrationMetricsUserConfigArgs:
    def __init__(__self__, *,
                 database: Optional[pulumi.Input[str]] = None,
                 retention_days: Optional[pulumi.Input[int]] = None,
                 ro_username: Optional[pulumi.Input[str]] = None,
                 source_mysql: Optional[pulumi.Input['ServiceIntegrationMetricsUserConfigSourceMysqlArgs']] = None,
                 username: Optional[pulumi.Input[str]] = None):
        """
        :param pulumi.Input[str] database: Name of the database where to store metric datapoints. Only affects PostgreSQL destinations. Defaults to 'metrics'. Note that this must be the same for all metrics integrations that write data to the same PostgreSQL service.
        :param pulumi.Input[int] retention_days: Number of days to keep old metrics. Only affects PostgreSQL destinations. Set to 0 for no automatic cleanup. Defaults to 30 days.
        :param pulumi.Input[str] ro_username: Name of a user that can be used to read metrics. This will be used for Grafana integration (if enabled) to prevent Grafana users from making undesired changes. Only affects PostgreSQL destinations. Defaults to 'metrics_reader'. Note that this must be the same for all metrics integrations that write data to the same PostgreSQL service.
        :param pulumi.Input['ServiceIntegrationMetricsUserConfigSourceMysqlArgs'] source_mysql: Configuration options for metrics where source service is MySQL.
        :param pulumi.Input[str] username: Name of the user used to write metrics. Only affects PostgreSQL destinations. Defaults to 'metrics_writer'. Note that this must be the same for all metrics integrations that write data to the same PostgreSQL service.
        """
        if database is not None:
            pulumi.set(__self__, "database", database)
        if retention_days is not None:
            pulumi.set(__self__, "retention_days", retention_days)
        if ro_username is not None:
            pulumi.set(__self__, "ro_username", ro_username)
        if source_mysql is not None:
            pulumi.set(__self__, "source_mysql", source_mysql)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @property
    @pulumi.getter
    def database(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the database where to store metric datapoints. Only affects PostgreSQL destinations. Defaults to 'metrics'. Note that this must be the same for all metrics integrations that write data to the same PostgreSQL service.
        """
        return pulumi.get(self, "database")

    @database.setter
    def database(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "database", value)

    @property
    @pulumi.getter(name="retentionDays")
    def retention_days(self) -> Optional[pulumi.Input[int]]:
        """
        Number of days to keep old metrics. Only affects PostgreSQL destinations. Set to 0 for no automatic cleanup. Defaults to 30 days.
        """
        return pulumi.get(self, "retention_days")

    @retention_days.setter
    def retention_days(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "retention_days", value)

    @property
    @pulumi.getter(name="roUsername")
    def ro_username(self) -> Optional[pulumi.Input[str]]:
        """
        Name of a user that can be used to read metrics. This will be used for Grafana integration (if enabled) to prevent Grafana users from making undesired changes. Only affects PostgreSQL destinations. Defaults to 'metrics_reader'. Note that this must be the same for all metrics integrations that write data to the same PostgreSQL service.
        """
        return pulumi.get(self, "ro_username")

    @ro_username.setter
    def ro_username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "ro_username", value)

    @property
    @pulumi.getter(name="sourceMysql")
    def source_mysql(self) -> Optional[pulumi.Input['ServiceIntegrationMetricsUserConfigSourceMysqlArgs']]:
        """
        Configuration options for metrics where source service is MySQL.
        """
        return pulumi.get(self, "source_mysql")

    @source_mysql.setter
    def source_mysql(self, value: Optional[pulumi.Input['ServiceIntegrationMetricsUserConfigSourceMysqlArgs']]):
        pulumi.set(self, "source_mysql", value)

    @property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[str]]:
        """
        Name of the user used to write metrics. Only affects PostgreSQL destinations. Defaults to 'metrics_writer'. Note that this must be the same for all metrics integrations that write data to the same PostgreSQL service.
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[str]]):
        pulumi.set(self, "username", value)


@pulumi.input_type
class ServiceIntegrationMetricsUserConfigSourceMysqlArgs:
    def __init__(__self__, *,
                 telegraf: Optional[pulumi.Input['ServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgs']] = None):
        if telegraf is not None:
            pulumi.set(__self__, "telegraf", telegraf)

    @property
    @pulumi.getter
    def telegraf(self) -> Optional[pulumi.Input['ServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgs']]:
        return pulumi.get(self, "telegraf")

    @telegraf.setter
    def telegraf(self, value: Optional[pulumi.Input['ServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgs']]):
        pulumi.set(self, "telegraf", value)


@pulumi.input_type
class ServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgs:
    def __init__(__self__, *,
                 gather_event_waits: Optional[pulumi.Input[bool]] = None,
                 gather_file_events_stats: Optional[pulumi.Input[bool]] = None,
                 gather_index_io_waits: Optional[pulumi.Input[bool]] = None,
                 gather_info_schema_auto_inc: Optional[pulumi.Input[bool]] = None,
                 gather_innodb_metrics: Optional[pulumi.Input[bool]] = None,
                 gather_perf_events_statements: Optional[pulumi.Input[bool]] = None,
                 gather_process_list: Optional[pulumi.Input[bool]] = None,
                 gather_slave_status: Optional[pulumi.Input[bool]] = None,
                 gather_table_io_waits: Optional[pulumi.Input[bool]] = None,
                 gather_table_lock_waits: Optional[pulumi.Input[bool]] = None,
                 gather_table_schema: Optional[pulumi.Input[bool]] = None,
                 perf_events_statements_digest_text_limit: Optional[pulumi.Input[int]] = None,
                 perf_events_statements_limit: Optional[pulumi.Input[int]] = None,
                 perf_events_statements_time_limit: Optional[pulumi.Input[int]] = None):
        if gather_event_waits is not None:
            pulumi.set(__self__, "gather_event_waits", gather_event_waits)
        if gather_file_events_stats is not None:
            pulumi.set(__self__, "gather_file_events_stats", gather_file_events_stats)
        if gather_index_io_waits is not None:
            pulumi.set(__self__, "gather_index_io_waits", gather_index_io_waits)
        if gather_info_schema_auto_inc is not None:
            pulumi.set(__self__, "gather_info_schema_auto_inc", gather_info_schema_auto_inc)
        if gather_innodb_metrics is not None:
            pulumi.set(__self__, "gather_innodb_metrics", gather_innodb_metrics)
        if gather_perf_events_statements is not None:
            pulumi.set(__self__, "gather_perf_events_statements", gather_perf_events_statements)
        if gather_process_list is not None:
            pulumi.set(__self__, "gather_process_list", gather_process_list)
        if gather_slave_status is not None:
            pulumi.set(__self__, "gather_slave_status", gather_slave_status)
        if gather_table_io_waits is not None:
            pulumi.set(__self__, "gather_table_io_waits", gather_table_io_waits)
        if gather_table_lock_waits is not None:
            pulumi.set(__self__, "gather_table_lock_waits", gather_table_lock_waits)
        if gather_table_schema is not None:
            pulumi.set(__self__, "gather_table_schema", gather_table_schema)
        if perf_events_statements_digest_text_limit is not None:
            pulumi.set(__self__, "perf_events_statements_digest_text_limit", perf_events_statements_digest_text_limit)
        if perf_events_statements_limit is not None:
            pulumi.set(__self__, "perf_events_statements_limit", perf_events_statements_limit)
        if perf_events_statements_time_limit is not None:
            pulumi.set(__self__, "perf_events_statements_time_limit", perf_events_statements_time_limit)

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

    @gather_event_waits.setter
    def gather_event_waits(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "gather_event_waits", value)

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

    @gather_file_events_stats.setter
    def gather_file_events_stats(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "gather_file_events_stats", value)

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

    @gather_index_io_waits.setter
    def gather_index_io_waits(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "gather_index_io_waits", value)

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

    @gather_info_schema_auto_inc.setter
    def gather_info_schema_auto_inc(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "gather_info_schema_auto_inc", value)

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

    @gather_innodb_metrics.setter
    def gather_innodb_metrics(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "gather_innodb_metrics", value)

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

    @gather_perf_events_statements.setter
    def gather_perf_events_statements(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "gather_perf_events_statements", value)

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

    @gather_process_list.setter
    def gather_process_list(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "gather_process_list", value)

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

    @gather_slave_status.setter
    def gather_slave_status(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "gather_slave_status", value)

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

    @gather_table_io_waits.setter
    def gather_table_io_waits(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "gather_table_io_waits", value)

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

    @gather_table_lock_waits.setter
    def gather_table_lock_waits(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "gather_table_lock_waits", value)

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

    @gather_table_schema.setter
    def gather_table_schema(self, value: Optional[pulumi.Input[bool]]):
        pulumi.set(self, "gather_table_schema", value)

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

    @perf_events_statements_digest_text_limit.setter
    def perf_events_statements_digest_text_limit(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "perf_events_statements_digest_text_limit", value)

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

    @perf_events_statements_limit.setter
    def perf_events_statements_limit(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "perf_events_statements_limit", value)

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

    @perf_events_statements_time_limit.setter
    def perf_events_statements_time_limit(self, value: Optional[pulumi.Input[int]]):
        pulumi.set(self, "perf_events_statements_time_limit", value)


