# coding=utf-8
# *** WARNING: this file was generated by pulumi-language-python. ***
# *** Do not edit by hand unless you're certain you know what you are doing! ***

import builtins as _builtins
import warnings
import sys
import pulumi
import pulumi.runtime
from typing import Any, Mapping, Optional, Sequence, Union, overload
if sys.version_info >= (3, 11):
    from typing import NotRequired, TypedDict, TypeAlias
else:
    from typing_extensions import NotRequired, TypedDict, TypeAlias
from . import _utilities

__all__ = [
    'AccountAuthenticationSamlFieldMappingArgs',
    'AccountAuthenticationSamlFieldMappingArgsDict',
    'AlloydbomniAlloydbomniArgs',
    'AlloydbomniAlloydbomniArgsDict',
    'AlloydbomniAlloydbomniParamArgs',
    'AlloydbomniAlloydbomniParamArgsDict',
    'AlloydbomniAlloydbomniUserConfigArgs',
    'AlloydbomniAlloydbomniUserConfigArgsDict',
    'AlloydbomniAlloydbomniUserConfigIpFilterObjectArgs',
    'AlloydbomniAlloydbomniUserConfigIpFilterObjectArgsDict',
    'AlloydbomniAlloydbomniUserConfigPgArgs',
    'AlloydbomniAlloydbomniUserConfigPgArgsDict',
    'AlloydbomniAlloydbomniUserConfigPgauditArgs',
    'AlloydbomniAlloydbomniUserConfigPgauditArgsDict',
    'AlloydbomniAlloydbomniUserConfigPgbouncerArgs',
    'AlloydbomniAlloydbomniUserConfigPgbouncerArgsDict',
    'AlloydbomniAlloydbomniUserConfigPglookoutArgs',
    'AlloydbomniAlloydbomniUserConfigPglookoutArgsDict',
    'AlloydbomniAlloydbomniUserConfigPrivateAccessArgs',
    'AlloydbomniAlloydbomniUserConfigPrivateAccessArgsDict',
    'AlloydbomniAlloydbomniUserConfigPrivatelinkAccessArgs',
    'AlloydbomniAlloydbomniUserConfigPrivatelinkAccessArgsDict',
    'AlloydbomniAlloydbomniUserConfigPublicAccessArgs',
    'AlloydbomniAlloydbomniUserConfigPublicAccessArgsDict',
    'AlloydbomniComponentArgs',
    'AlloydbomniComponentArgsDict',
    'AlloydbomniServiceIntegrationArgs',
    'AlloydbomniServiceIntegrationArgsDict',
    'AlloydbomniTagArgs',
    'AlloydbomniTagArgsDict',
    'AlloydbomniTechEmailArgs',
    'AlloydbomniTechEmailArgsDict',
    'BillingGroupTimeoutsArgs',
    'BillingGroupTimeoutsArgsDict',
    'CassandraCassandraArgs',
    'CassandraCassandraArgsDict',
    'CassandraCassandraUserConfigArgs',
    'CassandraCassandraUserConfigArgsDict',
    'CassandraCassandraUserConfigCassandraArgs',
    'CassandraCassandraUserConfigCassandraArgsDict',
    'CassandraCassandraUserConfigIpFilterObjectArgs',
    'CassandraCassandraUserConfigIpFilterObjectArgsDict',
    'CassandraCassandraUserConfigPrivateAccessArgs',
    'CassandraCassandraUserConfigPrivateAccessArgsDict',
    'CassandraCassandraUserConfigPublicAccessArgs',
    'CassandraCassandraUserConfigPublicAccessArgsDict',
    'CassandraComponentArgs',
    'CassandraComponentArgsDict',
    'CassandraServiceIntegrationArgs',
    'CassandraServiceIntegrationArgsDict',
    'CassandraTagArgs',
    'CassandraTagArgsDict',
    'CassandraTechEmailArgs',
    'CassandraTechEmailArgsDict',
    'ClickhouseClickhouseArgs',
    'ClickhouseClickhouseArgsDict',
    'ClickhouseClickhouseUserConfigArgs',
    'ClickhouseClickhouseUserConfigArgsDict',
    'ClickhouseClickhouseUserConfigIpFilterObjectArgs',
    'ClickhouseClickhouseUserConfigIpFilterObjectArgsDict',
    'ClickhouseClickhouseUserConfigPrivateAccessArgs',
    'ClickhouseClickhouseUserConfigPrivateAccessArgsDict',
    'ClickhouseClickhouseUserConfigPrivatelinkAccessArgs',
    'ClickhouseClickhouseUserConfigPrivatelinkAccessArgsDict',
    'ClickhouseClickhouseUserConfigPublicAccessArgs',
    'ClickhouseClickhouseUserConfigPublicAccessArgsDict',
    'ClickhouseComponentArgs',
    'ClickhouseComponentArgsDict',
    'ClickhouseGrantPrivilegeGrantArgs',
    'ClickhouseGrantPrivilegeGrantArgsDict',
    'ClickhouseGrantRoleGrantArgs',
    'ClickhouseGrantRoleGrantArgsDict',
    'ClickhouseServiceIntegrationArgs',
    'ClickhouseServiceIntegrationArgsDict',
    'ClickhouseTagArgs',
    'ClickhouseTagArgsDict',
    'ClickhouseTechEmailArgs',
    'ClickhouseTechEmailArgsDict',
    'DragonflyComponentArgs',
    'DragonflyComponentArgsDict',
    'DragonflyDragonflyArgs',
    'DragonflyDragonflyArgsDict',
    'DragonflyDragonflyUserConfigArgs',
    'DragonflyDragonflyUserConfigArgsDict',
    'DragonflyDragonflyUserConfigIpFilterObjectArgs',
    'DragonflyDragonflyUserConfigIpFilterObjectArgsDict',
    'DragonflyDragonflyUserConfigMigrationArgs',
    'DragonflyDragonflyUserConfigMigrationArgsDict',
    'DragonflyDragonflyUserConfigPrivateAccessArgs',
    'DragonflyDragonflyUserConfigPrivateAccessArgsDict',
    'DragonflyDragonflyUserConfigPrivatelinkAccessArgs',
    'DragonflyDragonflyUserConfigPrivatelinkAccessArgsDict',
    'DragonflyDragonflyUserConfigPublicAccessArgs',
    'DragonflyDragonflyUserConfigPublicAccessArgsDict',
    'DragonflyServiceIntegrationArgs',
    'DragonflyServiceIntegrationArgsDict',
    'DragonflyTagArgs',
    'DragonflyTagArgsDict',
    'DragonflyTechEmailArgs',
    'DragonflyTechEmailArgsDict',
    'FlinkApplicationVersionSinkArgs',
    'FlinkApplicationVersionSinkArgsDict',
    'FlinkApplicationVersionSourceArgs',
    'FlinkApplicationVersionSourceArgsDict',
    'FlinkComponentArgs',
    'FlinkComponentArgsDict',
    'FlinkFlinkArgs',
    'FlinkFlinkArgsDict',
    'FlinkFlinkUserConfigArgs',
    'FlinkFlinkUserConfigArgsDict',
    'FlinkFlinkUserConfigIpFilterObjectArgs',
    'FlinkFlinkUserConfigIpFilterObjectArgsDict',
    'FlinkFlinkUserConfigPrivatelinkAccessArgs',
    'FlinkFlinkUserConfigPrivatelinkAccessArgsDict',
    'FlinkFlinkUserConfigPublicAccessArgs',
    'FlinkFlinkUserConfigPublicAccessArgsDict',
    'FlinkJarApplicationApplicationVersionArgs',
    'FlinkJarApplicationApplicationVersionArgsDict',
    'FlinkJarApplicationApplicationVersionFileInfoArgs',
    'FlinkJarApplicationApplicationVersionFileInfoArgsDict',
    'FlinkJarApplicationCurrentDeploymentArgs',
    'FlinkJarApplicationCurrentDeploymentArgsDict',
    'FlinkJarApplicationVersionFileInfoArgs',
    'FlinkJarApplicationVersionFileInfoArgsDict',
    'FlinkServiceIntegrationArgs',
    'FlinkServiceIntegrationArgsDict',
    'FlinkTagArgs',
    'FlinkTagArgsDict',
    'FlinkTechEmailArgs',
    'FlinkTechEmailArgsDict',
    'GovernanceAccessAccessDataArgs',
    'GovernanceAccessAccessDataArgsDict',
    'GovernanceAccessAccessDataAclArgs',
    'GovernanceAccessAccessDataAclArgsDict',
    'GovernanceAccessTimeoutsArgs',
    'GovernanceAccessTimeoutsArgsDict',
    'GrafanaComponentArgs',
    'GrafanaComponentArgsDict',
    'GrafanaGrafanaArgs',
    'GrafanaGrafanaArgsDict',
    'GrafanaGrafanaUserConfigArgs',
    'GrafanaGrafanaUserConfigArgsDict',
    'GrafanaGrafanaUserConfigAuthAzureadArgs',
    'GrafanaGrafanaUserConfigAuthAzureadArgsDict',
    'GrafanaGrafanaUserConfigAuthGenericOauthArgs',
    'GrafanaGrafanaUserConfigAuthGenericOauthArgsDict',
    'GrafanaGrafanaUserConfigAuthGithubArgs',
    'GrafanaGrafanaUserConfigAuthGithubArgsDict',
    'GrafanaGrafanaUserConfigAuthGitlabArgs',
    'GrafanaGrafanaUserConfigAuthGitlabArgsDict',
    'GrafanaGrafanaUserConfigAuthGoogleArgs',
    'GrafanaGrafanaUserConfigAuthGoogleArgsDict',
    'GrafanaGrafanaUserConfigDateFormatsArgs',
    'GrafanaGrafanaUserConfigDateFormatsArgsDict',
    'GrafanaGrafanaUserConfigExternalImageStorageArgs',
    'GrafanaGrafanaUserConfigExternalImageStorageArgsDict',
    'GrafanaGrafanaUserConfigIpFilterObjectArgs',
    'GrafanaGrafanaUserConfigIpFilterObjectArgsDict',
    'GrafanaGrafanaUserConfigPrivateAccessArgs',
    'GrafanaGrafanaUserConfigPrivateAccessArgsDict',
    'GrafanaGrafanaUserConfigPrivatelinkAccessArgs',
    'GrafanaGrafanaUserConfigPrivatelinkAccessArgsDict',
    'GrafanaGrafanaUserConfigPublicAccessArgs',
    'GrafanaGrafanaUserConfigPublicAccessArgsDict',
    'GrafanaGrafanaUserConfigSmtpServerArgs',
    'GrafanaGrafanaUserConfigSmtpServerArgsDict',
    'GrafanaServiceIntegrationArgs',
    'GrafanaServiceIntegrationArgsDict',
    'GrafanaTagArgs',
    'GrafanaTagArgsDict',
    'GrafanaTechEmailArgs',
    'GrafanaTechEmailArgsDict',
    'InfluxDbComponentArgs',
    'InfluxDbComponentArgsDict',
    'InfluxDbInfluxdbArgs',
    'InfluxDbInfluxdbArgsDict',
    'InfluxDbInfluxdbUserConfigArgs',
    'InfluxDbInfluxdbUserConfigArgsDict',
    'InfluxDbInfluxdbUserConfigInfluxdbArgs',
    'InfluxDbInfluxdbUserConfigInfluxdbArgsDict',
    'InfluxDbInfluxdbUserConfigIpFilterObjectArgs',
    'InfluxDbInfluxdbUserConfigIpFilterObjectArgsDict',
    'InfluxDbInfluxdbUserConfigPrivateAccessArgs',
    'InfluxDbInfluxdbUserConfigPrivateAccessArgsDict',
    'InfluxDbInfluxdbUserConfigPrivatelinkAccessArgs',
    'InfluxDbInfluxdbUserConfigPrivatelinkAccessArgsDict',
    'InfluxDbInfluxdbUserConfigPublicAccessArgs',
    'InfluxDbInfluxdbUserConfigPublicAccessArgsDict',
    'InfluxDbServiceIntegrationArgs',
    'InfluxDbServiceIntegrationArgsDict',
    'InfluxDbTagArgs',
    'InfluxDbTagArgsDict',
    'InfluxDbTechEmailArgs',
    'InfluxDbTechEmailArgsDict',
    'KafkaComponentArgs',
    'KafkaComponentArgsDict',
    'KafkaConnectComponentArgs',
    'KafkaConnectComponentArgsDict',
    'KafkaConnectKafkaConnectUserConfigArgs',
    'KafkaConnectKafkaConnectUserConfigArgsDict',
    'KafkaConnectKafkaConnectUserConfigIpFilterObjectArgs',
    'KafkaConnectKafkaConnectUserConfigIpFilterObjectArgsDict',
    'KafkaConnectKafkaConnectUserConfigKafkaConnectArgs',
    'KafkaConnectKafkaConnectUserConfigKafkaConnectArgsDict',
    'KafkaConnectKafkaConnectUserConfigPluginVersionArgs',
    'KafkaConnectKafkaConnectUserConfigPluginVersionArgsDict',
    'KafkaConnectKafkaConnectUserConfigPrivateAccessArgs',
    'KafkaConnectKafkaConnectUserConfigPrivateAccessArgsDict',
    'KafkaConnectKafkaConnectUserConfigPrivatelinkAccessArgs',
    'KafkaConnectKafkaConnectUserConfigPrivatelinkAccessArgsDict',
    'KafkaConnectKafkaConnectUserConfigPublicAccessArgs',
    'KafkaConnectKafkaConnectUserConfigPublicAccessArgsDict',
    'KafkaConnectKafkaConnectUserConfigSecretProviderArgs',
    'KafkaConnectKafkaConnectUserConfigSecretProviderArgsDict',
    'KafkaConnectKafkaConnectUserConfigSecretProviderAwsArgs',
    'KafkaConnectKafkaConnectUserConfigSecretProviderAwsArgsDict',
    'KafkaConnectKafkaConnectUserConfigSecretProviderVaultArgs',
    'KafkaConnectKafkaConnectUserConfigSecretProviderVaultArgsDict',
    'KafkaConnectServiceIntegrationArgs',
    'KafkaConnectServiceIntegrationArgsDict',
    'KafkaConnectTagArgs',
    'KafkaConnectTagArgsDict',
    'KafkaConnectTechEmailArgs',
    'KafkaConnectTechEmailArgsDict',
    'KafkaConnectorTaskArgs',
    'KafkaConnectorTaskArgsDict',
    'KafkaKafkaArgs',
    'KafkaKafkaArgsDict',
    'KafkaKafkaUserConfigArgs',
    'KafkaKafkaUserConfigArgsDict',
    'KafkaKafkaUserConfigFollowerFetchingArgs',
    'KafkaKafkaUserConfigFollowerFetchingArgsDict',
    'KafkaKafkaUserConfigIpFilterObjectArgs',
    'KafkaKafkaUserConfigIpFilterObjectArgsDict',
    'KafkaKafkaUserConfigKafkaArgs',
    'KafkaKafkaUserConfigKafkaArgsDict',
    'KafkaKafkaUserConfigKafkaAuthenticationMethodsArgs',
    'KafkaKafkaUserConfigKafkaAuthenticationMethodsArgsDict',
    'KafkaKafkaUserConfigKafkaConnectConfigArgs',
    'KafkaKafkaUserConfigKafkaConnectConfigArgsDict',
    'KafkaKafkaUserConfigKafkaConnectPluginVersionArgs',
    'KafkaKafkaUserConfigKafkaConnectPluginVersionArgsDict',
    'KafkaKafkaUserConfigKafkaConnectSecretProviderArgs',
    'KafkaKafkaUserConfigKafkaConnectSecretProviderArgsDict',
    'KafkaKafkaUserConfigKafkaConnectSecretProviderAwsArgs',
    'KafkaKafkaUserConfigKafkaConnectSecretProviderAwsArgsDict',
    'KafkaKafkaUserConfigKafkaConnectSecretProviderVaultArgs',
    'KafkaKafkaUserConfigKafkaConnectSecretProviderVaultArgsDict',
    'KafkaKafkaUserConfigKafkaDisklessArgs',
    'KafkaKafkaUserConfigKafkaDisklessArgsDict',
    'KafkaKafkaUserConfigKafkaRestConfigArgs',
    'KafkaKafkaUserConfigKafkaRestConfigArgsDict',
    'KafkaKafkaUserConfigKafkaSaslMechanismsArgs',
    'KafkaKafkaUserConfigKafkaSaslMechanismsArgsDict',
    'KafkaKafkaUserConfigPrivateAccessArgs',
    'KafkaKafkaUserConfigPrivateAccessArgsDict',
    'KafkaKafkaUserConfigPrivatelinkAccessArgs',
    'KafkaKafkaUserConfigPrivatelinkAccessArgsDict',
    'KafkaKafkaUserConfigPublicAccessArgs',
    'KafkaKafkaUserConfigPublicAccessArgsDict',
    'KafkaKafkaUserConfigSchemaRegistryConfigArgs',
    'KafkaKafkaUserConfigSchemaRegistryConfigArgsDict',
    'KafkaKafkaUserConfigSingleZoneArgs',
    'KafkaKafkaUserConfigSingleZoneArgsDict',
    'KafkaKafkaUserConfigTieredStorageArgs',
    'KafkaKafkaUserConfigTieredStorageArgsDict',
    'KafkaKafkaUserConfigTieredStorageLocalCacheArgs',
    'KafkaKafkaUserConfigTieredStorageLocalCacheArgsDict',
    'KafkaMirrorMakerComponentArgs',
    'KafkaMirrorMakerComponentArgsDict',
    'KafkaMirrorMakerKafkaMirrormakerUserConfigArgs',
    'KafkaMirrorMakerKafkaMirrormakerUserConfigArgsDict',
    'KafkaMirrorMakerKafkaMirrormakerUserConfigIpFilterObjectArgs',
    'KafkaMirrorMakerKafkaMirrormakerUserConfigIpFilterObjectArgsDict',
    'KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerArgs',
    'KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerArgsDict',
    'KafkaMirrorMakerServiceIntegrationArgs',
    'KafkaMirrorMakerServiceIntegrationArgsDict',
    'KafkaMirrorMakerTagArgs',
    'KafkaMirrorMakerTagArgsDict',
    'KafkaMirrorMakerTechEmailArgs',
    'KafkaMirrorMakerTechEmailArgsDict',
    'KafkaServiceIntegrationArgs',
    'KafkaServiceIntegrationArgsDict',
    'KafkaTagArgs',
    'KafkaTagArgsDict',
    'KafkaTechEmailArgs',
    'KafkaTechEmailArgsDict',
    'KafkaTopicConfigArgs',
    'KafkaTopicConfigArgsDict',
    'KafkaTopicTagArgs',
    'KafkaTopicTagArgsDict',
    'M3AggregatorComponentArgs',
    'M3AggregatorComponentArgsDict',
    'M3AggregatorM3aggregatorArgs',
    'M3AggregatorM3aggregatorArgsDict',
    'M3AggregatorM3aggregatorUserConfigArgs',
    'M3AggregatorM3aggregatorUserConfigArgsDict',
    'M3AggregatorM3aggregatorUserConfigIpFilterObjectArgs',
    'M3AggregatorM3aggregatorUserConfigIpFilterObjectArgsDict',
    'M3AggregatorServiceIntegrationArgs',
    'M3AggregatorServiceIntegrationArgsDict',
    'M3AggregatorTagArgs',
    'M3AggregatorTagArgsDict',
    'M3AggregatorTechEmailArgs',
    'M3AggregatorTechEmailArgsDict',
    'M3DbComponentArgs',
    'M3DbComponentArgsDict',
    'M3DbM3dbArgs',
    'M3DbM3dbArgsDict',
    'M3DbM3dbUserConfigArgs',
    'M3DbM3dbUserConfigArgsDict',
    'M3DbM3dbUserConfigIpFilterObjectArgs',
    'M3DbM3dbUserConfigIpFilterObjectArgsDict',
    'M3DbM3dbUserConfigLimitsArgs',
    'M3DbM3dbUserConfigLimitsArgsDict',
    'M3DbM3dbUserConfigM3Args',
    'M3DbM3dbUserConfigM3ArgsDict',
    'M3DbM3dbUserConfigM3TagOptionsArgs',
    'M3DbM3dbUserConfigM3TagOptionsArgsDict',
    'M3DbM3dbUserConfigNamespaceArgs',
    'M3DbM3dbUserConfigNamespaceArgsDict',
    'M3DbM3dbUserConfigNamespaceOptionsArgs',
    'M3DbM3dbUserConfigNamespaceOptionsArgsDict',
    'M3DbM3dbUserConfigNamespaceOptionsRetentionOptionsArgs',
    'M3DbM3dbUserConfigNamespaceOptionsRetentionOptionsArgsDict',
    'M3DbM3dbUserConfigPrivateAccessArgs',
    'M3DbM3dbUserConfigPrivateAccessArgsDict',
    'M3DbM3dbUserConfigPublicAccessArgs',
    'M3DbM3dbUserConfigPublicAccessArgsDict',
    'M3DbM3dbUserConfigRulesArgs',
    'M3DbM3dbUserConfigRulesArgsDict',
    'M3DbM3dbUserConfigRulesMappingArgs',
    'M3DbM3dbUserConfigRulesMappingArgsDict',
    'M3DbM3dbUserConfigRulesMappingNamespacesObjectArgs',
    'M3DbM3dbUserConfigRulesMappingNamespacesObjectArgsDict',
    'M3DbM3dbUserConfigRulesMappingTagArgs',
    'M3DbM3dbUserConfigRulesMappingTagArgsDict',
    'M3DbServiceIntegrationArgs',
    'M3DbServiceIntegrationArgsDict',
    'M3DbTagArgs',
    'M3DbTagArgsDict',
    'M3DbTechEmailArgs',
    'M3DbTechEmailArgsDict',
    'MySqlComponentArgs',
    'MySqlComponentArgsDict',
    'MySqlMysqlArgs',
    'MySqlMysqlArgsDict',
    'MySqlMysqlParamArgs',
    'MySqlMysqlParamArgsDict',
    'MySqlMysqlUserConfigArgs',
    'MySqlMysqlUserConfigArgsDict',
    'MySqlMysqlUserConfigIpFilterObjectArgs',
    'MySqlMysqlUserConfigIpFilterObjectArgsDict',
    'MySqlMysqlUserConfigMigrationArgs',
    'MySqlMysqlUserConfigMigrationArgsDict',
    'MySqlMysqlUserConfigMysqlArgs',
    'MySqlMysqlUserConfigMysqlArgsDict',
    'MySqlMysqlUserConfigMysqlIncrementalBackupArgs',
    'MySqlMysqlUserConfigMysqlIncrementalBackupArgsDict',
    'MySqlMysqlUserConfigPrivateAccessArgs',
    'MySqlMysqlUserConfigPrivateAccessArgsDict',
    'MySqlMysqlUserConfigPrivatelinkAccessArgs',
    'MySqlMysqlUserConfigPrivatelinkAccessArgsDict',
    'MySqlMysqlUserConfigPublicAccessArgs',
    'MySqlMysqlUserConfigPublicAccessArgsDict',
    'MySqlServiceIntegrationArgs',
    'MySqlServiceIntegrationArgsDict',
    'MySqlTagArgs',
    'MySqlTagArgsDict',
    'MySqlTechEmailArgs',
    'MySqlTechEmailArgsDict',
    'MysqlDatabaseTimeoutsArgs',
    'MysqlDatabaseTimeoutsArgsDict',
    'MysqlUserTimeoutsArgs',
    'MysqlUserTimeoutsArgsDict',
    'OpenSearchComponentArgs',
    'OpenSearchComponentArgsDict',
    'OpenSearchOpensearchArgs',
    'OpenSearchOpensearchArgsDict',
    'OpenSearchOpensearchUserConfigArgs',
    'OpenSearchOpensearchUserConfigArgsDict',
    'OpenSearchOpensearchUserConfigAzureMigrationArgs',
    'OpenSearchOpensearchUserConfigAzureMigrationArgsDict',
    'OpenSearchOpensearchUserConfigGcsMigrationArgs',
    'OpenSearchOpensearchUserConfigGcsMigrationArgsDict',
    'OpenSearchOpensearchUserConfigIndexPatternArgs',
    'OpenSearchOpensearchUserConfigIndexPatternArgsDict',
    'OpenSearchOpensearchUserConfigIndexRollupArgs',
    'OpenSearchOpensearchUserConfigIndexRollupArgsDict',
    'OpenSearchOpensearchUserConfigIndexTemplateArgs',
    'OpenSearchOpensearchUserConfigIndexTemplateArgsDict',
    'OpenSearchOpensearchUserConfigIpFilterObjectArgs',
    'OpenSearchOpensearchUserConfigIpFilterObjectArgsDict',
    'OpenSearchOpensearchUserConfigJwtArgs',
    'OpenSearchOpensearchUserConfigJwtArgsDict',
    'OpenSearchOpensearchUserConfigOpenidArgs',
    'OpenSearchOpensearchUserConfigOpenidArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchArgs',
    'OpenSearchOpensearchUserConfigOpensearchArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersArgs',
    'OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersInternalAuthenticationBackendLimitingArgs',
    'OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersInternalAuthenticationBackendLimitingArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersIpRateLimitingArgs',
    'OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersIpRateLimitingArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchClusterRemoteStoreArgs',
    'OpenSearchOpensearchUserConfigOpensearchClusterRemoteStoreArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogArgs',
    'OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogThresholdArgs',
    'OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogThresholdArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchDashboardsArgs',
    'OpenSearchOpensearchUserConfigOpensearchDashboardsArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchDiskWatermarksArgs',
    'OpenSearchOpensearchUserConfigOpensearchDiskWatermarksArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchRemoteStoreArgs',
    'OpenSearchOpensearchUserConfigOpensearchRemoteStoreArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchSearchBackpressureArgs',
    'OpenSearchOpensearchUserConfigOpensearchSearchBackpressureArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchSearchBackpressureNodeDuressArgs',
    'OpenSearchOpensearchUserConfigOpensearchSearchBackpressureNodeDuressArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchShardTaskArgs',
    'OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchShardTaskArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTaskArgs',
    'OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTaskArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesArgs',
    'OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpuArgs',
    'OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpuArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatencyArgs',
    'OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatencyArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemoryArgs',
    'OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemoryArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchSegrepArgs',
    'OpenSearchOpensearchUserConfigOpensearchSegrepArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureArgs',
    'OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureOperatingFactorArgs',
    'OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureOperatingFactorArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterArgs',
    'OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterNodeArgs',
    'OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterNodeArgsDict',
    'OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterShardArgs',
    'OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterShardArgsDict',
    'OpenSearchOpensearchUserConfigPrivateAccessArgs',
    'OpenSearchOpensearchUserConfigPrivateAccessArgsDict',
    'OpenSearchOpensearchUserConfigPrivatelinkAccessArgs',
    'OpenSearchOpensearchUserConfigPrivatelinkAccessArgsDict',
    'OpenSearchOpensearchUserConfigPublicAccessArgs',
    'OpenSearchOpensearchUserConfigPublicAccessArgsDict',
    'OpenSearchOpensearchUserConfigS3MigrationArgs',
    'OpenSearchOpensearchUserConfigS3MigrationArgsDict',
    'OpenSearchOpensearchUserConfigSamlArgs',
    'OpenSearchOpensearchUserConfigSamlArgsDict',
    'OpenSearchServiceIntegrationArgs',
    'OpenSearchServiceIntegrationArgsDict',
    'OpenSearchTagArgs',
    'OpenSearchTagArgsDict',
    'OpenSearchTechEmailArgs',
    'OpenSearchTechEmailArgsDict',
    'OrganizationAddressTimeoutsArgs',
    'OrganizationAddressTimeoutsArgsDict',
    'OrganizationApplicationUserTimeoutsArgs',
    'OrganizationApplicationUserTimeoutsArgsDict',
    'OrganizationApplicationUserTokenTimeoutsArgs',
    'OrganizationApplicationUserTokenTimeoutsArgsDict',
    'OrganizationBillingGroupTimeoutsArgs',
    'OrganizationBillingGroupTimeoutsArgsDict',
    'OrganizationGroupProjectTimeoutsArgs',
    'OrganizationGroupProjectTimeoutsArgsDict',
    'OrganizationPermissionPermissionArgs',
    'OrganizationPermissionPermissionArgsDict',
    'OrganizationPermissionTimeoutsArgs',
    'OrganizationPermissionTimeoutsArgsDict',
    'OrganizationProjectTagArgs',
    'OrganizationProjectTagArgsDict',
    'OrganizationProjectTimeoutsArgs',
    'OrganizationProjectTimeoutsArgsDict',
    'OrganizationTimeoutsArgs',
    'OrganizationTimeoutsArgsDict',
    'OrganizationUserGroupMemberTimeoutsArgs',
    'OrganizationUserGroupMemberTimeoutsArgsDict',
    'OrganizationalUnitTimeoutsArgs',
    'OrganizationalUnitTimeoutsArgsDict',
    'PgComponentArgs',
    'PgComponentArgsDict',
    'PgDatabaseTimeoutsArgs',
    'PgDatabaseTimeoutsArgsDict',
    'PgPgArgs',
    'PgPgArgsDict',
    'PgPgParamArgs',
    'PgPgParamArgsDict',
    'PgPgUserConfigArgs',
    'PgPgUserConfigArgsDict',
    'PgPgUserConfigIpFilterObjectArgs',
    'PgPgUserConfigIpFilterObjectArgsDict',
    'PgPgUserConfigMigrationArgs',
    'PgPgUserConfigMigrationArgsDict',
    'PgPgUserConfigPgArgs',
    'PgPgUserConfigPgArgsDict',
    'PgPgUserConfigPgQualstatsArgs',
    'PgPgUserConfigPgQualstatsArgsDict',
    'PgPgUserConfigPgauditArgs',
    'PgPgUserConfigPgauditArgsDict',
    'PgPgUserConfigPgbouncerArgs',
    'PgPgUserConfigPgbouncerArgsDict',
    'PgPgUserConfigPglookoutArgs',
    'PgPgUserConfigPglookoutArgsDict',
    'PgPgUserConfigPrivateAccessArgs',
    'PgPgUserConfigPrivateAccessArgsDict',
    'PgPgUserConfigPrivatelinkAccessArgs',
    'PgPgUserConfigPrivatelinkAccessArgsDict',
    'PgPgUserConfigPublicAccessArgs',
    'PgPgUserConfigPublicAccessArgsDict',
    'PgPgUserConfigTimescaledbArgs',
    'PgPgUserConfigTimescaledbArgsDict',
    'PgServiceIntegrationArgs',
    'PgServiceIntegrationArgsDict',
    'PgTagArgs',
    'PgTagArgsDict',
    'PgTechEmailArgs',
    'PgTechEmailArgsDict',
    'ProjectTagArgs',
    'ProjectTagArgsDict',
    'RedisComponentArgs',
    'RedisComponentArgsDict',
    'RedisRedisArgs',
    'RedisRedisArgsDict',
    'RedisRedisUserConfigArgs',
    'RedisRedisUserConfigArgsDict',
    'RedisRedisUserConfigIpFilterObjectArgs',
    'RedisRedisUserConfigIpFilterObjectArgsDict',
    'RedisRedisUserConfigMigrationArgs',
    'RedisRedisUserConfigMigrationArgsDict',
    'RedisRedisUserConfigPrivateAccessArgs',
    'RedisRedisUserConfigPrivateAccessArgsDict',
    'RedisRedisUserConfigPrivatelinkAccessArgs',
    'RedisRedisUserConfigPrivatelinkAccessArgsDict',
    'RedisRedisUserConfigPublicAccessArgs',
    'RedisRedisUserConfigPublicAccessArgsDict',
    'RedisServiceIntegrationArgs',
    'RedisServiceIntegrationArgsDict',
    'RedisTagArgs',
    'RedisTagArgsDict',
    'RedisTechEmailArgs',
    'RedisTechEmailArgsDict',
    'ServiceIntegrationClickhouseCredentialsUserConfigArgs',
    'ServiceIntegrationClickhouseCredentialsUserConfigArgsDict',
    'ServiceIntegrationClickhouseCredentialsUserConfigGrantArgs',
    'ServiceIntegrationClickhouseCredentialsUserConfigGrantArgsDict',
    'ServiceIntegrationClickhouseKafkaUserConfigArgs',
    'ServiceIntegrationClickhouseKafkaUserConfigArgsDict',
    'ServiceIntegrationClickhouseKafkaUserConfigTableArgs',
    'ServiceIntegrationClickhouseKafkaUserConfigTableArgsDict',
    'ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs',
    'ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgsDict',
    'ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs',
    'ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgsDict',
    'ServiceIntegrationClickhousePostgresqlUserConfigArgs',
    'ServiceIntegrationClickhousePostgresqlUserConfigArgsDict',
    'ServiceIntegrationClickhousePostgresqlUserConfigDatabaseArgs',
    'ServiceIntegrationClickhousePostgresqlUserConfigDatabaseArgsDict',
    'ServiceIntegrationDatadogUserConfigArgs',
    'ServiceIntegrationDatadogUserConfigArgsDict',
    'ServiceIntegrationDatadogUserConfigDatadogTagArgs',
    'ServiceIntegrationDatadogUserConfigDatadogTagArgsDict',
    'ServiceIntegrationDatadogUserConfigOpensearchArgs',
    'ServiceIntegrationDatadogUserConfigOpensearchArgsDict',
    'ServiceIntegrationDatadogUserConfigRedisArgs',
    'ServiceIntegrationDatadogUserConfigRedisArgsDict',
    'ServiceIntegrationEndpointAutoscalerUserConfigArgs',
    'ServiceIntegrationEndpointAutoscalerUserConfigArgsDict',
    'ServiceIntegrationEndpointAutoscalerUserConfigAutoscalingArgs',
    'ServiceIntegrationEndpointAutoscalerUserConfigAutoscalingArgsDict',
    'ServiceIntegrationEndpointDatadogUserConfigArgs',
    'ServiceIntegrationEndpointDatadogUserConfigArgsDict',
    'ServiceIntegrationEndpointDatadogUserConfigDatadogTagArgs',
    'ServiceIntegrationEndpointDatadogUserConfigDatadogTagArgsDict',
    'ServiceIntegrationEndpointExternalAwsCloudwatchLogsUserConfigArgs',
    'ServiceIntegrationEndpointExternalAwsCloudwatchLogsUserConfigArgsDict',
    'ServiceIntegrationEndpointExternalAwsCloudwatchMetricsUserConfigArgs',
    'ServiceIntegrationEndpointExternalAwsCloudwatchMetricsUserConfigArgsDict',
    'ServiceIntegrationEndpointExternalAwsS3UserConfigArgs',
    'ServiceIntegrationEndpointExternalAwsS3UserConfigArgsDict',
    'ServiceIntegrationEndpointExternalAzureBlobStorageUserConfigArgs',
    'ServiceIntegrationEndpointExternalAzureBlobStorageUserConfigArgsDict',
    'ServiceIntegrationEndpointExternalClickhouseUserConfigArgs',
    'ServiceIntegrationEndpointExternalClickhouseUserConfigArgsDict',
    'ServiceIntegrationEndpointExternalElasticsearchLogsUserConfigArgs',
    'ServiceIntegrationEndpointExternalElasticsearchLogsUserConfigArgsDict',
    'ServiceIntegrationEndpointExternalGoogleCloudBigqueryArgs',
    'ServiceIntegrationEndpointExternalGoogleCloudBigqueryArgsDict',
    'ServiceIntegrationEndpointExternalGoogleCloudLoggingUserConfigArgs',
    'ServiceIntegrationEndpointExternalGoogleCloudLoggingUserConfigArgsDict',
    'ServiceIntegrationEndpointExternalKafkaUserConfigArgs',
    'ServiceIntegrationEndpointExternalKafkaUserConfigArgsDict',
    'ServiceIntegrationEndpointExternalMysqlUserConfigArgs',
    'ServiceIntegrationEndpointExternalMysqlUserConfigArgsDict',
    'ServiceIntegrationEndpointExternalOpensearchLogsUserConfigArgs',
    'ServiceIntegrationEndpointExternalOpensearchLogsUserConfigArgsDict',
    'ServiceIntegrationEndpointExternalPostgresqlArgs',
    'ServiceIntegrationEndpointExternalPostgresqlArgsDict',
    'ServiceIntegrationEndpointExternalPrometheusUserConfigArgs',
    'ServiceIntegrationEndpointExternalPrometheusUserConfigArgsDict',
    'ServiceIntegrationEndpointExternalSchemaRegistryUserConfigArgs',
    'ServiceIntegrationEndpointExternalSchemaRegistryUserConfigArgsDict',
    'ServiceIntegrationEndpointJolokiaUserConfigArgs',
    'ServiceIntegrationEndpointJolokiaUserConfigArgsDict',
    'ServiceIntegrationEndpointPrometheusUserConfigArgs',
    'ServiceIntegrationEndpointPrometheusUserConfigArgsDict',
    'ServiceIntegrationEndpointRsyslogUserConfigArgs',
    'ServiceIntegrationEndpointRsyslogUserConfigArgsDict',
    'ServiceIntegrationExternalAwsCloudwatchLogsUserConfigArgs',
    'ServiceIntegrationExternalAwsCloudwatchLogsUserConfigArgsDict',
    'ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigArgs',
    'ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigArgsDict',
    'ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricArgs',
    'ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricArgsDict',
    'ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricArgs',
    'ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricArgsDict',
    'ServiceIntegrationExternalElasticsearchLogsUserConfigArgs',
    'ServiceIntegrationExternalElasticsearchLogsUserConfigArgsDict',
    'ServiceIntegrationExternalOpensearchLogsUserConfigArgs',
    'ServiceIntegrationExternalOpensearchLogsUserConfigArgsDict',
    'ServiceIntegrationFlinkExternalPostgresqlUserConfigArgs',
    'ServiceIntegrationFlinkExternalPostgresqlUserConfigArgsDict',
    'ServiceIntegrationKafkaConnectUserConfigArgs',
    'ServiceIntegrationKafkaConnectUserConfigArgsDict',
    'ServiceIntegrationKafkaConnectUserConfigKafkaConnectArgs',
    'ServiceIntegrationKafkaConnectUserConfigKafkaConnectArgsDict',
    'ServiceIntegrationKafkaLogsUserConfigArgs',
    'ServiceIntegrationKafkaLogsUserConfigArgsDict',
    'ServiceIntegrationKafkaMirrormakerUserConfigArgs',
    'ServiceIntegrationKafkaMirrormakerUserConfigArgsDict',
    'ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgs',
    'ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgsDict',
    'ServiceIntegrationLogsUserConfigArgs',
    'ServiceIntegrationLogsUserConfigArgsDict',
    'ServiceIntegrationMetricsUserConfigArgs',
    'ServiceIntegrationMetricsUserConfigArgsDict',
    'ServiceIntegrationMetricsUserConfigSourceMysqlArgs',
    'ServiceIntegrationMetricsUserConfigSourceMysqlArgsDict',
    'ServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgs',
    'ServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgsDict',
    'ServiceIntegrationPrometheusUserConfigArgs',
    'ServiceIntegrationPrometheusUserConfigArgsDict',
    'ServiceIntegrationPrometheusUserConfigSourceMysqlArgs',
    'ServiceIntegrationPrometheusUserConfigSourceMysqlArgsDict',
    'ServiceIntegrationPrometheusUserConfigSourceMysqlTelegrafArgs',
    'ServiceIntegrationPrometheusUserConfigSourceMysqlTelegrafArgsDict',
    'ThanosComponentArgs',
    'ThanosComponentArgsDict',
    'ThanosServiceIntegrationArgs',
    'ThanosServiceIntegrationArgsDict',
    'ThanosTagArgs',
    'ThanosTagArgsDict',
    'ThanosTechEmailArgs',
    'ThanosTechEmailArgsDict',
    'ThanosThanosArgs',
    'ThanosThanosArgsDict',
    'ThanosThanosUserConfigArgs',
    'ThanosThanosUserConfigArgsDict',
    'ThanosThanosUserConfigCompactorArgs',
    'ThanosThanosUserConfigCompactorArgsDict',
    'ThanosThanosUserConfigIpFilterObjectArgs',
    'ThanosThanosUserConfigIpFilterObjectArgsDict',
    'ThanosThanosUserConfigPrivateAccessArgs',
    'ThanosThanosUserConfigPrivateAccessArgsDict',
    'ThanosThanosUserConfigPrivatelinkAccessArgs',
    'ThanosThanosUserConfigPrivatelinkAccessArgsDict',
    'ThanosThanosUserConfigPublicAccessArgs',
    'ThanosThanosUserConfigPublicAccessArgsDict',
    'ThanosThanosUserConfigQueryArgs',
    'ThanosThanosUserConfigQueryArgsDict',
    'ThanosThanosUserConfigQueryFrontendArgs',
    'ThanosThanosUserConfigQueryFrontendArgsDict',
    'ValkeyComponentArgs',
    'ValkeyComponentArgsDict',
    'ValkeyServiceIntegrationArgs',
    'ValkeyServiceIntegrationArgsDict',
    'ValkeyTagArgs',
    'ValkeyTagArgsDict',
    'ValkeyTechEmailArgs',
    'ValkeyTechEmailArgsDict',
    'ValkeyValkeyArgs',
    'ValkeyValkeyArgsDict',
    'ValkeyValkeyUserConfigArgs',
    'ValkeyValkeyUserConfigArgsDict',
    'ValkeyValkeyUserConfigIpFilterObjectArgs',
    'ValkeyValkeyUserConfigIpFilterObjectArgsDict',
    'ValkeyValkeyUserConfigMigrationArgs',
    'ValkeyValkeyUserConfigMigrationArgsDict',
    'ValkeyValkeyUserConfigPrivateAccessArgs',
    'ValkeyValkeyUserConfigPrivateAccessArgsDict',
    'ValkeyValkeyUserConfigPrivatelinkAccessArgs',
    'ValkeyValkeyUserConfigPrivatelinkAccessArgsDict',
    'ValkeyValkeyUserConfigPublicAccessArgs',
    'ValkeyValkeyUserConfigPublicAccessArgsDict',
    'GetBillingGroupTimeoutsArgs',
    'GetBillingGroupTimeoutsArgsDict',
    'GetMysqlDatabaseTimeoutsArgs',
    'GetMysqlDatabaseTimeoutsArgsDict',
    'GetMysqlUserTimeoutsArgs',
    'GetMysqlUserTimeoutsArgsDict',
    'GetOrganizationAddressTimeoutsArgs',
    'GetOrganizationAddressTimeoutsArgsDict',
    'GetOrganizationApplicationUserTimeoutsArgs',
    'GetOrganizationApplicationUserTimeoutsArgsDict',
    'GetOrganizationBillingGroupListBillingGroupArgs',
    'GetOrganizationBillingGroupListBillingGroupArgsDict',
    'GetOrganizationBillingGroupListTimeoutsArgs',
    'GetOrganizationBillingGroupListTimeoutsArgsDict',
    'GetOrganizationBillingGroupTimeoutsArgs',
    'GetOrganizationBillingGroupTimeoutsArgsDict',
    'GetOrganizationProjectTagArgs',
    'GetOrganizationProjectTagArgsDict',
    'GetOrganizationProjectTimeoutsArgs',
    'GetOrganizationProjectTimeoutsArgsDict',
    'GetOrganizationTimeoutsArgs',
    'GetOrganizationTimeoutsArgsDict',
    'GetOrganizationUserGroupListTimeoutsArgs',
    'GetOrganizationUserGroupListTimeoutsArgsDict',
    'GetOrganizationUserGroupListUserGroupArgs',
    'GetOrganizationUserGroupListUserGroupArgsDict',
    'GetOrganizationUserGroupMemberListMemberArgs',
    'GetOrganizationUserGroupMemberListMemberArgsDict',
    'GetOrganizationUserGroupMemberListMemberUserInfoArgs',
    'GetOrganizationUserGroupMemberListMemberUserInfoArgsDict',
    'GetOrganizationUserGroupMemberListTimeoutsArgs',
    'GetOrganizationUserGroupMemberListTimeoutsArgsDict',
    'GetOrganizationUserListTimeoutsArgs',
    'GetOrganizationUserListTimeoutsArgsDict',
    'GetOrganizationUserListUserArgs',
    'GetOrganizationUserListUserArgsDict',
    'GetOrganizationUserListUserUserInfoArgs',
    'GetOrganizationUserListUserUserInfoArgsDict',
    'GetOrganizationalUnitTimeoutsArgs',
    'GetOrganizationalUnitTimeoutsArgsDict',
    'GetPgDatabaseTimeoutsArgs',
    'GetPgDatabaseTimeoutsArgsDict',
    'GetServiceListServiceArgs',
    'GetServiceListServiceArgsDict',
    'GetServiceListTimeoutsArgs',
    'GetServiceListTimeoutsArgsDict',
    'GetServicePlanBackupConfigArgs',
    'GetServicePlanBackupConfigArgsDict',
    'GetServicePlanListServicePlanArgs',
    'GetServicePlanListServicePlanArgsDict',
    'GetServicePlanListServicePlanRegionsArgs',
    'GetServicePlanListServicePlanRegionsArgsDict',
    'GetServicePlanListTimeoutsArgs',
    'GetServicePlanListTimeoutsArgsDict',
    'GetServicePlanTimeoutsArgs',
    'GetServicePlanTimeoutsArgsDict',
]

MYPY = False

if not MYPY:
    class AccountAuthenticationSamlFieldMappingArgsDict(TypedDict):
        email: NotRequired[pulumi.Input[_builtins.str]]
        """
        Field name for user email
        """
        first_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Field name for user's first name
        """
        identity: NotRequired[pulumi.Input[_builtins.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.
        """
        last_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Field name for user's last name
        """
        real_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Field name for user's full name. If specified, first*name and last*name mappings are ignored
        """
elif False:
    AccountAuthenticationSamlFieldMappingArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AccountAuthenticationSamlFieldMappingArgs:
    def __init__(__self__, *,
                 email: Optional[pulumi.Input[_builtins.str]] = None,
                 first_name: Optional[pulumi.Input[_builtins.str]] = None,
                 identity: Optional[pulumi.Input[_builtins.str]] = None,
                 last_name: Optional[pulumi.Input[_builtins.str]] = None,
                 real_name: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] email: Field name for user email
        :param pulumi.Input[_builtins.str] first_name: Field name for user's first name
        :param pulumi.Input[_builtins.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[_builtins.str] last_name: Field name for user's last name
        :param pulumi.Input[_builtins.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)

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

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

    @_builtins.property
    @pulumi.getter(name="firstName")
    def first_name(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "first_name", value)

    @_builtins.property
    @pulumi.getter
    def identity(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "identity", value)

    @_builtins.property
    @pulumi.getter(name="lastName")
    def last_name(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "last_name", value)

    @_builtins.property
    @pulumi.getter(name="realName")
    def real_name(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "real_name", value)


if not MYPY:
    class AlloydbomniAlloydbomniArgsDict(TypedDict):
        bouncer: NotRequired[pulumi.Input[_builtins.str]]
        """
        PgBouncer connection details for [connection pooling](https://aiven.io/docs/products/postgresql/concepts/pg-connection-pooling).
        """
        dbname: NotRequired[pulumi.Input[_builtins.str]]
        """
        Primary AlloyDB Omni database name.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        AlloyDB Omni primary node host IP or name.
        """
        max_connections: NotRequired[pulumi.Input[_builtins.int]]
        """
        The [number of allowed connections](https://aiven.io/docs/products/postgresql/reference/pg-connection-limits). Varies based on the service plan.
        """
        params: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlloydbomniAlloydbomniParamArgsDict']]]]
        """
        AlloyDB Omni connection parameters.
        """
        password: NotRequired[pulumi.Input[_builtins.str]]
        """
        AlloyDB Omni admin user password.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        AlloyDB Omni port.
        """
        replica_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        AlloyDB Omni replica URI for services with a replica.
        """
        sslmode: NotRequired[pulumi.Input[_builtins.str]]
        """
        AlloyDB Omni SSL mode setting.
        """
        standby_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        AlloyDB Omni standby connection URIs.
        """
        syncing_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        AlloyDB Omni syncing connection URIs.
        """
        uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        AlloyDB Omni primary connection URI.
        """
        uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        AlloyDB Omni primary connection URIs.
        """
        user: NotRequired[pulumi.Input[_builtins.str]]
        """
        AlloyDB Omni admin user name.
        """
elif False:
    AlloydbomniAlloydbomniArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlloydbomniAlloydbomniArgs:
    def __init__(__self__, *,
                 bouncer: Optional[pulumi.Input[_builtins.str]] = None,
                 dbname: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 max_connections: Optional[pulumi.Input[_builtins.int]] = None,
                 params: Optional[pulumi.Input[Sequence[pulumi.Input['AlloydbomniAlloydbomniParamArgs']]]] = None,
                 password: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 replica_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 sslmode: Optional[pulumi.Input[_builtins.str]] = None,
                 standby_uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 syncing_uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 uri: Optional[pulumi.Input[_builtins.str]] = None,
                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 user: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] bouncer: PgBouncer connection details for [connection pooling](https://aiven.io/docs/products/postgresql/concepts/pg-connection-pooling).
        :param pulumi.Input[_builtins.str] dbname: Primary AlloyDB Omni database name.
        :param pulumi.Input[_builtins.str] host: AlloyDB Omni primary node host IP or name.
        :param pulumi.Input[_builtins.int] max_connections: The [number of allowed connections](https://aiven.io/docs/products/postgresql/reference/pg-connection-limits). Varies based on the service plan.
        :param pulumi.Input[Sequence[pulumi.Input['AlloydbomniAlloydbomniParamArgs']]] params: AlloyDB Omni connection parameters.
        :param pulumi.Input[_builtins.str] password: AlloyDB Omni admin user password.
        :param pulumi.Input[_builtins.int] port: AlloyDB Omni port.
        :param pulumi.Input[_builtins.str] replica_uri: AlloyDB Omni replica URI for services with a replica.
        :param pulumi.Input[_builtins.str] sslmode: AlloyDB Omni SSL mode setting.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] standby_uris: AlloyDB Omni standby connection URIs.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] syncing_uris: AlloyDB Omni syncing connection URIs.
        :param pulumi.Input[_builtins.str] uri: AlloyDB Omni primary connection URI.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uris: AlloyDB Omni primary connection URIs.
        :param pulumi.Input[_builtins.str] user: AlloyDB Omni admin user name.
        """
        if bouncer is not None:
            warnings.warn("""This field was added by mistake and has never worked. It will be removed in future versions.""", DeprecationWarning)
            pulumi.log.warn("""bouncer is deprecated: This field was added by mistake and has never worked. It will be removed in future versions.""")
        if bouncer is not None:
            pulumi.set(__self__, "bouncer", bouncer)
        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 params is not None:
            pulumi.set(__self__, "params", params)
        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 standby_uris is not None:
            pulumi.set(__self__, "standby_uris", standby_uris)
        if syncing_uris is not None:
            pulumi.set(__self__, "syncing_uris", syncing_uris)
        if uri is not None:
            pulumi.set(__self__, "uri", uri)
        if uris is not None:
            pulumi.set(__self__, "uris", uris)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @_builtins.property
    @pulumi.getter
    @_utilities.deprecated("""This field was added by mistake and has never worked. It will be removed in future versions.""")
    def bouncer(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PgBouncer connection details for [connection pooling](https://aiven.io/docs/products/postgresql/concepts/pg-connection-pooling).
        """
        return pulumi.get(self, "bouncer")

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

    @_builtins.property
    @pulumi.getter
    def dbname(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Primary AlloyDB Omni database name.
        """
        return pulumi.get(self, "dbname")

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

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        AlloyDB Omni primary node host IP or name.
        """
        return pulumi.get(self, "host")

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

    @_builtins.property
    @pulumi.getter(name="maxConnections")
    def max_connections(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The [number of allowed connections](https://aiven.io/docs/products/postgresql/reference/pg-connection-limits). Varies based on the service plan.
        """
        return pulumi.get(self, "max_connections")

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

    @_builtins.property
    @pulumi.getter
    def params(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AlloydbomniAlloydbomniParamArgs']]]]:
        """
        AlloyDB Omni connection parameters.
        """
        return pulumi.get(self, "params")

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

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

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

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

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

    @_builtins.property
    @pulumi.getter(name="replicaUri")
    def replica_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        AlloyDB Omni replica URI for services with a replica.
        """
        return pulumi.get(self, "replica_uri")

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

    @_builtins.property
    @pulumi.getter
    def sslmode(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        AlloyDB Omni SSL mode setting.
        """
        return pulumi.get(self, "sslmode")

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

    @_builtins.property
    @pulumi.getter(name="standbyUris")
    def standby_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        AlloyDB Omni standby connection URIs.
        """
        return pulumi.get(self, "standby_uris")

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

    @_builtins.property
    @pulumi.getter(name="syncingUris")
    def syncing_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        AlloyDB Omni syncing connection URIs.
        """
        return pulumi.get(self, "syncing_uris")

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

    @_builtins.property
    @pulumi.getter
    def uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        AlloyDB Omni primary connection URI.
        """
        return pulumi.get(self, "uri")

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

    @_builtins.property
    @pulumi.getter
    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        AlloyDB Omni primary connection URIs.
        """
        return pulumi.get(self, "uris")

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

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

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


if not MYPY:
    class AlloydbomniAlloydbomniParamArgsDict(TypedDict):
        database_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Primary AlloyDB Omni database name.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        AlloyDB Omni host IP or name.
        """
        password: NotRequired[pulumi.Input[_builtins.str]]
        """
        AlloyDB Omni admin user password.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        AlloyDB Omni port.
        """
        sslmode: NotRequired[pulumi.Input[_builtins.str]]
        """
        AlloyDB Omni SSL mode setting.
        """
        user: NotRequired[pulumi.Input[_builtins.str]]
        """
        AlloyDB Omni admin user name.
        """
elif False:
    AlloydbomniAlloydbomniParamArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlloydbomniAlloydbomniParamArgs:
    def __init__(__self__, *,
                 database_name: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 password: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 sslmode: Optional[pulumi.Input[_builtins.str]] = None,
                 user: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] database_name: Primary AlloyDB Omni database name.
        :param pulumi.Input[_builtins.str] host: AlloyDB Omni host IP or name.
        :param pulumi.Input[_builtins.str] password: AlloyDB Omni admin user password.
        :param pulumi.Input[_builtins.int] port: AlloyDB Omni port.
        :param pulumi.Input[_builtins.str] sslmode: AlloyDB Omni SSL mode setting.
        :param pulumi.Input[_builtins.str] user: AlloyDB Omni admin user name.
        """
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if sslmode is not None:
            pulumi.set(__self__, "sslmode", sslmode)
        if user is not None:
            pulumi.set(__self__, "user", user)

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

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

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        AlloyDB Omni host IP or name.
        """
        return pulumi.get(self, "host")

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

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

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

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

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

    @_builtins.property
    @pulumi.getter
    def sslmode(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        AlloyDB Omni SSL mode setting.
        """
        return pulumi.get(self, "sslmode")

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

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

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


if not MYPY:
    class AlloydbomniAlloydbomniUserConfigArgsDict(TypedDict):
        additional_backup_regions: NotRequired[pulumi.Input[_builtins.str]]
        """
        Additional Cloud Regions for Backup Replication.
        """
        admin_password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Custom password for admin user. Defaults to random string. This must be set only when a new service is being created.
        """
        admin_username: NotRequired[pulumi.Input[_builtins.str]]
        """
        Custom username for admin user. This must be set only when a new service is being created. Example: `avnadmin`.
        """
        alloydbomni_version: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `15`, and newer. PostgreSQL major version.
        """
        backup_hour: NotRequired[pulumi.Input[_builtins.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. Example: `3`.
        """
        backup_minute: NotRequired[pulumi.Input[_builtins.int]]
        """
        The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed. Example: `30`.
        """
        enable_ipv6: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Register AAAA DNS records for the service, and allow IPv6 packets to service ports.
        """
        google_columnar_engine_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enables or disables the columnar engine. When enabled, it accelerates SQL query processing. Default: `true`.
        """
        google_columnar_engine_memory_size_percentage: NotRequired[pulumi.Input[_builtins.int]]
        """
        Allocate the amount of RAM to store columnar data. Default: `10`.
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlloydbomniAlloydbomniUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        node_count: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of nodes for the service. Example: `3`.
        """
        pg: NotRequired[pulumi.Input['AlloydbomniAlloydbomniUserConfigPgArgsDict']]
        """
        postgresql.conf configuration values
        """
        pg_read_replica: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Should the service which is being forked be a read replica (deprecated, use read_replica service integration instead).
        """
        pg_service_to_fork_from: NotRequired[pulumi.Input[_builtins.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. Example: `anotherservicename`.
        """
        pg_version: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `15`, and newer. PostgreSQL major version.
        """
        pgaudit: NotRequired[pulumi.Input['AlloydbomniAlloydbomniUserConfigPgauditArgsDict']]
        """
        System-wide settings for the pgaudit extension
        """
        pgbouncer: NotRequired[pulumi.Input['AlloydbomniAlloydbomniUserConfigPgbouncerArgsDict']]
        """
        PGBouncer connection pooling settings
        """
        pglookout: NotRequired[pulumi.Input['AlloydbomniAlloydbomniUserConfigPglookoutArgsDict']]
        """
        System-wide settings for pglookout
        """
        private_access: NotRequired[pulumi.Input['AlloydbomniAlloydbomniUserConfigPrivateAccessArgsDict']]
        """
        Allow access to selected service ports from private networks
        """
        privatelink_access: NotRequired[pulumi.Input['AlloydbomniAlloydbomniUserConfigPrivatelinkAccessArgsDict']]
        """
        Allow access to selected service components through Privatelink
        """
        project_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        public_access: NotRequired[pulumi.Input['AlloydbomniAlloydbomniUserConfigPublicAccessArgsDict']]
        """
        Allow access to selected service ports from the public Internet
        """
        recovery_target_time: NotRequired[pulumi.Input[_builtins.str]]
        """
        Recovery target time when forking a service. This has effect only when a new service is being created. Example: `2019-01-01 23:34:45`.
        """
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        service_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        shared_buffers_percentage: NotRequired[pulumi.Input[_builtins.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. Changing this parameter causes a service restart. Example: `41.5`.
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
        synchronous_replication: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `off`, `quorum`. Synchronous replication type. Note that the service plan also needs to support synchronous replication.
        """
        variant: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `aiven`, `timescale`. Variant of the PostgreSQL service, may affect the features that are exposed by default.
        """
        work_mem: NotRequired[pulumi.Input[_builtins.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. The default is 1MB + 0.075% of total RAM (up to 32MB). Example: `4`.
        """
elif False:
    AlloydbomniAlloydbomniUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlloydbomniAlloydbomniUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[_builtins.str]] = None,
                 admin_password: Optional[pulumi.Input[_builtins.str]] = None,
                 admin_username: Optional[pulumi.Input[_builtins.str]] = None,
                 alloydbomni_version: Optional[pulumi.Input[_builtins.str]] = None,
                 backup_hour: Optional[pulumi.Input[_builtins.int]] = None,
                 backup_minute: Optional[pulumi.Input[_builtins.int]] = None,
                 enable_ipv6: Optional[pulumi.Input[_builtins.bool]] = None,
                 google_columnar_engine_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 google_columnar_engine_memory_size_percentage: Optional[pulumi.Input[_builtins.int]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['AlloydbomniAlloydbomniUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 node_count: Optional[pulumi.Input[_builtins.int]] = None,
                 pg: Optional[pulumi.Input['AlloydbomniAlloydbomniUserConfigPgArgs']] = None,
                 pg_read_replica: Optional[pulumi.Input[_builtins.bool]] = None,
                 pg_service_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 pg_version: Optional[pulumi.Input[_builtins.str]] = None,
                 pgaudit: Optional[pulumi.Input['AlloydbomniAlloydbomniUserConfigPgauditArgs']] = None,
                 pgbouncer: Optional[pulumi.Input['AlloydbomniAlloydbomniUserConfigPgbouncerArgs']] = None,
                 pglookout: Optional[pulumi.Input['AlloydbomniAlloydbomniUserConfigPglookoutArgs']] = None,
                 private_access: Optional[pulumi.Input['AlloydbomniAlloydbomniUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['AlloydbomniAlloydbomniUserConfigPrivatelinkAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 public_access: Optional[pulumi.Input['AlloydbomniAlloydbomniUserConfigPublicAccessArgs']] = None,
                 recovery_target_time: Optional[pulumi.Input[_builtins.str]] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 service_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 shared_buffers_percentage: Optional[pulumi.Input[_builtins.float]] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None,
                 synchronous_replication: Optional[pulumi.Input[_builtins.str]] = None,
                 variant: Optional[pulumi.Input[_builtins.str]] = None,
                 work_mem: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[_builtins.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[_builtins.str] admin_username: Custom username for admin user. This must be set only when a new service is being created. Example: `avnadmin`.
        :param pulumi.Input[_builtins.str] alloydbomni_version: Enum: `15`, and newer. PostgreSQL major version.
        :param pulumi.Input[_builtins.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. Example: `3`.
        :param pulumi.Input[_builtins.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. Example: `30`.
        :param pulumi.Input[_builtins.bool] enable_ipv6: Register AAAA DNS records for the service, and allow IPv6 packets to service ports.
        :param pulumi.Input[_builtins.bool] google_columnar_engine_enabled: Enables or disables the columnar engine. When enabled, it accelerates SQL query processing. Default: `true`.
        :param pulumi.Input[_builtins.int] google_columnar_engine_memory_size_percentage: Allocate the amount of RAM to store columnar data. Default: `10`.
        :param pulumi.Input[Sequence[pulumi.Input['AlloydbomniAlloydbomniUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[_builtins.int] node_count: Number of nodes for the service. Example: `3`.
        :param pulumi.Input['AlloydbomniAlloydbomniUserConfigPgArgs'] pg: postgresql.conf configuration values
        :param pulumi.Input[_builtins.bool] pg_read_replica: Should the service which is being forked be a read replica (deprecated, use read_replica service integration instead).
        :param pulumi.Input[_builtins.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. Example: `anotherservicename`.
        :param pulumi.Input[_builtins.str] pg_version: Enum: `15`, and newer. PostgreSQL major version.
        :param pulumi.Input['AlloydbomniAlloydbomniUserConfigPgauditArgs'] pgaudit: System-wide settings for the pgaudit extension
        :param pulumi.Input['AlloydbomniAlloydbomniUserConfigPgbouncerArgs'] pgbouncer: PGBouncer connection pooling settings
        :param pulumi.Input['AlloydbomniAlloydbomniUserConfigPglookoutArgs'] pglookout: System-wide settings for pglookout
        :param pulumi.Input['AlloydbomniAlloydbomniUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks
        :param pulumi.Input['AlloydbomniAlloydbomniUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink
        :param pulumi.Input[_builtins.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. Example: `anotherprojectname`.
        :param pulumi.Input['AlloydbomniAlloydbomniUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
        :param pulumi.Input[_builtins.str] recovery_target_time: Recovery target time when forking a service. This has effect only when a new service is being created. Example: `2019-01-01 23:34:45`.
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input[_builtins.str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        :param pulumi.Input[_builtins.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. Changing this parameter causes a service restart. Example: `41.5`.
        :param pulumi.Input[_builtins.bool] static_ips: Use static public IP addresses.
        :param pulumi.Input[_builtins.str] synchronous_replication: Enum: `off`, `quorum`. Synchronous replication type. Note that the service plan also needs to support synchronous replication.
        :param pulumi.Input[_builtins.str] variant: Enum: `aiven`, `timescale`. Variant of the PostgreSQL service, may affect the features that are exposed by default.
        :param pulumi.Input[_builtins.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. The default is 1MB + 0.075% of total RAM (up to 32MB). Example: `4`.
        """
        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 alloydbomni_version is not None:
            pulumi.set(__self__, "alloydbomni_version", alloydbomni_version)
        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 google_columnar_engine_enabled is not None:
            pulumi.set(__self__, "google_columnar_engine_enabled", google_columnar_engine_enabled)
        if google_columnar_engine_memory_size_percentage is not None:
            pulumi.set(__self__, "google_columnar_engine_memory_size_percentage", google_columnar_engine_memory_size_percentage)
        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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `ip_filter_string` instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        if node_count is not None:
            pulumi.set(__self__, "node_count", node_count)
        if pg is not None:
            pulumi.set(__self__, "pg", pg)
        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:
            pulumi.set(__self__, "pg_service_to_fork_from", pg_service_to_fork_from)
        if pg_version is not None:
            pulumi.set(__self__, "pg_version", pg_version)
        if pgaudit is not None:
            pulumi.set(__self__, "pgaudit", pgaudit)
        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_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        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 variant is not None:
            pulumi.set(__self__, "variant", variant)
        if work_mem is not None:
            pulumi.set(__self__, "work_mem", work_mem)

    @_builtins.property
    @pulumi.getter(name="additionalBackupRegions")
    def additional_backup_regions(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @_builtins.property
    @pulumi.getter(name="adminPassword")
    def admin_password(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "admin_password", value)

    @_builtins.property
    @pulumi.getter(name="adminUsername")
    def admin_username(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Custom username for admin user. This must be set only when a new service is being created. Example: `avnadmin`.
        """
        return pulumi.get(self, "admin_username")

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

    @_builtins.property
    @pulumi.getter(name="alloydbomniVersion")
    def alloydbomni_version(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `15`, and newer. PostgreSQL major version.
        """
        return pulumi.get(self, "alloydbomni_version")

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

    @_builtins.property
    @pulumi.getter(name="backupHour")
    def backup_hour(self) -> Optional[pulumi.Input[_builtins.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. Example: `3`.
        """
        return pulumi.get(self, "backup_hour")

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

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

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

    @_builtins.property
    @pulumi.getter(name="enableIpv6")
    def enable_ipv6(self) -> Optional[pulumi.Input[_builtins.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[_builtins.bool]]):
        pulumi.set(self, "enable_ipv6", value)

    @_builtins.property
    @pulumi.getter(name="googleColumnarEngineEnabled")
    def google_columnar_engine_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enables or disables the columnar engine. When enabled, it accelerates SQL query processing. Default: `true`.
        """
        return pulumi.get(self, "google_columnar_engine_enabled")

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

    @_builtins.property
    @pulumi.getter(name="googleColumnarEngineMemorySizePercentage")
    def google_columnar_engine_memory_size_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Allocate the amount of RAM to store columnar data. Default: `10`.
        """
        return pulumi.get(self, "google_columnar_engine_memory_size_percentage")

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

    @_builtins.property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AlloydbomniAlloydbomniUserConfigIpFilterObjectArgs']]]]:
        """
        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['AlloydbomniAlloydbomniUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

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

    @_builtins.property
    @pulumi.getter(name="nodeCount")
    def node_count(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of nodes for the service. Example: `3`.
        """
        return pulumi.get(self, "node_count")

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

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

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

    @_builtins.property
    @pulumi.getter(name="pgReadReplica")
    def pg_read_replica(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Should the service which is being forked be a read replica (deprecated, use read_replica service integration instead).
        """
        return pulumi.get(self, "pg_read_replica")

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

    @_builtins.property
    @pulumi.getter(name="pgServiceToForkFrom")
    def pg_service_to_fork_from(self) -> Optional[pulumi.Input[_builtins.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. Example: `anotherservicename`.
        """
        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[_builtins.str]]):
        pulumi.set(self, "pg_service_to_fork_from", value)

    @_builtins.property
    @pulumi.getter(name="pgVersion")
    def pg_version(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `15`, and newer. PostgreSQL major version.
        """
        return pulumi.get(self, "pg_version")

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

    @_builtins.property
    @pulumi.getter
    def pgaudit(self) -> Optional[pulumi.Input['AlloydbomniAlloydbomniUserConfigPgauditArgs']]:
        """
        System-wide settings for the pgaudit extension
        """
        return pulumi.get(self, "pgaudit")

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

    @_builtins.property
    @pulumi.getter
    def pgbouncer(self) -> Optional[pulumi.Input['AlloydbomniAlloydbomniUserConfigPgbouncerArgs']]:
        """
        PGBouncer connection pooling settings
        """
        return pulumi.get(self, "pgbouncer")

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

    @_builtins.property
    @pulumi.getter
    def pglookout(self) -> Optional[pulumi.Input['AlloydbomniAlloydbomniUserConfigPglookoutArgs']]:
        """
        System-wide settings for pglookout
        """
        return pulumi.get(self, "pglookout")

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

    @_builtins.property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['AlloydbomniAlloydbomniUserConfigPrivateAccessArgs']]:
        """
        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['AlloydbomniAlloydbomniUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @_builtins.property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['AlloydbomniAlloydbomniUserConfigPrivatelinkAccessArgs']]:
        """
        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['AlloydbomniAlloydbomniUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)

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

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

    @_builtins.property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['AlloydbomniAlloydbomniUserConfigPublicAccessArgs']]:
        """
        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['AlloydbomniAlloydbomniUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

    @_builtins.property
    @pulumi.getter(name="recoveryTargetTime")
    def recovery_target_time(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Recovery target time when forking a service. This has effect only when a new service is being created. Example: `2019-01-01 23:34:45`.
        """
        return pulumi.get(self, "recovery_target_time")

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

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

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

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

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

    @_builtins.property
    @pulumi.getter(name="sharedBuffersPercentage")
    def shared_buffers_percentage(self) -> Optional[pulumi.Input[_builtins.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. Changing this parameter causes a service restart. Example: `41.5`.
        """
        return pulumi.get(self, "shared_buffers_percentage")

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

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

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

    @_builtins.property
    @pulumi.getter(name="synchronousReplication")
    def synchronous_replication(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `off`, `quorum`. 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[_builtins.str]]):
        pulumi.set(self, "synchronous_replication", value)

    @_builtins.property
    @pulumi.getter
    def variant(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `aiven`, `timescale`. 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[_builtins.str]]):
        pulumi.set(self, "variant", value)

    @_builtins.property
    @pulumi.getter(name="workMem")
    def work_mem(self) -> Optional[pulumi.Input[_builtins.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. The default is 1MB + 0.075% of total RAM (up to 32MB). Example: `4`.
        """
        return pulumi.get(self, "work_mem")

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


if not MYPY:
    class AlloydbomniAlloydbomniUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    AlloydbomniAlloydbomniUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlloydbomniAlloydbomniUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

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

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

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


if not MYPY:
    class AlloydbomniAlloydbomniUserConfigPgArgsDict(TypedDict):
        autovacuum_analyze_scale_factor: NotRequired[pulumi.Input[_builtins.float]]
        """
        Specifies a fraction of the table size to add to autovacuum*analyze*threshold when deciding whether to trigger an ANALYZE (e.g. `0.2` for 20% of the table size). The default is `0.2`.
        """
        autovacuum_analyze_threshold: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the minimum number of inserted, updated or deleted tuples needed to trigger an ANALYZE in any one table. The default is `50`.
        """
        autovacuum_freeze_max_age: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the maximum age (in transactions) that a table's pg_class.relfrozenxid field can attain before a VACUUM operation is forced to prevent transaction ID wraparound within the table. The system launches autovacuum processes to prevent wraparound even when autovacuum is otherwise disabled. Changing this parameter causes a service restart.
        """
        autovacuum_max_workers: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the maximum number of autovacuum processes (other than the autovacuum launcher) that may be running at any one time. The default is `3`. Changing this parameter causes a service restart.
        """
        autovacuum_naptime: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the minimum delay between autovacuum runs on any given database. The delay is measured in seconds. The default is `60`.
        """
        autovacuum_vacuum_cost_delay: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the cost delay value that will be used in automatic VACUUM operations. If `-1` is specified, the regular vacuum*cost*delay value will be used. The default is `2` (upstream default).
        """
        autovacuum_vacuum_cost_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the cost limit value that will be used in automatic VACUUM operations. If `-1` is specified, the regular vacuum*cost*limit value will be used. The default is `-1` (upstream default).
        """
        autovacuum_vacuum_scale_factor: NotRequired[pulumi.Input[_builtins.float]]
        """
        Specifies a fraction of the table size to add to autovacuum*vacuum*threshold when deciding whether to trigger a VACUUM (e.g. `0.2` for 20% of the table size). The default is `0.2`.
        """
        autovacuum_vacuum_threshold: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the minimum number of updated or deleted tuples needed to trigger a VACUUM in any one table. The default is `50`.
        """
        bgwriter_delay: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the delay between activity rounds for the background writer in milliseconds. The default is `200`. Example: `200`.
        """
        bgwriter_flush_after: NotRequired[pulumi.Input[_builtins.int]]
        """
        Whenever more than bgwriter*flush*after bytes have been written by the background writer, attempt to force the OS to issue these writes to the underlying storage. Specified in kilobytes. Setting of 0 disables forced writeback. The default is `512`. Example: `512`.
        """
        bgwriter_lru_maxpages: NotRequired[pulumi.Input[_builtins.int]]
        """
        In each round, no more than this many buffers will be written by the background writer. Setting this to zero disables background writing. The default is `100`. Example: `100`.
        """
        bgwriter_lru_multiplier: NotRequired[pulumi.Input[_builtins.float]]
        """
        The average recent need for new buffers is multiplied by bgwriter*lru*multiplier to arrive at an estimate of the number that will be needed during the next round, (up to bgwriter*lru*maxpages). 1.0 represents a “just in time” policy of writing exactly the number of buffers predicted to be needed. Larger values provide some cushion against spikes in demand, while smaller values intentionally leave writes to be done by server processes. The default is `2.0`. Example: `2`.
        """
        deadlock_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        This is the amount of time, in milliseconds, to wait on a lock before checking to see if there is a deadlock condition. The default is `1000` (upstream default). Example: `1000`.
        """
        default_toast_compression: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `lz4`, `pglz`. Specifies the default TOAST compression method for values of compressible columns. The default is `lz4`.
        """
        idle_in_transaction_session_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        Time out sessions with open transactions after this number of milliseconds.
        """
        jit: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Controls system-wide use of Just-in-Time Compilation (JIT).
        """
        log_autovacuum_min_duration: NotRequired[pulumi.Input[_builtins.int]]
        """
        Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one disables logging autovacuum actions. The default is `1000`.
        """
        log_error_verbosity: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `DEFAULT`, `TERSE`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
        """
        log_line_prefix: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
        """
        log_min_duration_statement: NotRequired[pulumi.Input[_builtins.int]]
        """
        Log statements that take more than this number of milliseconds to run, -1 disables.
        """
        log_temp_files: NotRequired[pulumi.Input[_builtins.int]]
        """
        Log statements for each temporary file created larger than this number of kilobytes, -1 disables.
        """
        max_files_per_process: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL maximum number of files that can be open per process. The default is `1000` (upstream default). Changing this parameter causes a service restart.
        """
        max_locks_per_transaction: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL maximum locks per transaction. Changing this parameter causes a service restart.
        """
        max_logical_replication_workers: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL maximum logical replication workers (taken from the pool of max*parallel*workers). The default is `4` (upstream default). Changing this parameter causes a service restart.
        """
        max_parallel_workers: NotRequired[pulumi.Input[_builtins.int]]
        """
        Sets the maximum number of workers that the system can support for parallel queries. The default is `8` (upstream default).
        """
        max_parallel_workers_per_gather: NotRequired[pulumi.Input[_builtins.int]]
        """
        Sets the maximum number of workers that can be started by a single Gather or Gather Merge node. The default is `2` (upstream default).
        """
        max_pred_locks_per_transaction: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL maximum predicate locks per transaction. The default is `64` (upstream default). Changing this parameter causes a service restart.
        """
        max_prepared_transactions: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL maximum prepared transactions. The default is `0`. Changing this parameter causes a service restart.
        """
        max_replication_slots: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL maximum replication slots. The default is `20`. Changing this parameter causes a service restart.
        """
        max_slot_wal_keep_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL maximum WAL size (MB) reserved for replication slots. If `-1` is specified, replication slots may retain an unlimited amount of WAL files. The default is `-1` (upstream default). wal*keep*size minimum WAL size setting takes precedence over this.
        """
        max_stack_depth: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum depth of the stack in bytes. The default is `2097152` (upstream default).
        """
        max_standby_archive_delay: NotRequired[pulumi.Input[_builtins.int]]
        """
        Max standby archive delay in milliseconds. The default is `30000` (upstream default).
        """
        max_standby_streaming_delay: NotRequired[pulumi.Input[_builtins.int]]
        """
        Max standby streaming delay in milliseconds. The default is `30000` (upstream default).
        """
        max_sync_workers_per_subscription: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum number of synchronization workers per subscription. The default is `2`.
        """
        max_wal_senders: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL maximum WAL senders. The default is `20`. Changing this parameter causes a service restart.
        """
        max_worker_processes: NotRequired[pulumi.Input[_builtins.int]]
        """
        Sets the maximum number of background processes that the system can support. The default is `8`. Changing this parameter causes a service restart.
        """
        password_encryption: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `md5`, `scram-sha-256`. Chooses the algorithm for encrypting passwords.
        """
        pg_partman_bgw_dot_interval: NotRequired[pulumi.Input[_builtins.int]]
        """
        Sets the time interval in seconds to run pg_partman's scheduled tasks. The default is `3600`. Example: `3600`.
        """
        pg_partman_bgw_dot_role: NotRequired[pulumi.Input[_builtins.str]]
        """
        Controls which role to use for pg_partman's scheduled background tasks. Example: `myrolename`.
        """
        pg_stat_statements_dot_track: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `all`, `none`, `top`. Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default is `top`.
        """
        temp_file_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL temporary file limit in KiB, -1 for unlimited.
        """
        timezone: NotRequired[pulumi.Input[_builtins.str]]
        """
        PostgreSQL service timezone. Example: `Europe/Helsinki`.
        """
        track_activity_query_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the number of bytes reserved to track the currently executing command for each active session. Changing this parameter causes a service restart. Example: `1024`.
        """
        track_commit_timestamp: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `off`, `on`. Record commit time of transactions. Changing this parameter causes a service restart.
        """
        track_functions: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `all`, `none`, `pl`. Enables tracking of function call counts and time used.
        """
        track_io_timing: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `off`, `on`. Enables timing of database I/O calls. The default is `off`. When on, it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms.
        """
        wal_sender_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        Terminate replication connections that are inactive for longer than this amount of time, in milliseconds. Setting this value to zero disables the timeout. Example: `60000`.
        """
        wal_writer_delay: NotRequired[pulumi.Input[_builtins.int]]
        """
        WAL flush interval in milliseconds. The default is `200`. Setting this parameter to a lower value may negatively impact performance. Example: `50`.
        """
elif False:
    AlloydbomniAlloydbomniUserConfigPgArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlloydbomniAlloydbomniUserConfigPgArgs:
    def __init__(__self__, *,
                 autovacuum_analyze_scale_factor: Optional[pulumi.Input[_builtins.float]] = None,
                 autovacuum_analyze_threshold: Optional[pulumi.Input[_builtins.int]] = None,
                 autovacuum_freeze_max_age: Optional[pulumi.Input[_builtins.int]] = None,
                 autovacuum_max_workers: Optional[pulumi.Input[_builtins.int]] = None,
                 autovacuum_naptime: Optional[pulumi.Input[_builtins.int]] = None,
                 autovacuum_vacuum_cost_delay: Optional[pulumi.Input[_builtins.int]] = None,
                 autovacuum_vacuum_cost_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 autovacuum_vacuum_scale_factor: Optional[pulumi.Input[_builtins.float]] = None,
                 autovacuum_vacuum_threshold: Optional[pulumi.Input[_builtins.int]] = None,
                 bgwriter_delay: Optional[pulumi.Input[_builtins.int]] = None,
                 bgwriter_flush_after: Optional[pulumi.Input[_builtins.int]] = None,
                 bgwriter_lru_maxpages: Optional[pulumi.Input[_builtins.int]] = None,
                 bgwriter_lru_multiplier: Optional[pulumi.Input[_builtins.float]] = None,
                 deadlock_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 default_toast_compression: Optional[pulumi.Input[_builtins.str]] = None,
                 idle_in_transaction_session_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 jit: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_autovacuum_min_duration: Optional[pulumi.Input[_builtins.int]] = None,
                 log_error_verbosity: Optional[pulumi.Input[_builtins.str]] = None,
                 log_line_prefix: Optional[pulumi.Input[_builtins.str]] = None,
                 log_min_duration_statement: Optional[pulumi.Input[_builtins.int]] = None,
                 log_temp_files: Optional[pulumi.Input[_builtins.int]] = None,
                 max_files_per_process: Optional[pulumi.Input[_builtins.int]] = None,
                 max_locks_per_transaction: Optional[pulumi.Input[_builtins.int]] = None,
                 max_logical_replication_workers: Optional[pulumi.Input[_builtins.int]] = None,
                 max_parallel_workers: Optional[pulumi.Input[_builtins.int]] = None,
                 max_parallel_workers_per_gather: Optional[pulumi.Input[_builtins.int]] = None,
                 max_pred_locks_per_transaction: Optional[pulumi.Input[_builtins.int]] = None,
                 max_prepared_transactions: Optional[pulumi.Input[_builtins.int]] = None,
                 max_replication_slots: Optional[pulumi.Input[_builtins.int]] = None,
                 max_slot_wal_keep_size: Optional[pulumi.Input[_builtins.int]] = None,
                 max_stack_depth: Optional[pulumi.Input[_builtins.int]] = None,
                 max_standby_archive_delay: Optional[pulumi.Input[_builtins.int]] = None,
                 max_standby_streaming_delay: Optional[pulumi.Input[_builtins.int]] = None,
                 max_sync_workers_per_subscription: Optional[pulumi.Input[_builtins.int]] = None,
                 max_wal_senders: Optional[pulumi.Input[_builtins.int]] = None,
                 max_worker_processes: Optional[pulumi.Input[_builtins.int]] = None,
                 password_encryption: Optional[pulumi.Input[_builtins.str]] = None,
                 pg_partman_bgw_dot_interval: Optional[pulumi.Input[_builtins.int]] = None,
                 pg_partman_bgw_dot_role: Optional[pulumi.Input[_builtins.str]] = None,
                 pg_stat_statements_dot_track: Optional[pulumi.Input[_builtins.str]] = None,
                 temp_file_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 timezone: Optional[pulumi.Input[_builtins.str]] = None,
                 track_activity_query_size: Optional[pulumi.Input[_builtins.int]] = None,
                 track_commit_timestamp: Optional[pulumi.Input[_builtins.str]] = None,
                 track_functions: Optional[pulumi.Input[_builtins.str]] = None,
                 track_io_timing: Optional[pulumi.Input[_builtins.str]] = None,
                 wal_sender_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 wal_writer_delay: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.float] autovacuum_analyze_scale_factor: Specifies a fraction of the table size to add to autovacuum*analyze*threshold when deciding whether to trigger an ANALYZE (e.g. `0.2` for 20% of the table size). The default is `0.2`.
        :param pulumi.Input[_builtins.int] autovacuum_analyze_threshold: Specifies the minimum number of inserted, updated or deleted tuples needed to trigger an ANALYZE in any one table. The default is `50`.
        :param pulumi.Input[_builtins.int] autovacuum_freeze_max_age: Specifies the maximum age (in transactions) that a table's pg_class.relfrozenxid field can attain before a VACUUM operation is forced to prevent transaction ID wraparound within the table. The system launches autovacuum processes to prevent wraparound even when autovacuum is otherwise disabled. Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] autovacuum_max_workers: Specifies the maximum number of autovacuum processes (other than the autovacuum launcher) that may be running at any one time. The default is `3`. Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] autovacuum_naptime: Specifies the minimum delay between autovacuum runs on any given database. The delay is measured in seconds. The default is `60`.
        :param pulumi.Input[_builtins.int] autovacuum_vacuum_cost_delay: Specifies the cost delay value that will be used in automatic VACUUM operations. If `-1` is specified, the regular vacuum*cost*delay value will be used. The default is `2` (upstream default).
        :param pulumi.Input[_builtins.int] autovacuum_vacuum_cost_limit: Specifies the cost limit value that will be used in automatic VACUUM operations. If `-1` is specified, the regular vacuum*cost*limit value will be used. The default is `-1` (upstream default).
        :param pulumi.Input[_builtins.float] autovacuum_vacuum_scale_factor: Specifies a fraction of the table size to add to autovacuum*vacuum*threshold when deciding whether to trigger a VACUUM (e.g. `0.2` for 20% of the table size). The default is `0.2`.
        :param pulumi.Input[_builtins.int] autovacuum_vacuum_threshold: Specifies the minimum number of updated or deleted tuples needed to trigger a VACUUM in any one table. The default is `50`.
        :param pulumi.Input[_builtins.int] bgwriter_delay: Specifies the delay between activity rounds for the background writer in milliseconds. The default is `200`. Example: `200`.
        :param pulumi.Input[_builtins.int] bgwriter_flush_after: Whenever more than bgwriter*flush*after bytes have been written by the background writer, attempt to force the OS to issue these writes to the underlying storage. Specified in kilobytes. Setting of 0 disables forced writeback. The default is `512`. Example: `512`.
        :param pulumi.Input[_builtins.int] bgwriter_lru_maxpages: In each round, no more than this many buffers will be written by the background writer. Setting this to zero disables background writing. The default is `100`. Example: `100`.
        :param pulumi.Input[_builtins.float] bgwriter_lru_multiplier: The average recent need for new buffers is multiplied by bgwriter*lru*multiplier to arrive at an estimate of the number that will be needed during the next round, (up to bgwriter*lru*maxpages). 1.0 represents a “just in time” policy of writing exactly the number of buffers predicted to be needed. Larger values provide some cushion against spikes in demand, while smaller values intentionally leave writes to be done by server processes. The default is `2.0`. Example: `2`.
        :param pulumi.Input[_builtins.int] deadlock_timeout: This is the amount of time, in milliseconds, to wait on a lock before checking to see if there is a deadlock condition. The default is `1000` (upstream default). Example: `1000`.
        :param pulumi.Input[_builtins.str] default_toast_compression: Enum: `lz4`, `pglz`. Specifies the default TOAST compression method for values of compressible columns. The default is `lz4`.
        :param pulumi.Input[_builtins.int] idle_in_transaction_session_timeout: Time out sessions with open transactions after this number of milliseconds.
        :param pulumi.Input[_builtins.bool] jit: Controls system-wide use of Just-in-Time Compilation (JIT).
        :param pulumi.Input[_builtins.int] log_autovacuum_min_duration: Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one disables logging autovacuum actions. The default is `1000`.
        :param pulumi.Input[_builtins.str] log_error_verbosity: Enum: `DEFAULT`, `TERSE`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
        :param pulumi.Input[_builtins.str] log_line_prefix: Enum: `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
        :param pulumi.Input[_builtins.int] log_min_duration_statement: Log statements that take more than this number of milliseconds to run, -1 disables.
        :param pulumi.Input[_builtins.int] log_temp_files: Log statements for each temporary file created larger than this number of kilobytes, -1 disables.
        :param pulumi.Input[_builtins.int] max_files_per_process: PostgreSQL maximum number of files that can be open per process. The default is `1000` (upstream default). Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] max_locks_per_transaction: PostgreSQL maximum locks per transaction. Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] max_logical_replication_workers: PostgreSQL maximum logical replication workers (taken from the pool of max*parallel*workers). The default is `4` (upstream default). Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] max_parallel_workers: Sets the maximum number of workers that the system can support for parallel queries. The default is `8` (upstream default).
        :param pulumi.Input[_builtins.int] max_parallel_workers_per_gather: Sets the maximum number of workers that can be started by a single Gather or Gather Merge node. The default is `2` (upstream default).
        :param pulumi.Input[_builtins.int] max_pred_locks_per_transaction: PostgreSQL maximum predicate locks per transaction. The default is `64` (upstream default). Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] max_prepared_transactions: PostgreSQL maximum prepared transactions. The default is `0`. Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] max_replication_slots: PostgreSQL maximum replication slots. The default is `20`. Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] max_slot_wal_keep_size: PostgreSQL maximum WAL size (MB) reserved for replication slots. If `-1` is specified, replication slots may retain an unlimited amount of WAL files. The default is `-1` (upstream default). wal*keep*size minimum WAL size setting takes precedence over this.
        :param pulumi.Input[_builtins.int] max_stack_depth: Maximum depth of the stack in bytes. The default is `2097152` (upstream default).
        :param pulumi.Input[_builtins.int] max_standby_archive_delay: Max standby archive delay in milliseconds. The default is `30000` (upstream default).
        :param pulumi.Input[_builtins.int] max_standby_streaming_delay: Max standby streaming delay in milliseconds. The default is `30000` (upstream default).
        :param pulumi.Input[_builtins.int] max_sync_workers_per_subscription: Maximum number of synchronization workers per subscription. The default is `2`.
        :param pulumi.Input[_builtins.int] max_wal_senders: PostgreSQL maximum WAL senders. The default is `20`. Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] max_worker_processes: Sets the maximum number of background processes that the system can support. The default is `8`. Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.str] password_encryption: Enum: `md5`, `scram-sha-256`. Chooses the algorithm for encrypting passwords.
        :param pulumi.Input[_builtins.int] pg_partman_bgw_dot_interval: Sets the time interval in seconds to run pg_partman's scheduled tasks. The default is `3600`. Example: `3600`.
        :param pulumi.Input[_builtins.str] pg_partman_bgw_dot_role: Controls which role to use for pg_partman's scheduled background tasks. Example: `myrolename`.
        :param pulumi.Input[_builtins.str] pg_stat_statements_dot_track: Enum: `all`, `none`, `top`. Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default is `top`.
        :param pulumi.Input[_builtins.int] temp_file_limit: PostgreSQL temporary file limit in KiB, -1 for unlimited.
        :param pulumi.Input[_builtins.str] timezone: PostgreSQL service timezone. Example: `Europe/Helsinki`.
        :param pulumi.Input[_builtins.int] track_activity_query_size: Specifies the number of bytes reserved to track the currently executing command for each active session. Changing this parameter causes a service restart. Example: `1024`.
        :param pulumi.Input[_builtins.str] track_commit_timestamp: Enum: `off`, `on`. Record commit time of transactions. Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.str] track_functions: Enum: `all`, `none`, `pl`. Enables tracking of function call counts and time used.
        :param pulumi.Input[_builtins.str] track_io_timing: Enum: `off`, `on`. Enables timing of database I/O calls. The default is `off`. When on, it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms.
        :param pulumi.Input[_builtins.int] wal_sender_timeout: Terminate replication connections that are inactive for longer than this amount of time, in milliseconds. Setting this value to zero disables the timeout. Example: `60000`.
        :param pulumi.Input[_builtins.int] wal_writer_delay: WAL flush interval in milliseconds. The default is `200`. Setting this parameter to a lower value may negatively impact performance. Example: `50`.
        """
        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_sync_workers_per_subscription is not None:
            pulumi.set(__self__, "max_sync_workers_per_subscription", max_sync_workers_per_subscription)
        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 password_encryption is not None:
            pulumi.set(__self__, "password_encryption", password_encryption)
        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_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)

    @_builtins.property
    @pulumi.getter(name="autovacuumAnalyzeScaleFactor")
    def autovacuum_analyze_scale_factor(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        Specifies a fraction of the table size to add to autovacuum*analyze*threshold when deciding whether to trigger an ANALYZE (e.g. `0.2` for 20% of the table size). The default is `0.2`.
        """
        return pulumi.get(self, "autovacuum_analyze_scale_factor")

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

    @_builtins.property
    @pulumi.getter(name="autovacuumAnalyzeThreshold")
    def autovacuum_analyze_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the minimum number of inserted, updated or deleted tuples needed to trigger an ANALYZE in any one table. The default is `50`.
        """
        return pulumi.get(self, "autovacuum_analyze_threshold")

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

    @_builtins.property
    @pulumi.getter(name="autovacuumFreezeMaxAge")
    def autovacuum_freeze_max_age(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the maximum age (in transactions) that a table's pg_class.relfrozenxid field can attain before a VACUUM operation is forced to prevent transaction ID wraparound within the table. The system launches autovacuum processes to prevent wraparound even when autovacuum is otherwise disabled. Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "autovacuum_freeze_max_age")

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

    @_builtins.property
    @pulumi.getter(name="autovacuumMaxWorkers")
    def autovacuum_max_workers(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the maximum number of autovacuum processes (other than the autovacuum launcher) that may be running at any one time. The default is `3`. Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "autovacuum_max_workers")

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

    @_builtins.property
    @pulumi.getter(name="autovacuumNaptime")
    def autovacuum_naptime(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the minimum delay between autovacuum runs on any given database. The delay is measured in seconds. The default is `60`.
        """
        return pulumi.get(self, "autovacuum_naptime")

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

    @_builtins.property
    @pulumi.getter(name="autovacuumVacuumCostDelay")
    def autovacuum_vacuum_cost_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the cost delay value that will be used in automatic VACUUM operations. If `-1` is specified, the regular vacuum*cost*delay value will be used. The default is `2` (upstream default).
        """
        return pulumi.get(self, "autovacuum_vacuum_cost_delay")

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

    @_builtins.property
    @pulumi.getter(name="autovacuumVacuumCostLimit")
    def autovacuum_vacuum_cost_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the cost limit value that will be used in automatic VACUUM operations. If `-1` is specified, the regular vacuum*cost*limit value will be used. The default is `-1` (upstream default).
        """
        return pulumi.get(self, "autovacuum_vacuum_cost_limit")

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

    @_builtins.property
    @pulumi.getter(name="autovacuumVacuumScaleFactor")
    def autovacuum_vacuum_scale_factor(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        Specifies a fraction of the table size to add to autovacuum*vacuum*threshold when deciding whether to trigger a VACUUM (e.g. `0.2` for 20% of the table size). The default is `0.2`.
        """
        return pulumi.get(self, "autovacuum_vacuum_scale_factor")

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

    @_builtins.property
    @pulumi.getter(name="autovacuumVacuumThreshold")
    def autovacuum_vacuum_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the minimum number of updated or deleted tuples needed to trigger a VACUUM in any one table. The default is `50`.
        """
        return pulumi.get(self, "autovacuum_vacuum_threshold")

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

    @_builtins.property
    @pulumi.getter(name="bgwriterDelay")
    def bgwriter_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the delay between activity rounds for the background writer in milliseconds. The default is `200`. Example: `200`.
        """
        return pulumi.get(self, "bgwriter_delay")

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

    @_builtins.property
    @pulumi.getter(name="bgwriterFlushAfter")
    def bgwriter_flush_after(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Whenever more than bgwriter*flush*after bytes have been written by the background writer, attempt to force the OS to issue these writes to the underlying storage. Specified in kilobytes. Setting of 0 disables forced writeback. The default is `512`. Example: `512`.
        """
        return pulumi.get(self, "bgwriter_flush_after")

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

    @_builtins.property
    @pulumi.getter(name="bgwriterLruMaxpages")
    def bgwriter_lru_maxpages(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        In each round, no more than this many buffers will be written by the background writer. Setting this to zero disables background writing. The default is `100`. Example: `100`.
        """
        return pulumi.get(self, "bgwriter_lru_maxpages")

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

    @_builtins.property
    @pulumi.getter(name="bgwriterLruMultiplier")
    def bgwriter_lru_multiplier(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The average recent need for new buffers is multiplied by bgwriter*lru*multiplier to arrive at an estimate of the number that will be needed during the next round, (up to bgwriter*lru*maxpages). 1.0 represents a “just in time” policy of writing exactly the number of buffers predicted to be needed. Larger values provide some cushion against spikes in demand, while smaller values intentionally leave writes to be done by server processes. The default is `2.0`. Example: `2`.
        """
        return pulumi.get(self, "bgwriter_lru_multiplier")

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

    @_builtins.property
    @pulumi.getter(name="deadlockTimeout")
    def deadlock_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        This is the amount of time, in milliseconds, to wait on a lock before checking to see if there is a deadlock condition. The default is `1000` (upstream default). Example: `1000`.
        """
        return pulumi.get(self, "deadlock_timeout")

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

    @_builtins.property
    @pulumi.getter(name="defaultToastCompression")
    def default_toast_compression(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `lz4`, `pglz`. Specifies the default TOAST compression method for values of compressible columns. The default is `lz4`.
        """
        return pulumi.get(self, "default_toast_compression")

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

    @_builtins.property
    @pulumi.getter(name="idleInTransactionSessionTimeout")
    def idle_in_transaction_session_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Time out sessions with open transactions after this number of milliseconds.
        """
        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[_builtins.int]]):
        pulumi.set(self, "idle_in_transaction_session_timeout", value)

    @_builtins.property
    @pulumi.getter
    def jit(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Controls system-wide use of Just-in-Time Compilation (JIT).
        """
        return pulumi.get(self, "jit")

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

    @_builtins.property
    @pulumi.getter(name="logAutovacuumMinDuration")
    def log_autovacuum_min_duration(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one disables logging autovacuum actions. The default is `1000`.
        """
        return pulumi.get(self, "log_autovacuum_min_duration")

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

    @_builtins.property
    @pulumi.getter(name="logErrorVerbosity")
    def log_error_verbosity(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `DEFAULT`, `TERSE`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
        """
        return pulumi.get(self, "log_error_verbosity")

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

    @_builtins.property
    @pulumi.getter(name="logLinePrefix")
    def log_line_prefix(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
        """
        return pulumi.get(self, "log_line_prefix")

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

    @_builtins.property
    @pulumi.getter(name="logMinDurationStatement")
    def log_min_duration_statement(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Log statements that take more than this number of milliseconds to run, -1 disables.
        """
        return pulumi.get(self, "log_min_duration_statement")

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

    @_builtins.property
    @pulumi.getter(name="logTempFiles")
    def log_temp_files(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Log statements for each temporary file created larger than this number of kilobytes, -1 disables.
        """
        return pulumi.get(self, "log_temp_files")

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

    @_builtins.property
    @pulumi.getter(name="maxFilesPerProcess")
    def max_files_per_process(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL maximum number of files that can be open per process. The default is `1000` (upstream default). Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "max_files_per_process")

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

    @_builtins.property
    @pulumi.getter(name="maxLocksPerTransaction")
    def max_locks_per_transaction(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL maximum locks per transaction. Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "max_locks_per_transaction")

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

    @_builtins.property
    @pulumi.getter(name="maxLogicalReplicationWorkers")
    def max_logical_replication_workers(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL maximum logical replication workers (taken from the pool of max*parallel*workers). The default is `4` (upstream default). Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "max_logical_replication_workers")

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

    @_builtins.property
    @pulumi.getter(name="maxParallelWorkers")
    def max_parallel_workers(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Sets the maximum number of workers that the system can support for parallel queries. The default is `8` (upstream default).
        """
        return pulumi.get(self, "max_parallel_workers")

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

    @_builtins.property
    @pulumi.getter(name="maxParallelWorkersPerGather")
    def max_parallel_workers_per_gather(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Sets the maximum number of workers that can be started by a single Gather or Gather Merge node. The default is `2` (upstream default).
        """
        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[_builtins.int]]):
        pulumi.set(self, "max_parallel_workers_per_gather", value)

    @_builtins.property
    @pulumi.getter(name="maxPredLocksPerTransaction")
    def max_pred_locks_per_transaction(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL maximum predicate locks per transaction. The default is `64` (upstream default). Changing this parameter causes a service restart.
        """
        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[_builtins.int]]):
        pulumi.set(self, "max_pred_locks_per_transaction", value)

    @_builtins.property
    @pulumi.getter(name="maxPreparedTransactions")
    def max_prepared_transactions(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL maximum prepared transactions. The default is `0`. Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "max_prepared_transactions")

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

    @_builtins.property
    @pulumi.getter(name="maxReplicationSlots")
    def max_replication_slots(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL maximum replication slots. The default is `20`. Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "max_replication_slots")

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

    @_builtins.property
    @pulumi.getter(name="maxSlotWalKeepSize")
    def max_slot_wal_keep_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL maximum WAL size (MB) reserved for replication slots. If `-1` is specified, replication slots may retain an unlimited amount of WAL files. The default is `-1` (upstream default). wal*keep*size minimum WAL size setting takes precedence over this.
        """
        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[_builtins.int]]):
        pulumi.set(self, "max_slot_wal_keep_size", value)

    @_builtins.property
    @pulumi.getter(name="maxStackDepth")
    def max_stack_depth(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum depth of the stack in bytes. The default is `2097152` (upstream default).
        """
        return pulumi.get(self, "max_stack_depth")

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

    @_builtins.property
    @pulumi.getter(name="maxStandbyArchiveDelay")
    def max_standby_archive_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Max standby archive delay in milliseconds. The default is `30000` (upstream default).
        """
        return pulumi.get(self, "max_standby_archive_delay")

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

    @_builtins.property
    @pulumi.getter(name="maxStandbyStreamingDelay")
    def max_standby_streaming_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Max standby streaming delay in milliseconds. The default is `30000` (upstream default).
        """
        return pulumi.get(self, "max_standby_streaming_delay")

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

    @_builtins.property
    @pulumi.getter(name="maxSyncWorkersPerSubscription")
    def max_sync_workers_per_subscription(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum number of synchronization workers per subscription. The default is `2`.
        """
        return pulumi.get(self, "max_sync_workers_per_subscription")

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

    @_builtins.property
    @pulumi.getter(name="maxWalSenders")
    def max_wal_senders(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL maximum WAL senders. The default is `20`. Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "max_wal_senders")

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

    @_builtins.property
    @pulumi.getter(name="maxWorkerProcesses")
    def max_worker_processes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Sets the maximum number of background processes that the system can support. The default is `8`. Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "max_worker_processes")

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

    @_builtins.property
    @pulumi.getter(name="passwordEncryption")
    def password_encryption(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `md5`, `scram-sha-256`. Chooses the algorithm for encrypting passwords.
        """
        return pulumi.get(self, "password_encryption")

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

    @_builtins.property
    @pulumi.getter(name="pgPartmanBgwDotInterval")
    def pg_partman_bgw_dot_interval(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Sets the time interval in seconds to run pg_partman's scheduled tasks. The default is `3600`. Example: `3600`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "pg_partman_bgw_dot_interval", value)

    @_builtins.property
    @pulumi.getter(name="pgPartmanBgwDotRole")
    def pg_partman_bgw_dot_role(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Controls which role to use for pg_partman's scheduled background tasks. Example: `myrolename`.
        """
        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[_builtins.str]]):
        pulumi.set(self, "pg_partman_bgw_dot_role", value)

    @_builtins.property
    @pulumi.getter(name="pgStatStatementsDotTrack")
    def pg_stat_statements_dot_track(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `all`, `none`, `top`. Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default is `top`.
        """
        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[_builtins.str]]):
        pulumi.set(self, "pg_stat_statements_dot_track", value)

    @_builtins.property
    @pulumi.getter(name="tempFileLimit")
    def temp_file_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL temporary file limit in KiB, -1 for unlimited.
        """
        return pulumi.get(self, "temp_file_limit")

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

    @_builtins.property
    @pulumi.getter
    def timezone(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PostgreSQL service timezone. Example: `Europe/Helsinki`.
        """
        return pulumi.get(self, "timezone")

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

    @_builtins.property
    @pulumi.getter(name="trackActivityQuerySize")
    def track_activity_query_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the number of bytes reserved to track the currently executing command for each active session. Changing this parameter causes a service restart. Example: `1024`.
        """
        return pulumi.get(self, "track_activity_query_size")

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

    @_builtins.property
    @pulumi.getter(name="trackCommitTimestamp")
    def track_commit_timestamp(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `off`, `on`. Record commit time of transactions. Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "track_commit_timestamp")

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

    @_builtins.property
    @pulumi.getter(name="trackFunctions")
    def track_functions(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `all`, `none`, `pl`. Enables tracking of function call counts and time used.
        """
        return pulumi.get(self, "track_functions")

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

    @_builtins.property
    @pulumi.getter(name="trackIoTiming")
    def track_io_timing(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `off`, `on`. Enables timing of database I/O calls. The default is `off`. When on, it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms.
        """
        return pulumi.get(self, "track_io_timing")

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

    @_builtins.property
    @pulumi.getter(name="walSenderTimeout")
    def wal_sender_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Terminate replication connections that are inactive for longer than this amount of time, in milliseconds. Setting this value to zero disables the timeout. Example: `60000`.
        """
        return pulumi.get(self, "wal_sender_timeout")

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

    @_builtins.property
    @pulumi.getter(name="walWriterDelay")
    def wal_writer_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        WAL flush interval in milliseconds. The default is `200`. Setting this parameter to a lower value may negatively impact performance. Example: `50`.
        """
        return pulumi.get(self, "wal_writer_delay")

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


if not MYPY:
    class AlloydbomniAlloydbomniUserConfigPgauditArgsDict(TypedDict):
        feature_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable pgaudit extension. When enabled, pgaudit extension will be automatically installed.Otherwise, extension will be uninstalled but auditing configurations will be preserved. Default: `false`.
        """
        log_catalog: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Specifies that session logging should be enabled in the case where all relations in a statement are in pg_catalog. Default: `true`.
        """
        log_client: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Specifies whether log messages will be visible to a client process such as psql. Default: `false`.
        """
        log_level: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `debug1`, `debug2`, `debug3`, `debug4`, `debug5`, `info`, `log`, `notice`, `warning`. Specifies the log level that will be used for log entries. Default: `log`.
        """
        log_max_string_length: NotRequired[pulumi.Input[_builtins.int]]
        """
        Crop parameters representation and whole statements if they exceed this threshold. A (default) value of -1 disable the truncation. Default: `-1`.
        """
        log_nested_statements: NotRequired[pulumi.Input[_builtins.bool]]
        """
        This GUC allows to turn off logging nested statements, that is, statements that are executed as part of another ExecutorRun. Default: `true`.
        """
        log_parameter: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Specifies that audit logging should include the parameters that were passed with the statement. Default: `false`.
        """
        log_parameter_max_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies that parameter values longer than this setting (in bytes) should not be logged, but replaced with \\n\\n. Default: `0`.
        """
        log_relation: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Specifies whether session audit logging should create a separate log entry for each relation (TABLE, VIEW, etc.) referenced in a SELECT or DML statement. Default: `false`.
        """
        log_rows: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Log Rows. Default: `false`.
        """
        log_statement: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Specifies whether logging will include the statement text and parameters (if enabled). Default: `true`.
        """
        log_statement_once: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Specifies whether logging will include the statement text and parameters with the first log entry for a statement/substatement combination or with every entry. Default: `false`.
        """
        logs: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Specifies which classes of statements will be logged by session audit logging.
        """
        role: NotRequired[pulumi.Input[_builtins.str]]
        """
        Specifies the master role to use for object audit logging.
        """
elif False:
    AlloydbomniAlloydbomniUserConfigPgauditArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlloydbomniAlloydbomniUserConfigPgauditArgs:
    def __init__(__self__, *,
                 feature_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_catalog: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_client: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_level: Optional[pulumi.Input[_builtins.str]] = None,
                 log_max_string_length: Optional[pulumi.Input[_builtins.int]] = None,
                 log_nested_statements: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_parameter: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_parameter_max_size: Optional[pulumi.Input[_builtins.int]] = None,
                 log_relation: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_rows: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_statement: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_statement_once: Optional[pulumi.Input[_builtins.bool]] = None,
                 logs: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 role: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.bool] feature_enabled: Enable pgaudit extension. When enabled, pgaudit extension will be automatically installed.Otherwise, extension will be uninstalled but auditing configurations will be preserved. Default: `false`.
        :param pulumi.Input[_builtins.bool] log_catalog: Specifies that session logging should be enabled in the case where all relations in a statement are in pg_catalog. Default: `true`.
        :param pulumi.Input[_builtins.bool] log_client: Specifies whether log messages will be visible to a client process such as psql. Default: `false`.
        :param pulumi.Input[_builtins.str] log_level: Enum: `debug1`, `debug2`, `debug3`, `debug4`, `debug5`, `info`, `log`, `notice`, `warning`. Specifies the log level that will be used for log entries. Default: `log`.
        :param pulumi.Input[_builtins.int] log_max_string_length: Crop parameters representation and whole statements if they exceed this threshold. A (default) value of -1 disable the truncation. Default: `-1`.
        :param pulumi.Input[_builtins.bool] log_nested_statements: This GUC allows to turn off logging nested statements, that is, statements that are executed as part of another ExecutorRun. Default: `true`.
        :param pulumi.Input[_builtins.bool] log_parameter: Specifies that audit logging should include the parameters that were passed with the statement. Default: `false`.
        :param pulumi.Input[_builtins.int] log_parameter_max_size: Specifies that parameter values longer than this setting (in bytes) should not be logged, but replaced with \\n\\n. Default: `0`.
        :param pulumi.Input[_builtins.bool] log_relation: Specifies whether session audit logging should create a separate log entry for each relation (TABLE, VIEW, etc.) referenced in a SELECT or DML statement. Default: `false`.
        :param pulumi.Input[_builtins.bool] log_rows: Log Rows. Default: `false`.
        :param pulumi.Input[_builtins.bool] log_statement: Specifies whether logging will include the statement text and parameters (if enabled). Default: `true`.
        :param pulumi.Input[_builtins.bool] log_statement_once: Specifies whether logging will include the statement text and parameters with the first log entry for a statement/substatement combination or with every entry. Default: `false`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] logs: Specifies which classes of statements will be logged by session audit logging.
        :param pulumi.Input[_builtins.str] role: Specifies the master role to use for object audit logging.
        """
        if feature_enabled is not None:
            pulumi.set(__self__, "feature_enabled", feature_enabled)
        if log_catalog is not None:
            pulumi.set(__self__, "log_catalog", log_catalog)
        if log_client is not None:
            pulumi.set(__self__, "log_client", log_client)
        if log_level is not None:
            pulumi.set(__self__, "log_level", log_level)
        if log_max_string_length is not None:
            pulumi.set(__self__, "log_max_string_length", log_max_string_length)
        if log_nested_statements is not None:
            pulumi.set(__self__, "log_nested_statements", log_nested_statements)
        if log_parameter is not None:
            pulumi.set(__self__, "log_parameter", log_parameter)
        if log_parameter_max_size is not None:
            pulumi.set(__self__, "log_parameter_max_size", log_parameter_max_size)
        if log_relation is not None:
            pulumi.set(__self__, "log_relation", log_relation)
        if log_rows is not None:
            pulumi.set(__self__, "log_rows", log_rows)
        if log_statement is not None:
            pulumi.set(__self__, "log_statement", log_statement)
        if log_statement_once is not None:
            pulumi.set(__self__, "log_statement_once", log_statement_once)
        if logs is not None:
            pulumi.set(__self__, "logs", logs)
        if role is not None:
            pulumi.set(__self__, "role", role)

    @_builtins.property
    @pulumi.getter(name="featureEnabled")
    def feature_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable pgaudit extension. When enabled, pgaudit extension will be automatically installed.Otherwise, extension will be uninstalled but auditing configurations will be preserved. Default: `false`.
        """
        return pulumi.get(self, "feature_enabled")

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

    @_builtins.property
    @pulumi.getter(name="logCatalog")
    def log_catalog(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Specifies that session logging should be enabled in the case where all relations in a statement are in pg_catalog. Default: `true`.
        """
        return pulumi.get(self, "log_catalog")

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

    @_builtins.property
    @pulumi.getter(name="logClient")
    def log_client(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Specifies whether log messages will be visible to a client process such as psql. Default: `false`.
        """
        return pulumi.get(self, "log_client")

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

    @_builtins.property
    @pulumi.getter(name="logLevel")
    def log_level(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `debug1`, `debug2`, `debug3`, `debug4`, `debug5`, `info`, `log`, `notice`, `warning`. Specifies the log level that will be used for log entries. Default: `log`.
        """
        return pulumi.get(self, "log_level")

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

    @_builtins.property
    @pulumi.getter(name="logMaxStringLength")
    def log_max_string_length(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Crop parameters representation and whole statements if they exceed this threshold. A (default) value of -1 disable the truncation. Default: `-1`.
        """
        return pulumi.get(self, "log_max_string_length")

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

    @_builtins.property
    @pulumi.getter(name="logNestedStatements")
    def log_nested_statements(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        This GUC allows to turn off logging nested statements, that is, statements that are executed as part of another ExecutorRun. Default: `true`.
        """
        return pulumi.get(self, "log_nested_statements")

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

    @_builtins.property
    @pulumi.getter(name="logParameter")
    def log_parameter(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Specifies that audit logging should include the parameters that were passed with the statement. Default: `false`.
        """
        return pulumi.get(self, "log_parameter")

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

    @_builtins.property
    @pulumi.getter(name="logParameterMaxSize")
    def log_parameter_max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies that parameter values longer than this setting (in bytes) should not be logged, but replaced with \\n\\n. Default: `0`.
        """
        return pulumi.get(self, "log_parameter_max_size")

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

    @_builtins.property
    @pulumi.getter(name="logRelation")
    def log_relation(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Specifies whether session audit logging should create a separate log entry for each relation (TABLE, VIEW, etc.) referenced in a SELECT or DML statement. Default: `false`.
        """
        return pulumi.get(self, "log_relation")

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

    @_builtins.property
    @pulumi.getter(name="logRows")
    def log_rows(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Log Rows. Default: `false`.
        """
        return pulumi.get(self, "log_rows")

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

    @_builtins.property
    @pulumi.getter(name="logStatement")
    def log_statement(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Specifies whether logging will include the statement text and parameters (if enabled). Default: `true`.
        """
        return pulumi.get(self, "log_statement")

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

    @_builtins.property
    @pulumi.getter(name="logStatementOnce")
    def log_statement_once(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Specifies whether logging will include the statement text and parameters with the first log entry for a statement/substatement combination or with every entry. Default: `false`.
        """
        return pulumi.get(self, "log_statement_once")

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

    @_builtins.property
    @pulumi.getter
    def logs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Specifies which classes of statements will be logged by session audit logging.
        """
        return pulumi.get(self, "logs")

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

    @_builtins.property
    @pulumi.getter
    def role(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Specifies the master role to use for object audit logging.
        """
        return pulumi.get(self, "role")

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


if not MYPY:
    class AlloydbomniAlloydbomniUserConfigPgbouncerArgsDict(TypedDict):
        autodb_idle_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        If the automatically created database pools have been unused this many seconds, they are freed. If 0 then timeout is disabled. (seconds). Default: `3600`.
        """
        autodb_max_db_connections: NotRequired[pulumi.Input[_builtins.int]]
        """
        Do not allow more than this many server connections per database (regardless of user). Setting it to 0 means unlimited. Example: `0`.
        """
        autodb_pool_mode: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `session`, `statement`, `transaction`. PGBouncer pool mode. Default: `transaction`.
        """
        autodb_pool_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        If non-zero then create automatically a pool of that size per user when a pool doesn't exist. Default: `0`.
        """
        ignore_startup_parameters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        List of parameters to ignore when given in startup packet.
        """
        max_prepared_statements: NotRequired[pulumi.Input[_builtins.int]]
        """
        PgBouncer tracks protocol-level named prepared statements related commands sent by the client in transaction and statement pooling modes when max*prepared*statements is set to a non-zero value. Setting it to 0 disables prepared statements. max*prepared*statements defaults to 100, and its maximum is 3000. Default: `100`.
        """
        min_pool_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Add more server connections to pool if below this number. Improves behavior when usual load comes suddenly back after period of total inactivity. The value is effectively capped at the pool size. Default: `0`.
        """
        server_idle_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        If a server connection has been idle more than this many seconds it will be dropped. If 0 then timeout is disabled. (seconds). Default: `600`.
        """
        server_lifetime: NotRequired[pulumi.Input[_builtins.int]]
        """
        The pooler will close an unused server connection that has been connected longer than this. (seconds). Default: `3600`.
        """
        server_reset_query_always: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Run server*reset*query (DISCARD ALL) in all pooling modes. Default: `false`.
        """
elif False:
    AlloydbomniAlloydbomniUserConfigPgbouncerArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlloydbomniAlloydbomniUserConfigPgbouncerArgs:
    def __init__(__self__, *,
                 autodb_idle_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 autodb_max_db_connections: Optional[pulumi.Input[_builtins.int]] = None,
                 autodb_pool_mode: Optional[pulumi.Input[_builtins.str]] = None,
                 autodb_pool_size: Optional[pulumi.Input[_builtins.int]] = None,
                 ignore_startup_parameters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 max_prepared_statements: Optional[pulumi.Input[_builtins.int]] = None,
                 min_pool_size: Optional[pulumi.Input[_builtins.int]] = None,
                 server_idle_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 server_lifetime: Optional[pulumi.Input[_builtins.int]] = None,
                 server_reset_query_always: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.int] autodb_idle_timeout: If the automatically created database pools have been unused this many seconds, they are freed. If 0 then timeout is disabled. (seconds). Default: `3600`.
        :param pulumi.Input[_builtins.int] autodb_max_db_connections: Do not allow more than this many server connections per database (regardless of user). Setting it to 0 means unlimited. Example: `0`.
        :param pulumi.Input[_builtins.str] autodb_pool_mode: Enum: `session`, `statement`, `transaction`. PGBouncer pool mode. Default: `transaction`.
        :param pulumi.Input[_builtins.int] autodb_pool_size: If non-zero then create automatically a pool of that size per user when a pool doesn't exist. Default: `0`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ignore_startup_parameters: List of parameters to ignore when given in startup packet.
        :param pulumi.Input[_builtins.int] max_prepared_statements: PgBouncer tracks protocol-level named prepared statements related commands sent by the client in transaction and statement pooling modes when max*prepared*statements is set to a non-zero value. Setting it to 0 disables prepared statements. max*prepared*statements defaults to 100, and its maximum is 3000. Default: `100`.
        :param pulumi.Input[_builtins.int] min_pool_size: Add more server connections to pool if below this number. Improves behavior when usual load comes suddenly back after period of total inactivity. The value is effectively capped at the pool size. Default: `0`.
        :param pulumi.Input[_builtins.int] server_idle_timeout: If a server connection has been idle more than this many seconds it will be dropped. If 0 then timeout is disabled. (seconds). Default: `600`.
        :param pulumi.Input[_builtins.int] server_lifetime: The pooler will close an unused server connection that has been connected longer than this. (seconds). Default: `3600`.
        :param pulumi.Input[_builtins.bool] server_reset_query_always: Run server*reset*query (DISCARD ALL) in all pooling modes. Default: `false`.
        """
        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 max_prepared_statements is not None:
            pulumi.set(__self__, "max_prepared_statements", max_prepared_statements)
        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)

    @_builtins.property
    @pulumi.getter(name="autodbIdleTimeout")
    def autodb_idle_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        If the automatically created database pools have been unused this many seconds, they are freed. If 0 then timeout is disabled. (seconds). Default: `3600`.
        """
        return pulumi.get(self, "autodb_idle_timeout")

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

    @_builtins.property
    @pulumi.getter(name="autodbMaxDbConnections")
    def autodb_max_db_connections(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Do not allow more than this many server connections per database (regardless of user). Setting it to 0 means unlimited. Example: `0`.
        """
        return pulumi.get(self, "autodb_max_db_connections")

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

    @_builtins.property
    @pulumi.getter(name="autodbPoolMode")
    def autodb_pool_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `session`, `statement`, `transaction`. PGBouncer pool mode. Default: `transaction`.
        """
        return pulumi.get(self, "autodb_pool_mode")

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

    @_builtins.property
    @pulumi.getter(name="autodbPoolSize")
    def autodb_pool_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        If non-zero then create automatically a pool of that size per user when a pool doesn't exist. Default: `0`.
        """
        return pulumi.get(self, "autodb_pool_size")

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

    @_builtins.property
    @pulumi.getter(name="ignoreStartupParameters")
    def ignore_startup_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        List of parameters to ignore when given in startup packet.
        """
        return pulumi.get(self, "ignore_startup_parameters")

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

    @_builtins.property
    @pulumi.getter(name="maxPreparedStatements")
    def max_prepared_statements(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PgBouncer tracks protocol-level named prepared statements related commands sent by the client in transaction and statement pooling modes when max*prepared*statements is set to a non-zero value. Setting it to 0 disables prepared statements. max*prepared*statements defaults to 100, and its maximum is 3000. Default: `100`.
        """
        return pulumi.get(self, "max_prepared_statements")

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

    @_builtins.property
    @pulumi.getter(name="minPoolSize")
    def min_pool_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Add more server connections to pool if below this number. Improves behavior when usual load comes suddenly back after period of total inactivity. The value is effectively capped at the pool size. Default: `0`.
        """
        return pulumi.get(self, "min_pool_size")

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

    @_builtins.property
    @pulumi.getter(name="serverIdleTimeout")
    def server_idle_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        If a server connection has been idle more than this many seconds it will be dropped. If 0 then timeout is disabled. (seconds). Default: `600`.
        """
        return pulumi.get(self, "server_idle_timeout")

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

    @_builtins.property
    @pulumi.getter(name="serverLifetime")
    def server_lifetime(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The pooler will close an unused server connection that has been connected longer than this. (seconds). Default: `3600`.
        """
        return pulumi.get(self, "server_lifetime")

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

    @_builtins.property
    @pulumi.getter(name="serverResetQueryAlways")
    def server_reset_query_always(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Run server*reset*query (DISCARD ALL) in all pooling modes. Default: `false`.
        """
        return pulumi.get(self, "server_reset_query_always")

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


if not MYPY:
    class AlloydbomniAlloydbomniUserConfigPglookoutArgsDict(TypedDict):
        max_failover_replication_time_lag: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of seconds of master unavailability before triggering database failover to standby. Default: `60`.
        """
elif False:
    AlloydbomniAlloydbomniUserConfigPglookoutArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlloydbomniAlloydbomniUserConfigPglookoutArgs:
    def __init__(__self__, *,
                 max_failover_replication_time_lag: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.int] max_failover_replication_time_lag: Number of seconds of master unavailability before triggering database failover to standby. Default: `60`.
        """
        if max_failover_replication_time_lag is not None:
            pulumi.set(__self__, "max_failover_replication_time_lag", max_failover_replication_time_lag)

    @_builtins.property
    @pulumi.getter(name="maxFailoverReplicationTimeLag")
    def max_failover_replication_time_lag(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of seconds of master unavailability before triggering database failover to standby. Default: `60`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "max_failover_replication_time_lag", value)


if not MYPY:
    class AlloydbomniAlloydbomniUserConfigPrivateAccessArgsDict(TypedDict):
        pg: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to pg with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        pgbouncer: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to pgbouncer with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
elif False:
    AlloydbomniAlloydbomniUserConfigPrivateAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlloydbomniAlloydbomniUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 pg: Optional[pulumi.Input[_builtins.bool]] = None,
                 pgbouncer: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] pg: Allow clients to connect to pg with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] pgbouncer: Allow clients to connect to pgbouncer with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        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)

    @_builtins.property
    @pulumi.getter
    def pg(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to pg with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "pg")

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

    @_builtins.property
    @pulumi.getter
    def pgbouncer(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to pgbouncer with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "pgbouncer")

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

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "prometheus")

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


if not MYPY:
    class AlloydbomniAlloydbomniUserConfigPrivatelinkAccessArgsDict(TypedDict):
        pg: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable pg.
        """
        pgbouncer: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable pgbouncer.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable prometheus.
        """
elif False:
    AlloydbomniAlloydbomniUserConfigPrivatelinkAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlloydbomniAlloydbomniUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 pg: Optional[pulumi.Input[_builtins.bool]] = None,
                 pgbouncer: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] pg: Enable pg.
        :param pulumi.Input[_builtins.bool] pgbouncer: Enable pgbouncer.
        :param pulumi.Input[_builtins.bool] prometheus: Enable prometheus.
        """
        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)

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

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

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

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

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

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


if not MYPY:
    class AlloydbomniAlloydbomniUserConfigPublicAccessArgsDict(TypedDict):
        pg: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to pg from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        pgbouncer: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to pgbouncer from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
elif False:
    AlloydbomniAlloydbomniUserConfigPublicAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlloydbomniAlloydbomniUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 pg: Optional[pulumi.Input[_builtins.bool]] = None,
                 pgbouncer: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] pg: Allow clients to connect to pg from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] pgbouncer: Allow clients to connect to pgbouncer from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        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)

    @_builtins.property
    @pulumi.getter
    def pg(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to pg from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "pg")

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

    @_builtins.property
    @pulumi.getter
    def pgbouncer(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to pgbouncer from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "pgbouncer")

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

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "prometheus")

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


if not MYPY:
    class AlloydbomniComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    AlloydbomniComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlloydbomniComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

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

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

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

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

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

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

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

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

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

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

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

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

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

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

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

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

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

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


if not MYPY:
    class AlloydbomniServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration. The possible value is `read_replica`.
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    AlloydbomniServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlloydbomniServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration. The possible value is `read_replica`.
        :param pulumi.Input[_builtins.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)

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

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

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class AlloydbomniTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    AlloydbomniTagArgsDict: TypeAlias = Mapping[str, Any]

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

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

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

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

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


if not MYPY:
    class AlloydbomniTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    AlloydbomniTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class AlloydbomniTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

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


if not MYPY:
    class BillingGroupTimeoutsArgsDict(TypedDict):
        create: NotRequired[pulumi.Input[_builtins.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).
        """
        default: NotRequired[pulumi.Input[_builtins.str]]
        """
        Timeout for all operations. Deprecated, use operation-specific timeouts instead.
        """
        delete: NotRequired[pulumi.Input[_builtins.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.
        """
        read: NotRequired[pulumi.Input[_builtins.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.
        """
        update: NotRequired[pulumi.Input[_builtins.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).
        """
elif False:
    BillingGroupTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class BillingGroupTimeoutsArgs:
    def __init__(__self__, *,
                 create: Optional[pulumi.Input[_builtins.str]] = None,
                 default: Optional[pulumi.Input[_builtins.str]] = None,
                 delete: Optional[pulumi.Input[_builtins.str]] = None,
                 read: Optional[pulumi.Input[_builtins.str]] = None,
                 update: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.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[_builtins.str] default: Timeout for all operations. Deprecated, use operation-specific timeouts instead.
        :param pulumi.Input[_builtins.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[_builtins.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[_builtins.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 default is not None:
            warnings.warn("""Use operation-specific timeouts instead. This field will be removed in the next major version.""", DeprecationWarning)
            pulumi.log.warn("""default is deprecated: Use operation-specific timeouts instead. This field will be removed in the next major version.""")
        if default is not None:
            pulumi.set(__self__, "default", default)
        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)

    @_builtins.property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "create", value)

    @_builtins.property
    @pulumi.getter
    @_utilities.deprecated("""Use operation-specific timeouts instead. This field will be removed in the next major version.""")
    def default(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Timeout for all operations. Deprecated, use operation-specific timeouts instead.
        """
        return pulumi.get(self, "default")

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

    @_builtins.property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "delete", value)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "read", value)

    @_builtins.property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "update", value)


if not MYPY:
    class CassandraCassandraArgsDict(TypedDict):
        uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Cassandra server URIs.
        """
elif False:
    CassandraCassandraArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CassandraCassandraArgs:
    def __init__(__self__, *,
                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uris: Cassandra server URIs.
        """
        if uris is not None:
            pulumi.set(__self__, "uris", uris)

    @_builtins.property
    @pulumi.getter
    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Cassandra server URIs.
        """
        return pulumi.get(self, "uris")

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


if not MYPY:
    class CassandraCassandraUserConfigArgsDict(TypedDict):
        additional_backup_regions: NotRequired[pulumi.Input[_builtins.str]]
        """
        Additional Cloud Regions for Backup Replication.
        """
        backup_hour: NotRequired[pulumi.Input[_builtins.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. Example: `3`.
        """
        backup_minute: NotRequired[pulumi.Input[_builtins.int]]
        """
        The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed. Example: `30`.
        """
        cassandra: NotRequired[pulumi.Input['CassandraCassandraUserConfigCassandraArgsDict']]
        """
        Cassandra configuration values
        """
        cassandra_version: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `3`, `4`, `4.1`, and newer. Cassandra version.
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['CassandraCassandraUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        migrate_sstableloader: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Sets the service into migration mode enabling the sstableloader utility to be used to upload Cassandra data files. Available only on service create.
        """
        private_access: NotRequired[pulumi.Input['CassandraCassandraUserConfigPrivateAccessArgsDict']]
        """
        Allow access to selected service ports from private networks
        """
        project_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        public_access: NotRequired[pulumi.Input['CassandraCassandraUserConfigPublicAccessArgsDict']]
        """
        Allow access to selected service ports from the public Internet
        """
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        service_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        service_to_join_with: NotRequired[pulumi.Input[_builtins.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. Example: `my-test-cassandra`.
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
elif False:
    CassandraCassandraUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CassandraCassandraUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[_builtins.str]] = None,
                 backup_hour: Optional[pulumi.Input[_builtins.int]] = None,
                 backup_minute: Optional[pulumi.Input[_builtins.int]] = None,
                 cassandra: Optional[pulumi.Input['CassandraCassandraUserConfigCassandraArgs']] = None,
                 cassandra_version: Optional[pulumi.Input[_builtins.str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['CassandraCassandraUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 migrate_sstableloader: Optional[pulumi.Input[_builtins.bool]] = None,
                 private_access: Optional[pulumi.Input['CassandraCassandraUserConfigPrivateAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 public_access: Optional[pulumi.Input['CassandraCassandraUserConfigPublicAccessArgs']] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 service_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 service_to_join_with: Optional[pulumi.Input[_builtins.str]] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[_builtins.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. Example: `3`.
        :param pulumi.Input[_builtins.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. Example: `30`.
        :param pulumi.Input['CassandraCassandraUserConfigCassandraArgs'] cassandra: Cassandra configuration values
        :param pulumi.Input[_builtins.str] cassandra_version: Enum: `3`, `4`, `4.1`, and newer. Cassandra 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[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[_builtins.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[_builtins.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. Example: `anotherprojectname`.
        :param pulumi.Input['CassandraCassandraUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input[_builtins.str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        :param pulumi.Input[_builtins.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. Example: `my-test-cassandra`.
        :param pulumi.Input[_builtins.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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `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_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        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)

    @_builtins.property
    @pulumi.getter(name="additionalBackupRegions")
    def additional_backup_regions(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @_builtins.property
    @pulumi.getter(name="backupHour")
    def backup_hour(self) -> Optional[pulumi.Input[_builtins.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. Example: `3`.
        """
        return pulumi.get(self, "backup_hour")

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

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

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

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="cassandraVersion")
    def cassandra_version(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `3`, `4`, `4.1`, and newer. Cassandra version.
        """
        return pulumi.get(self, "cassandra_version")

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

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

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

    @_builtins.property
    @pulumi.getter(name="migrateSstableloader")
    def migrate_sstableloader(self) -> Optional[pulumi.Input[_builtins.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[_builtins.bool]]):
        pulumi.set(self, "migrate_sstableloader", value)

    @_builtins.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)

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

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

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

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

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

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

    @_builtins.property
    @pulumi.getter(name="serviceToJoinWith")
    def service_to_join_with(self) -> Optional[pulumi.Input[_builtins.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. Example: `my-test-cassandra`.
        """
        return pulumi.get(self, "service_to_join_with")

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

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

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


if not MYPY:
    class CassandraCassandraUserConfigCassandraArgsDict(TypedDict):
        batch_size_fail_threshold_in_kb: NotRequired[pulumi.Input[_builtins.int]]
        """
        Fail any multiple-partition batch exceeding this value. 50kb (10x warn threshold) by default. Example: `50`.
        """
        batch_size_warn_threshold_in_kb: NotRequired[pulumi.Input[_builtins.int]]
        """
        Log a warning message on any multiple-partition batch size exceeding this value.5kb per batch by default.Caution should be taken on increasing the size of this thresholdas it can lead to node instability. Example: `5`.
        """
        datacenter: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of the datacenter to which nodes of this service belong. Can be set only when creating the service. Example: `my-service-google-west1`.
        """
        read_request_timeout_in_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        How long the coordinator waits for read operations to complete before timing it out. 5 seconds by default. Example: `5000`.
        """
        write_request_timeout_in_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        How long the coordinator waits for write requests to complete with at least one node in the local datacenter. 2 seconds by default. Example: `2000`.
        """
elif False:
    CassandraCassandraUserConfigCassandraArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CassandraCassandraUserConfigCassandraArgs:
    def __init__(__self__, *,
                 batch_size_fail_threshold_in_kb: Optional[pulumi.Input[_builtins.int]] = None,
                 batch_size_warn_threshold_in_kb: Optional[pulumi.Input[_builtins.int]] = None,
                 datacenter: Optional[pulumi.Input[_builtins.str]] = None,
                 read_request_timeout_in_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 write_request_timeout_in_ms: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.int] batch_size_fail_threshold_in_kb: Fail any multiple-partition batch exceeding this value. 50kb (10x warn threshold) by default. Example: `50`.
        :param pulumi.Input[_builtins.int] batch_size_warn_threshold_in_kb: Log a warning message on any multiple-partition batch size exceeding this value.5kb per batch by default.Caution should be taken on increasing the size of this thresholdas it can lead to node instability. Example: `5`.
        :param pulumi.Input[_builtins.str] datacenter: Name of the datacenter to which nodes of this service belong. Can be set only when creating the service. Example: `my-service-google-west1`.
        :param pulumi.Input[_builtins.int] read_request_timeout_in_ms: How long the coordinator waits for read operations to complete before timing it out. 5 seconds by default. Example: `5000`.
        :param pulumi.Input[_builtins.int] write_request_timeout_in_ms: How long the coordinator waits for write requests to complete with at least one node in the local datacenter. 2 seconds by default. Example: `2000`.
        """
        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)
        if read_request_timeout_in_ms is not None:
            pulumi.set(__self__, "read_request_timeout_in_ms", read_request_timeout_in_ms)
        if write_request_timeout_in_ms is not None:
            pulumi.set(__self__, "write_request_timeout_in_ms", write_request_timeout_in_ms)

    @_builtins.property
    @pulumi.getter(name="batchSizeFailThresholdInKb")
    def batch_size_fail_threshold_in_kb(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Fail any multiple-partition batch exceeding this value. 50kb (10x warn threshold) by default. Example: `50`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "batch_size_fail_threshold_in_kb", value)

    @_builtins.property
    @pulumi.getter(name="batchSizeWarnThresholdInKb")
    def batch_size_warn_threshold_in_kb(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Log a warning message on any multiple-partition batch size exceeding this value.5kb per batch by default.Caution should be taken on increasing the size of this thresholdas it can lead to node instability. Example: `5`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "batch_size_warn_threshold_in_kb", value)

    @_builtins.property
    @pulumi.getter
    def datacenter(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of the datacenter to which nodes of this service belong. Can be set only when creating the service. Example: `my-service-google-west1`.
        """
        return pulumi.get(self, "datacenter")

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

    @_builtins.property
    @pulumi.getter(name="readRequestTimeoutInMs")
    def read_request_timeout_in_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        How long the coordinator waits for read operations to complete before timing it out. 5 seconds by default. Example: `5000`.
        """
        return pulumi.get(self, "read_request_timeout_in_ms")

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

    @_builtins.property
    @pulumi.getter(name="writeRequestTimeoutInMs")
    def write_request_timeout_in_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        How long the coordinator waits for write requests to complete with at least one node in the local datacenter. 2 seconds by default. Example: `2000`.
        """
        return pulumi.get(self, "write_request_timeout_in_ms")

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


if not MYPY:
    class CassandraCassandraUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    CassandraCassandraUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CassandraCassandraUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

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

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

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


if not MYPY:
    class CassandraCassandraUserConfigPrivateAccessArgsDict(TypedDict):
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
elif False:
    CassandraCassandraUserConfigPrivateAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CassandraCassandraUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "prometheus")

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


if not MYPY:
    class CassandraCassandraUserConfigPublicAccessArgsDict(TypedDict):
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
elif False:
    CassandraCassandraUserConfigPublicAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CassandraCassandraUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "prometheus")

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


if not MYPY:
    class CassandraComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    CassandraComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CassandraComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

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

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

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

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

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

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

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

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

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

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

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

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

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

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

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

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

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

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


if not MYPY:
    class CassandraServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    CassandraServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CassandraServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration
        :param pulumi.Input[_builtins.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)

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

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

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class CassandraTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    CassandraTagArgsDict: TypeAlias = Mapping[str, Any]

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

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

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

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

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


if not MYPY:
    class CassandraTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    CassandraTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class CassandraTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

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


if not MYPY:
    class ClickhouseClickhouseArgsDict(TypedDict):
        uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        ClickHouse server URIs.
        """
elif False:
    ClickhouseClickhouseArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClickhouseClickhouseArgs:
    def __init__(__self__, *,
                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uris: ClickHouse server URIs.
        """
        if uris is not None:
            pulumi.set(__self__, "uris", uris)

    @_builtins.property
    @pulumi.getter
    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        ClickHouse server URIs.
        """
        return pulumi.get(self, "uris")

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


if not MYPY:
    class ClickhouseClickhouseUserConfigArgsDict(TypedDict):
        additional_backup_regions: NotRequired[pulumi.Input[_builtins.str]]
        """
        Additional Cloud Regions for Backup Replication.
        """
        backup_hour: NotRequired[pulumi.Input[_builtins.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. Example: `3`.
        """
        backup_minute: NotRequired[pulumi.Input[_builtins.int]]
        """
        The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed. Example: `30`.
        """
        enable_ipv6: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Register AAAA DNS records for the service, and allow IPv6 packets to service ports.
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['ClickhouseClickhouseUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        private_access: NotRequired[pulumi.Input['ClickhouseClickhouseUserConfigPrivateAccessArgsDict']]
        """
        Allow access to selected service ports from private networks
        """
        privatelink_access: NotRequired[pulumi.Input['ClickhouseClickhouseUserConfigPrivatelinkAccessArgsDict']]
        """
        Allow access to selected service components through Privatelink
        """
        project_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        public_access: NotRequired[pulumi.Input['ClickhouseClickhouseUserConfigPublicAccessArgsDict']]
        """
        Allow access to selected service ports from the public Internet
        """
        recovery_basebackup_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of the basebackup to restore in forked service. Example: `backup-20191112t091354293891z`.
        """
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        service_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
elif False:
    ClickhouseClickhouseUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClickhouseClickhouseUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[_builtins.str]] = None,
                 backup_hour: Optional[pulumi.Input[_builtins.int]] = None,
                 backup_minute: Optional[pulumi.Input[_builtins.int]] = None,
                 enable_ipv6: Optional[pulumi.Input[_builtins.bool]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['ClickhouseClickhouseUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 private_access: Optional[pulumi.Input['ClickhouseClickhouseUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['ClickhouseClickhouseUserConfigPrivatelinkAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 public_access: Optional[pulumi.Input['ClickhouseClickhouseUserConfigPublicAccessArgs']] = None,
                 recovery_basebackup_name: Optional[pulumi.Input[_builtins.str]] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 service_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[_builtins.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. Example: `3`.
        :param pulumi.Input[_builtins.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. Example: `30`.
        :param pulumi.Input[_builtins.bool] enable_ipv6: Register AAAA DNS records for the service, and allow IPv6 packets to service ports.
        :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[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.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. Example: `anotherprojectname`.
        :param pulumi.Input['ClickhouseClickhouseUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
        :param pulumi.Input[_builtins.str] recovery_basebackup_name: Name of the basebackup to restore in forked service. Example: `backup-20191112t091354293891z`.
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input[_builtins.str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        :param pulumi.Input[_builtins.bool] static_ips: Use static public IP addresses.
        """
        if additional_backup_regions is not None:
            warnings.warn("""This property is deprecated.""", DeprecationWarning)
            pulumi.log.warn("""additional_backup_regions is deprecated: This property is deprecated.""")
        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 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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `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_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        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)

    @_builtins.property
    @pulumi.getter(name="additionalBackupRegions")
    @_utilities.deprecated("""This property is deprecated.""")
    def additional_backup_regions(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @_builtins.property
    @pulumi.getter(name="backupHour")
    def backup_hour(self) -> Optional[pulumi.Input[_builtins.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. Example: `3`.
        """
        return pulumi.get(self, "backup_hour")

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

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

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

    @_builtins.property
    @pulumi.getter(name="enableIpv6")
    def enable_ipv6(self) -> Optional[pulumi.Input[_builtins.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[_builtins.bool]]):
        pulumi.set(self, "enable_ipv6", value)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

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

    @_builtins.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)

    @_builtins.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)

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

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

    @_builtins.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)

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

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

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

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

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

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

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

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


if not MYPY:
    class ClickhouseClickhouseUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    ClickhouseClickhouseUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClickhouseClickhouseUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

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

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

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


if not MYPY:
    class ClickhouseClickhouseUserConfigPrivateAccessArgsDict(TypedDict):
        clickhouse: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to clickhouse with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        clickhouse_https: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to clickhouse_https with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        clickhouse_mysql: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to clickhouse_mysql with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
elif False:
    ClickhouseClickhouseUserConfigPrivateAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClickhouseClickhouseUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 clickhouse: Optional[pulumi.Input[_builtins.bool]] = None,
                 clickhouse_https: Optional[pulumi.Input[_builtins.bool]] = None,
                 clickhouse_mysql: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] clickhouse: Allow clients to connect to clickhouse with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] clickhouse_https: Allow clients to connect to clickhouse_https with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] clickhouse_mysql: Allow clients to connect to clickhouse_mysql with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        if clickhouse is not None:
            pulumi.set(__self__, "clickhouse", clickhouse)
        if clickhouse_https is not None:
            pulumi.set(__self__, "clickhouse_https", clickhouse_https)
        if clickhouse_mysql is not None:
            pulumi.set(__self__, "clickhouse_mysql", clickhouse_mysql)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @_builtins.property
    @pulumi.getter
    def clickhouse(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to clickhouse with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "clickhouse")

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

    @_builtins.property
    @pulumi.getter(name="clickhouseHttps")
    def clickhouse_https(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to clickhouse_https with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "clickhouse_https")

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

    @_builtins.property
    @pulumi.getter(name="clickhouseMysql")
    def clickhouse_mysql(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to clickhouse_mysql with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "clickhouse_mysql")

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

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "prometheus")

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


if not MYPY:
    class ClickhouseClickhouseUserConfigPrivatelinkAccessArgsDict(TypedDict):
        clickhouse: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable clickhouse.
        """
        clickhouse_https: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable clickhouse_https.
        """
        clickhouse_mysql: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable clickhouse_mysql.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable prometheus.
        """
elif False:
    ClickhouseClickhouseUserConfigPrivatelinkAccessArgsDict: TypeAlias = Mapping[str, Any]

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

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

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

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

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

    @_builtins.property
    @pulumi.getter(name="clickhouseMysql")
    def clickhouse_mysql(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable clickhouse_mysql.
        """
        return pulumi.get(self, "clickhouse_mysql")

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

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

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


if not MYPY:
    class ClickhouseClickhouseUserConfigPublicAccessArgsDict(TypedDict):
        clickhouse: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to clickhouse from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        clickhouse_https: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to clickhouse_https from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        clickhouse_mysql: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to clickhouse_mysql from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
elif False:
    ClickhouseClickhouseUserConfigPublicAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClickhouseClickhouseUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 clickhouse: Optional[pulumi.Input[_builtins.bool]] = None,
                 clickhouse_https: Optional[pulumi.Input[_builtins.bool]] = None,
                 clickhouse_mysql: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] clickhouse: Allow clients to connect to clickhouse from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] clickhouse_https: Allow clients to connect to clickhouse_https from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] clickhouse_mysql: Allow clients to connect to clickhouse_mysql from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        if clickhouse is not None:
            pulumi.set(__self__, "clickhouse", clickhouse)
        if clickhouse_https is not None:
            pulumi.set(__self__, "clickhouse_https", clickhouse_https)
        if clickhouse_mysql is not None:
            pulumi.set(__self__, "clickhouse_mysql", clickhouse_mysql)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @_builtins.property
    @pulumi.getter
    def clickhouse(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to clickhouse from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "clickhouse")

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

    @_builtins.property
    @pulumi.getter(name="clickhouseHttps")
    def clickhouse_https(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to clickhouse_https from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "clickhouse_https")

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

    @_builtins.property
    @pulumi.getter(name="clickhouseMysql")
    def clickhouse_mysql(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to clickhouse_mysql from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "clickhouse_mysql")

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

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "prometheus")

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


if not MYPY:
    class ClickhouseComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    ClickhouseComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClickhouseComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

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

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

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

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

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

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

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

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

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

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

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

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

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

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

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

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

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

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


if not MYPY:
    class ClickhouseGrantPrivilegeGrantArgsDict(TypedDict):
        database: pulumi.Input[_builtins.str]
        """
        The database to grant access to. To set up proper dependencies please refer to this variable as a reference. Changing this property forces recreation of the resource.
        """
        column: NotRequired[pulumi.Input[_builtins.str]]
        """
        The column to grant access to. Changing this property forces recreation of the resource.
        """
        privilege: NotRequired[pulumi.Input[_builtins.str]]
        """
        The privileges to grant. For example: `INSERT`, `SELECT`, `CREATE TABLE`. A complete list is available in the [ClickHouse documentation](https://clickhouse.com/docs/en/sql-reference/statements/grant). Changing this property forces recreation of the resource.
        """
        table: NotRequired[pulumi.Input[_builtins.str]]
        """
        The table to grant access to. Changing this property forces recreation of the resource.
        """
        with_grant: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow grantees to grant their privileges to other grantees. Changing this property forces recreation of the resource.
        """
elif False:
    ClickhouseGrantPrivilegeGrantArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClickhouseGrantPrivilegeGrantArgs:
    def __init__(__self__, *,
                 database: pulumi.Input[_builtins.str],
                 column: Optional[pulumi.Input[_builtins.str]] = None,
                 privilege: Optional[pulumi.Input[_builtins.str]] = None,
                 table: Optional[pulumi.Input[_builtins.str]] = None,
                 with_grant: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] database: The database to grant access to. To set up proper dependencies please refer to this variable as a reference. Changing this property forces recreation of the resource.
        :param pulumi.Input[_builtins.str] column: The column to grant access to. Changing this property forces recreation of the resource.
        :param pulumi.Input[_builtins.str] privilege: The privileges to grant. For example: `INSERT`, `SELECT`, `CREATE TABLE`. A complete list is available in the [ClickHouse documentation](https://clickhouse.com/docs/en/sql-reference/statements/grant). Changing this property forces recreation of the resource.
        :param pulumi.Input[_builtins.str] table: The table to grant access to. Changing this property forces recreation of the resource.
        :param pulumi.Input[_builtins.bool] with_grant: Allow grantees to grant their privileges to other grantees. Changing this property 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)

    @_builtins.property
    @pulumi.getter
    def database(self) -> pulumi.Input[_builtins.str]:
        """
        The database to grant access to. To set up proper dependencies please refer to this variable as a reference. Changing this property forces recreation of the resource.
        """
        return pulumi.get(self, "database")

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

    @_builtins.property
    @pulumi.getter
    def column(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The column to grant access to. Changing this property forces recreation of the resource.
        """
        return pulumi.get(self, "column")

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

    @_builtins.property
    @pulumi.getter
    def privilege(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The privileges to grant. For example: `INSERT`, `SELECT`, `CREATE TABLE`. A complete list is available in the [ClickHouse documentation](https://clickhouse.com/docs/en/sql-reference/statements/grant). Changing this property forces recreation of the resource.
        """
        return pulumi.get(self, "privilege")

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

    @_builtins.property
    @pulumi.getter
    def table(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The table to grant access to. Changing this property forces recreation of the resource.
        """
        return pulumi.get(self, "table")

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

    @_builtins.property
    @pulumi.getter(name="withGrant")
    def with_grant(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow grantees to grant their privileges to other grantees. Changing this property forces recreation of the resource.
        """
        return pulumi.get(self, "with_grant")

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


if not MYPY:
    class ClickhouseGrantRoleGrantArgsDict(TypedDict):
        role: NotRequired[pulumi.Input[_builtins.str]]
        """
        The roles to grant. To set up proper dependencies please refer to this variable as a reference. Changing this property forces recreation of the resource.
        """
elif False:
    ClickhouseGrantRoleGrantArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClickhouseGrantRoleGrantArgs:
    def __init__(__self__, *,
                 role: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] role: The roles to grant. To set up proper dependencies please refer to this variable as a reference. Changing this property forces recreation of the resource.
        """
        if role is not None:
            pulumi.set(__self__, "role", role)

    @_builtins.property
    @pulumi.getter
    def role(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The roles to grant. To set up proper dependencies please refer to this variable as a reference. Changing this property forces recreation of the resource.
        """
        return pulumi.get(self, "role")

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


if not MYPY:
    class ClickhouseServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    ClickhouseServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClickhouseServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration
        :param pulumi.Input[_builtins.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)

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

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

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class ClickhouseTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    ClickhouseTagArgsDict: TypeAlias = Mapping[str, Any]

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

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

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

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

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


if not MYPY:
    class ClickhouseTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    ClickhouseTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ClickhouseTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

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


if not MYPY:
    class DragonflyComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    DragonflyComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DragonflyComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

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

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

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

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

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

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

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

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

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

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

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

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

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

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

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

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

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

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


if not MYPY:
    class DragonflyDragonflyArgsDict(TypedDict):
        password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Dragonfly password.
        """
        replica_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Dragonfly replica server URI.
        """
        slave_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Dragonfly slave server URIs.
        """
        uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Dragonfly server URIs.
        """
elif False:
    DragonflyDragonflyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DragonflyDragonflyArgs:
    def __init__(__self__, *,
                 password: Optional[pulumi.Input[_builtins.str]] = None,
                 replica_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 slave_uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[_builtins.str] password: Dragonfly password.
        :param pulumi.Input[_builtins.str] replica_uri: Dragonfly replica server URI.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] slave_uris: Dragonfly slave server URIs.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uris: Dragonfly server URIs.
        """
        if password is not None:
            pulumi.set(__self__, "password", password)
        if replica_uri is not None:
            pulumi.set(__self__, "replica_uri", replica_uri)
        if slave_uris is not None:
            pulumi.set(__self__, "slave_uris", slave_uris)
        if uris is not None:
            pulumi.set(__self__, "uris", uris)

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

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

    @_builtins.property
    @pulumi.getter(name="replicaUri")
    def replica_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Dragonfly replica server URI.
        """
        return pulumi.get(self, "replica_uri")

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

    @_builtins.property
    @pulumi.getter(name="slaveUris")
    def slave_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Dragonfly slave server URIs.
        """
        return pulumi.get(self, "slave_uris")

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

    @_builtins.property
    @pulumi.getter
    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Dragonfly server URIs.
        """
        return pulumi.get(self, "uris")

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


if not MYPY:
    class DragonflyDragonflyUserConfigArgsDict(TypedDict):
        cache_mode: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Evict entries when getting close to maxmemory limit. Default: `false`.
        """
        dragonfly_persistence: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `dfs`, `off`, `rdb`. When persistence is `rdb` or `dfs`, Dragonfly does RDB or DFS dumps every 10 minutes. Dumps are done according to the backup schedule for backup purposes. When persistence is `off`, no RDB/DFS dumps or backups are done, so data can be lost at any moment if the service is restarted for any reason, or if the service is powered off. Also, the service can't be forked.
        """
        dragonfly_ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Require SSL to access Dragonfly. Default: `true`.
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['DragonflyDragonflyUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        migration: NotRequired[pulumi.Input['DragonflyDragonflyUserConfigMigrationArgsDict']]
        """
        Migrate data from existing server
        """
        private_access: NotRequired[pulumi.Input['DragonflyDragonflyUserConfigPrivateAccessArgsDict']]
        """
        Allow access to selected service ports from private networks
        """
        privatelink_access: NotRequired[pulumi.Input['DragonflyDragonflyUserConfigPrivatelinkAccessArgsDict']]
        """
        Allow access to selected service components through Privatelink
        """
        project_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        public_access: NotRequired[pulumi.Input['DragonflyDragonflyUserConfigPublicAccessArgsDict']]
        """
        Allow access to selected service ports from the public Internet
        """
        recovery_basebackup_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of the basebackup to restore in forked service. Example: `backup-20191112t091354293891z`.
        """
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        service_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
elif False:
    DragonflyDragonflyUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DragonflyDragonflyUserConfigArgs:
    def __init__(__self__, *,
                 cache_mode: Optional[pulumi.Input[_builtins.bool]] = None,
                 dragonfly_persistence: Optional[pulumi.Input[_builtins.str]] = None,
                 dragonfly_ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['DragonflyDragonflyUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 migration: Optional[pulumi.Input['DragonflyDragonflyUserConfigMigrationArgs']] = None,
                 private_access: Optional[pulumi.Input['DragonflyDragonflyUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['DragonflyDragonflyUserConfigPrivatelinkAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 public_access: Optional[pulumi.Input['DragonflyDragonflyUserConfigPublicAccessArgs']] = None,
                 recovery_basebackup_name: Optional[pulumi.Input[_builtins.str]] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 service_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] cache_mode: Evict entries when getting close to maxmemory limit. Default: `false`.
        :param pulumi.Input[_builtins.str] dragonfly_persistence: Enum: `dfs`, `off`, `rdb`. When persistence is `rdb` or `dfs`, Dragonfly does RDB or DFS dumps every 10 minutes. Dumps are done according to the backup schedule for backup purposes. When persistence is `off`, no RDB/DFS dumps or backups are done, so data can be lost at any moment if the service is restarted for any reason, or if the service is powered off. Also, the service can't be forked.
        :param pulumi.Input[_builtins.bool] dragonfly_ssl: Require SSL to access Dragonfly. Default: `true`.
        :param pulumi.Input[Sequence[pulumi.Input['DragonflyDragonflyUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input['DragonflyDragonflyUserConfigMigrationArgs'] migration: Migrate data from existing server
        :param pulumi.Input['DragonflyDragonflyUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks
        :param pulumi.Input['DragonflyDragonflyUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink
        :param pulumi.Input[_builtins.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. Example: `anotherprojectname`.
        :param pulumi.Input['DragonflyDragonflyUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
        :param pulumi.Input[_builtins.str] recovery_basebackup_name: Name of the basebackup to restore in forked service. Example: `backup-20191112t091354293891z`.
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input[_builtins.str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        :param pulumi.Input[_builtins.bool] static_ips: Use static public IP addresses.
        """
        if cache_mode is not None:
            pulumi.set(__self__, "cache_mode", cache_mode)
        if dragonfly_persistence is not None:
            pulumi.set(__self__, "dragonfly_persistence", dragonfly_persistence)
        if dragonfly_ssl is not None:
            pulumi.set(__self__, "dragonfly_ssl", dragonfly_ssl)
        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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `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 service_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        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)

    @_builtins.property
    @pulumi.getter(name="cacheMode")
    def cache_mode(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Evict entries when getting close to maxmemory limit. Default: `false`.
        """
        return pulumi.get(self, "cache_mode")

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

    @_builtins.property
    @pulumi.getter(name="dragonflyPersistence")
    def dragonfly_persistence(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `dfs`, `off`, `rdb`. When persistence is `rdb` or `dfs`, Dragonfly does RDB or DFS dumps every 10 minutes. Dumps are done according to the backup schedule for backup purposes. When persistence is `off`, no RDB/DFS dumps or backups are done, so data can be lost at any moment if the service is restarted for any reason, or if the service is powered off. Also, the service can't be forked.
        """
        return pulumi.get(self, "dragonfly_persistence")

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

    @_builtins.property
    @pulumi.getter(name="dragonflySsl")
    def dragonfly_ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Require SSL to access Dragonfly. Default: `true`.
        """
        return pulumi.get(self, "dragonfly_ssl")

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

    @_builtins.property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['DragonflyDragonflyUserConfigIpFilterObjectArgs']]]]:
        """
        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['DragonflyDragonflyUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

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

    @_builtins.property
    @pulumi.getter
    def migration(self) -> Optional[pulumi.Input['DragonflyDragonflyUserConfigMigrationArgs']]:
        """
        Migrate data from existing server
        """
        return pulumi.get(self, "migration")

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

    @_builtins.property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['DragonflyDragonflyUserConfigPrivateAccessArgs']]:
        """
        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['DragonflyDragonflyUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @_builtins.property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['DragonflyDragonflyUserConfigPrivatelinkAccessArgs']]:
        """
        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['DragonflyDragonflyUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)

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

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

    @_builtins.property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['DragonflyDragonflyUserConfigPublicAccessArgs']]:
        """
        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['DragonflyDragonflyUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

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

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

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

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

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

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

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

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


if not MYPY:
    class DragonflyDragonflyUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    DragonflyDragonflyUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DragonflyDragonflyUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

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

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

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


if not MYPY:
    class DragonflyDragonflyUserConfigMigrationArgsDict(TypedDict):
        host: pulumi.Input[_builtins.str]
        """
        Hostname or IP address of the server where to migrate data from. Example: `my.server.com`.
        """
        port: pulumi.Input[_builtins.int]
        """
        Port number of the server where to migrate data from. Example: `1234`.
        """
        dbname: NotRequired[pulumi.Input[_builtins.str]]
        """
        Database name for bootstrapping the initial connection. Example: `defaultdb`.
        """
        ignore_dbs: NotRequired[pulumi.Input[_builtins.str]]
        """
        Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
        """
        ignore_roles: NotRequired[pulumi.Input[_builtins.str]]
        """
        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
        """
        method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
        """
        password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        The server where to migrate data from is secured with SSL. Default: `true`.
        """
        username: NotRequired[pulumi.Input[_builtins.str]]
        """
        User name for authentication with the server where to migrate data from. Example: `myname`.
        """
elif False:
    DragonflyDragonflyUserConfigMigrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DragonflyDragonflyUserConfigMigrationArgs:
    def __init__(__self__, *,
                 host: pulumi.Input[_builtins.str],
                 port: pulumi.Input[_builtins.int],
                 dbname: Optional[pulumi.Input[_builtins.str]] = None,
                 ignore_dbs: Optional[pulumi.Input[_builtins.str]] = None,
                 ignore_roles: Optional[pulumi.Input[_builtins.str]] = None,
                 method: Optional[pulumi.Input[_builtins.str]] = None,
                 password: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 username: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] host: Hostname or IP address of the server where to migrate data from. Example: `my.server.com`.
        :param pulumi.Input[_builtins.int] port: Port number of the server where to migrate data from. Example: `1234`.
        :param pulumi.Input[_builtins.str] dbname: Database name for bootstrapping the initial connection. Example: `defaultdb`.
        :param pulumi.Input[_builtins.str] ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
        :param pulumi.Input[_builtins.str] ignore_roles: Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
        :param pulumi.Input[_builtins.str] method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
        :param pulumi.Input[_builtins.str] password: Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
        :param pulumi.Input[_builtins.bool] ssl: The server where to migrate data from is secured with SSL. Default: `true`.
        :param pulumi.Input[_builtins.str] username: User name for authentication with the server where to migrate data from. Example: `myname`.
        """
        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 ignore_roles is not None:
            pulumi.set(__self__, "ignore_roles", ignore_roles)
        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)

    @_builtins.property
    @pulumi.getter
    def host(self) -> pulumi.Input[_builtins.str]:
        """
        Hostname or IP address of the server where to migrate data from. Example: `my.server.com`.
        """
        return pulumi.get(self, "host")

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

    @_builtins.property
    @pulumi.getter
    def port(self) -> pulumi.Input[_builtins.int]:
        """
        Port number of the server where to migrate data from. Example: `1234`.
        """
        return pulumi.get(self, "port")

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

    @_builtins.property
    @pulumi.getter
    def dbname(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Database name for bootstrapping the initial connection. Example: `defaultdb`.
        """
        return pulumi.get(self, "dbname")

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

    @_builtins.property
    @pulumi.getter(name="ignoreDbs")
    def ignore_dbs(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
        """
        return pulumi.get(self, "ignore_dbs")

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

    @_builtins.property
    @pulumi.getter(name="ignoreRoles")
    def ignore_roles(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
        """
        return pulumi.get(self, "ignore_roles")

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

    @_builtins.property
    @pulumi.getter
    def method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
        """
        return pulumi.get(self, "method")

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

    @_builtins.property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
        """
        return pulumi.get(self, "password")

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

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        The server where to migrate data from is secured with SSL. Default: `true`.
        """
        return pulumi.get(self, "ssl")

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

    @_builtins.property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        User name for authentication with the server where to migrate data from. Example: `myname`.
        """
        return pulumi.get(self, "username")

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


if not MYPY:
    class DragonflyDragonflyUserConfigPrivateAccessArgsDict(TypedDict):
        dragonfly: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to dragonfly with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
elif False:
    DragonflyDragonflyUserConfigPrivateAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DragonflyDragonflyUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 dragonfly: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] dragonfly: Allow clients to connect to dragonfly with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        if dragonfly is not None:
            pulumi.set(__self__, "dragonfly", dragonfly)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @_builtins.property
    @pulumi.getter
    def dragonfly(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to dragonfly with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "dragonfly")

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

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "prometheus")

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


if not MYPY:
    class DragonflyDragonflyUserConfigPrivatelinkAccessArgsDict(TypedDict):
        dragonfly: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable dragonfly.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable prometheus.
        """
elif False:
    DragonflyDragonflyUserConfigPrivatelinkAccessArgsDict: TypeAlias = Mapping[str, Any]

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

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

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

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

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


if not MYPY:
    class DragonflyDragonflyUserConfigPublicAccessArgsDict(TypedDict):
        dragonfly: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to dragonfly from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
elif False:
    DragonflyDragonflyUserConfigPublicAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DragonflyDragonflyUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 dragonfly: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] dragonfly: Allow clients to connect to dragonfly from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        if dragonfly is not None:
            pulumi.set(__self__, "dragonfly", dragonfly)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @_builtins.property
    @pulumi.getter
    def dragonfly(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to dragonfly from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "dragonfly")

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

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "prometheus")

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


if not MYPY:
    class DragonflyServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    DragonflyServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DragonflyServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration
        :param pulumi.Input[_builtins.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)

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

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

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class DragonflyTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    DragonflyTagArgsDict: TypeAlias = Mapping[str, Any]

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

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

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

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

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


if not MYPY:
    class DragonflyTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    DragonflyTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class DragonflyTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

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


if not MYPY:
    class FlinkApplicationVersionSinkArgsDict(TypedDict):
        create_table: pulumi.Input[_builtins.str]
        """
        The CREATE TABLE statement
        """
        integration_id: NotRequired[pulumi.Input[_builtins.str]]
        """
        The integration ID
        """
elif False:
    FlinkApplicationVersionSinkArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkApplicationVersionSinkArgs:
    def __init__(__self__, *,
                 create_table: pulumi.Input[_builtins.str],
                 integration_id: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] create_table: The CREATE TABLE statement
        :param pulumi.Input[_builtins.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)

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

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

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

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


if not MYPY:
    class FlinkApplicationVersionSourceArgsDict(TypedDict):
        create_table: pulumi.Input[_builtins.str]
        """
        The CREATE TABLE statement
        """
        integration_id: NotRequired[pulumi.Input[_builtins.str]]
        """
        The integration ID
        """
elif False:
    FlinkApplicationVersionSourceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkApplicationVersionSourceArgs:
    def __init__(__self__, *,
                 create_table: pulumi.Input[_builtins.str],
                 integration_id: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] create_table: The CREATE TABLE statement
        :param pulumi.Input[_builtins.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)

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

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

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

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


if not MYPY:
    class FlinkComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    FlinkComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

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

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

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

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

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

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

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

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

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

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

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

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

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

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

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

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

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

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


if not MYPY:
    class FlinkFlinkArgsDict(TypedDict):
        host_ports: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        The host and port of a Flink server.
        """
elif False:
    FlinkFlinkArgsDict: TypeAlias = Mapping[str, Any]

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

    @_builtins.property
    @pulumi.getter(name="hostPorts")
    def host_ports(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        The 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[_builtins.str]]]]):
        pulumi.set(self, "host_ports", value)


if not MYPY:
    class FlinkFlinkUserConfigArgsDict(TypedDict):
        additional_backup_regions: NotRequired[pulumi.Input[_builtins.str]]
        """
        Additional Cloud Regions for Backup Replication.
        """
        custom_code: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable to upload Custom JARs for Flink applications.
        """
        flink_version: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `1.16`, `1.19`, `1.20`, and newer. Flink major version.
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['FlinkFlinkUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        number_of_task_slots: NotRequired[pulumi.Input[_builtins.int]]
        """
        Task slots per node. For a 3 node plan, total number of task slots is 3x this value. Example: `1`.
        """
        pekko_ask_timeout_s: NotRequired[pulumi.Input[_builtins.int]]
        """
        Timeout in seconds used for all futures and blocking Pekko requests. Example: `10`.
        """
        pekko_framesize_b: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum size in bytes for messages exchanged between the JobManager and the TaskManagers.
        """
        privatelink_access: NotRequired[pulumi.Input['FlinkFlinkUserConfigPrivatelinkAccessArgsDict']]
        """
        Allow access to selected service components through Privatelink
        """
        public_access: NotRequired[pulumi.Input['FlinkFlinkUserConfigPublicAccessArgsDict']]
        """
        Allow access to selected service ports from the public Internet
        """
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
elif False:
    FlinkFlinkUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkFlinkUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[_builtins.str]] = None,
                 custom_code: Optional[pulumi.Input[_builtins.bool]] = None,
                 flink_version: Optional[pulumi.Input[_builtins.str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['FlinkFlinkUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 number_of_task_slots: Optional[pulumi.Input[_builtins.int]] = None,
                 pekko_ask_timeout_s: Optional[pulumi.Input[_builtins.int]] = None,
                 pekko_framesize_b: Optional[pulumi.Input[_builtins.int]] = None,
                 privatelink_access: Optional[pulumi.Input['FlinkFlinkUserConfigPrivatelinkAccessArgs']] = None,
                 public_access: Optional[pulumi.Input['FlinkFlinkUserConfigPublicAccessArgs']] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[_builtins.bool] custom_code: Enable to upload Custom JARs for Flink applications.
        :param pulumi.Input[_builtins.str] flink_version: Enum: `1.16`, `1.19`, `1.20`, and newer. 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[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[_builtins.int] number_of_task_slots: Task slots per node. For a 3 node plan, total number of task slots is 3x this value. Example: `1`.
        :param pulumi.Input[_builtins.int] pekko_ask_timeout_s: Timeout in seconds used for all futures and blocking Pekko requests. Example: `10`.
        :param pulumi.Input[_builtins.int] pekko_framesize_b: Maximum size in bytes for messages exchanged between the JobManager and the TaskManagers.
        :param pulumi.Input['FlinkFlinkUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink
        :param pulumi.Input['FlinkFlinkUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input[_builtins.bool] static_ips: Use static public IP addresses.
        """
        if additional_backup_regions is not None:
            warnings.warn("""This property is deprecated.""", DeprecationWarning)
            pulumi.log.warn("""additional_backup_regions is deprecated: This property is deprecated.""")
        if additional_backup_regions is not None:
            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
        if custom_code is not None:
            pulumi.set(__self__, "custom_code", custom_code)
        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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `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 pekko_ask_timeout_s is not None:
            pulumi.set(__self__, "pekko_ask_timeout_s", pekko_ask_timeout_s)
        if pekko_framesize_b is not None:
            pulumi.set(__self__, "pekko_framesize_b", pekko_framesize_b)
        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 service_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)

    @_builtins.property
    @pulumi.getter(name="additionalBackupRegions")
    @_utilities.deprecated("""This property is deprecated.""")
    def additional_backup_regions(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @_builtins.property
    @pulumi.getter(name="customCode")
    def custom_code(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable to upload Custom JARs for Flink applications.
        """
        return pulumi.get(self, "custom_code")

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

    @_builtins.property
    @pulumi.getter(name="flinkVersion")
    def flink_version(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `1.16`, `1.19`, `1.20`, and newer. Flink major version.
        """
        return pulumi.get(self, "flink_version")

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

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

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

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

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

    @_builtins.property
    @pulumi.getter(name="pekkoAskTimeoutS")
    def pekko_ask_timeout_s(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Timeout in seconds used for all futures and blocking Pekko requests. Example: `10`.
        """
        return pulumi.get(self, "pekko_ask_timeout_s")

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

    @_builtins.property
    @pulumi.getter(name="pekkoFramesizeB")
    def pekko_framesize_b(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum size in bytes for messages exchanged between the JobManager and the TaskManagers.
        """
        return pulumi.get(self, "pekko_framesize_b")

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

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['FlinkFlinkUserConfigPublicAccessArgs']]:
        """
        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['FlinkFlinkUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

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

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

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


if not MYPY:
    class FlinkFlinkUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    FlinkFlinkUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkFlinkUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

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

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

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


if not MYPY:
    class FlinkFlinkUserConfigPrivatelinkAccessArgsDict(TypedDict):
        flink: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable flink.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable prometheus.
        """
elif False:
    FlinkFlinkUserConfigPrivatelinkAccessArgsDict: TypeAlias = Mapping[str, Any]

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

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

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

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

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


if not MYPY:
    class FlinkFlinkUserConfigPublicAccessArgsDict(TypedDict):
        flink: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to flink from the public internet for service nodes that are in a project VPC or another type of private network.
        """
elif False:
    FlinkFlinkUserConfigPublicAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkFlinkUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 flink: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] flink: Allow clients to connect to flink from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        if flink is not None:
            pulumi.set(__self__, "flink", flink)

    @_builtins.property
    @pulumi.getter
    def flink(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to flink from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "flink")

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


if not MYPY:
    class FlinkJarApplicationApplicationVersionArgsDict(TypedDict):
        created_at: NotRequired[pulumi.Input[_builtins.str]]
        """
        The creation timestamp of this entity in ISO 8601 format, always in UTC.
        """
        created_by: NotRequired[pulumi.Input[_builtins.str]]
        """
        The creator of this entity.
        """
        file_infos: NotRequired[pulumi.Input[Sequence[pulumi.Input['FlinkJarApplicationApplicationVersionFileInfoArgsDict']]]]
        """
        Flink JarApplicationVersion FileInfo.
        """
        id: NotRequired[pulumi.Input[_builtins.str]]
        """
        ApplicationVersion ID.
        """
        version: NotRequired[pulumi.Input[_builtins.int]]
        """
        Version number.
        """
elif False:
    FlinkJarApplicationApplicationVersionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkJarApplicationApplicationVersionArgs:
    def __init__(__self__, *,
                 created_at: Optional[pulumi.Input[_builtins.str]] = None,
                 created_by: Optional[pulumi.Input[_builtins.str]] = None,
                 file_infos: Optional[pulumi.Input[Sequence[pulumi.Input['FlinkJarApplicationApplicationVersionFileInfoArgs']]]] = None,
                 id: Optional[pulumi.Input[_builtins.str]] = None,
                 version: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.str] created_at: The creation timestamp of this entity in ISO 8601 format, always in UTC.
        :param pulumi.Input[_builtins.str] created_by: The creator of this entity.
        :param pulumi.Input[Sequence[pulumi.Input['FlinkJarApplicationApplicationVersionFileInfoArgs']]] file_infos: Flink JarApplicationVersion FileInfo.
        :param pulumi.Input[_builtins.str] id: ApplicationVersion ID.
        :param pulumi.Input[_builtins.int] version: Version number.
        """
        if created_at is not None:
            pulumi.set(__self__, "created_at", created_at)
        if created_by is not None:
            pulumi.set(__self__, "created_by", created_by)
        if file_infos is not None:
            pulumi.set(__self__, "file_infos", file_infos)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if version is not None:
            pulumi.set(__self__, "version", version)

    @_builtins.property
    @pulumi.getter(name="createdAt")
    def created_at(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The creation timestamp of this entity in ISO 8601 format, always in UTC.
        """
        return pulumi.get(self, "created_at")

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

    @_builtins.property
    @pulumi.getter(name="createdBy")
    def created_by(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The creator of this entity.
        """
        return pulumi.get(self, "created_by")

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

    @_builtins.property
    @pulumi.getter(name="fileInfos")
    def file_infos(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['FlinkJarApplicationApplicationVersionFileInfoArgs']]]]:
        """
        Flink JarApplicationVersion FileInfo.
        """
        return pulumi.get(self, "file_infos")

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

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

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

    @_builtins.property
    @pulumi.getter
    def version(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Version number.
        """
        return pulumi.get(self, "version")

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


if not MYPY:
    class FlinkJarApplicationApplicationVersionFileInfoArgsDict(TypedDict):
        file_sha256: NotRequired[pulumi.Input[_builtins.str]]
        """
        sha256 of the file if known.
        """
        file_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        The size of the file in bytes.
        """
        file_status: NotRequired[pulumi.Input[_builtins.str]]
        """
        Indicates whether the uploaded .jar file has been verified by the system and deployment ready. The possible values are `INITIAL`, `READY` and `FAILED`.
        """
        url: NotRequired[pulumi.Input[_builtins.str]]
        """
        The pre-signed url of the bucket where the .jar file is uploaded. Becomes null when the JarApplicationVersion is ready or failed.
        """
        verify_error_code: NotRequired[pulumi.Input[_builtins.int]]
        """
        In the case file_status is FAILED, the error code of the failure. The possible values are `1`, `2` and `3`.
        """
        verify_error_message: NotRequired[pulumi.Input[_builtins.str]]
        """
        In the case file_status is FAILED, may contain details about the failure.
        """
elif False:
    FlinkJarApplicationApplicationVersionFileInfoArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkJarApplicationApplicationVersionFileInfoArgs:
    def __init__(__self__, *,
                 file_sha256: Optional[pulumi.Input[_builtins.str]] = None,
                 file_size: Optional[pulumi.Input[_builtins.int]] = None,
                 file_status: Optional[pulumi.Input[_builtins.str]] = None,
                 url: Optional[pulumi.Input[_builtins.str]] = None,
                 verify_error_code: Optional[pulumi.Input[_builtins.int]] = None,
                 verify_error_message: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] file_sha256: sha256 of the file if known.
        :param pulumi.Input[_builtins.int] file_size: The size of the file in bytes.
        :param pulumi.Input[_builtins.str] file_status: Indicates whether the uploaded .jar file has been verified by the system and deployment ready. The possible values are `INITIAL`, `READY` and `FAILED`.
        :param pulumi.Input[_builtins.str] url: The pre-signed url of the bucket where the .jar file is uploaded. Becomes null when the JarApplicationVersion is ready or failed.
        :param pulumi.Input[_builtins.int] verify_error_code: In the case file_status is FAILED, the error code of the failure. The possible values are `1`, `2` and `3`.
        :param pulumi.Input[_builtins.str] verify_error_message: In the case file_status is FAILED, may contain details about the failure.
        """
        if file_sha256 is not None:
            pulumi.set(__self__, "file_sha256", file_sha256)
        if file_size is not None:
            pulumi.set(__self__, "file_size", file_size)
        if file_status is not None:
            pulumi.set(__self__, "file_status", file_status)
        if url is not None:
            pulumi.set(__self__, "url", url)
        if verify_error_code is not None:
            pulumi.set(__self__, "verify_error_code", verify_error_code)
        if verify_error_message is not None:
            pulumi.set(__self__, "verify_error_message", verify_error_message)

    @_builtins.property
    @pulumi.getter(name="fileSha256")
    def file_sha256(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        sha256 of the file if known.
        """
        return pulumi.get(self, "file_sha256")

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

    @_builtins.property
    @pulumi.getter(name="fileSize")
    def file_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The size of the file in bytes.
        """
        return pulumi.get(self, "file_size")

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

    @_builtins.property
    @pulumi.getter(name="fileStatus")
    def file_status(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Indicates whether the uploaded .jar file has been verified by the system and deployment ready. The possible values are `INITIAL`, `READY` and `FAILED`.
        """
        return pulumi.get(self, "file_status")

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

    @_builtins.property
    @pulumi.getter
    def url(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The pre-signed url of the bucket where the .jar file is uploaded. Becomes null when the JarApplicationVersion is ready or failed.
        """
        return pulumi.get(self, "url")

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

    @_builtins.property
    @pulumi.getter(name="verifyErrorCode")
    def verify_error_code(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        In the case file_status is FAILED, the error code of the failure. The possible values are `1`, `2` and `3`.
        """
        return pulumi.get(self, "verify_error_code")

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

    @_builtins.property
    @pulumi.getter(name="verifyErrorMessage")
    def verify_error_message(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        In the case file_status is FAILED, may contain details about the failure.
        """
        return pulumi.get(self, "verify_error_message")

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


if not MYPY:
    class FlinkJarApplicationCurrentDeploymentArgsDict(TypedDict):
        created_at: NotRequired[pulumi.Input[_builtins.str]]
        """
        The creation timestamp of this entity in ISO 8601 format, always in UTC.
        """
        created_by: NotRequired[pulumi.Input[_builtins.str]]
        """
        The creator of this entity.
        """
        entry_class: NotRequired[pulumi.Input[_builtins.str]]
        """
        The fully qualified name of the entry class to pass during Flink job submission through the entryClass parameter.
        """
        error_msg: NotRequired[pulumi.Input[_builtins.str]]
        """
        Error message describing what caused deployment to fail.
        """
        id: NotRequired[pulumi.Input[_builtins.str]]
        """
        Deployment ID.
        """
        job_id: NotRequired[pulumi.Input[_builtins.str]]
        """
        Job ID.
        """
        last_savepoint: NotRequired[pulumi.Input[_builtins.str]]
        """
        Job savepoint.
        """
        parallelism: NotRequired[pulumi.Input[_builtins.int]]
        """
        Reading of Flink parallel execution documentation is recommended before setting this value to other than 1. Please do not set this value higher than (total number of nodes x number_of_task_slots), or every new job created will fail.
        """
        program_args: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Arguments to pass during Flink job submission through the programArgsList parameter.
        """
        starting_savepoint: NotRequired[pulumi.Input[_builtins.str]]
        """
        Job savepoint.
        """
        status: NotRequired[pulumi.Input[_builtins.str]]
        """
        Deployment status. The possible values are `CANCELED`, `CANCELLING`, `CANCELLING_REQUESTED`, `CREATED`, `DELETE_REQUESTED`, `DELETING`, `FAILED`, `FAILING`, `FINISHED`, `INITIALIZING`, `RECONCILING`, `RESTARTING`, `RUNNING`, `SAVING`, `SAVING_AND_STOP`, `SAVING_AND_STOP_REQUESTED` and `SUSPENDED`.
        """
        version_id: NotRequired[pulumi.Input[_builtins.str]]
        """
        ApplicationVersion ID.
        """
elif False:
    FlinkJarApplicationCurrentDeploymentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkJarApplicationCurrentDeploymentArgs:
    def __init__(__self__, *,
                 created_at: Optional[pulumi.Input[_builtins.str]] = None,
                 created_by: Optional[pulumi.Input[_builtins.str]] = None,
                 entry_class: Optional[pulumi.Input[_builtins.str]] = None,
                 error_msg: Optional[pulumi.Input[_builtins.str]] = None,
                 id: Optional[pulumi.Input[_builtins.str]] = None,
                 job_id: Optional[pulumi.Input[_builtins.str]] = None,
                 last_savepoint: Optional[pulumi.Input[_builtins.str]] = None,
                 parallelism: Optional[pulumi.Input[_builtins.int]] = None,
                 program_args: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 starting_savepoint: Optional[pulumi.Input[_builtins.str]] = None,
                 status: Optional[pulumi.Input[_builtins.str]] = None,
                 version_id: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] created_at: The creation timestamp of this entity in ISO 8601 format, always in UTC.
        :param pulumi.Input[_builtins.str] created_by: The creator of this entity.
        :param pulumi.Input[_builtins.str] entry_class: The fully qualified name of the entry class to pass during Flink job submission through the entryClass parameter.
        :param pulumi.Input[_builtins.str] error_msg: Error message describing what caused deployment to fail.
        :param pulumi.Input[_builtins.str] id: Deployment ID.
        :param pulumi.Input[_builtins.str] job_id: Job ID.
        :param pulumi.Input[_builtins.str] last_savepoint: Job savepoint.
        :param pulumi.Input[_builtins.int] parallelism: Reading of Flink parallel execution documentation is recommended before setting this value to other than 1. Please do not set this value higher than (total number of nodes x number_of_task_slots), or every new job created will fail.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] program_args: Arguments to pass during Flink job submission through the programArgsList parameter.
        :param pulumi.Input[_builtins.str] starting_savepoint: Job savepoint.
        :param pulumi.Input[_builtins.str] status: Deployment status. The possible values are `CANCELED`, `CANCELLING`, `CANCELLING_REQUESTED`, `CREATED`, `DELETE_REQUESTED`, `DELETING`, `FAILED`, `FAILING`, `FINISHED`, `INITIALIZING`, `RECONCILING`, `RESTARTING`, `RUNNING`, `SAVING`, `SAVING_AND_STOP`, `SAVING_AND_STOP_REQUESTED` and `SUSPENDED`.
        :param pulumi.Input[_builtins.str] version_id: ApplicationVersion ID.
        """
        if created_at is not None:
            pulumi.set(__self__, "created_at", created_at)
        if created_by is not None:
            pulumi.set(__self__, "created_by", created_by)
        if entry_class is not None:
            pulumi.set(__self__, "entry_class", entry_class)
        if error_msg is not None:
            pulumi.set(__self__, "error_msg", error_msg)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if job_id is not None:
            pulumi.set(__self__, "job_id", job_id)
        if last_savepoint is not None:
            pulumi.set(__self__, "last_savepoint", last_savepoint)
        if parallelism is not None:
            pulumi.set(__self__, "parallelism", parallelism)
        if program_args is not None:
            pulumi.set(__self__, "program_args", program_args)
        if starting_savepoint is not None:
            pulumi.set(__self__, "starting_savepoint", starting_savepoint)
        if status is not None:
            pulumi.set(__self__, "status", status)
        if version_id is not None:
            pulumi.set(__self__, "version_id", version_id)

    @_builtins.property
    @pulumi.getter(name="createdAt")
    def created_at(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The creation timestamp of this entity in ISO 8601 format, always in UTC.
        """
        return pulumi.get(self, "created_at")

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

    @_builtins.property
    @pulumi.getter(name="createdBy")
    def created_by(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The creator of this entity.
        """
        return pulumi.get(self, "created_by")

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

    @_builtins.property
    @pulumi.getter(name="entryClass")
    def entry_class(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The fully qualified name of the entry class to pass during Flink job submission through the entryClass parameter.
        """
        return pulumi.get(self, "entry_class")

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

    @_builtins.property
    @pulumi.getter(name="errorMsg")
    def error_msg(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Error message describing what caused deployment to fail.
        """
        return pulumi.get(self, "error_msg")

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

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

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

    @_builtins.property
    @pulumi.getter(name="jobId")
    def job_id(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Job ID.
        """
        return pulumi.get(self, "job_id")

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

    @_builtins.property
    @pulumi.getter(name="lastSavepoint")
    def last_savepoint(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Job savepoint.
        """
        return pulumi.get(self, "last_savepoint")

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

    @_builtins.property
    @pulumi.getter
    def parallelism(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Reading of Flink parallel execution documentation is recommended before setting this value to other than 1. Please do not set this value higher than (total number of nodes x number_of_task_slots), or every new job created will fail.
        """
        return pulumi.get(self, "parallelism")

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

    @_builtins.property
    @pulumi.getter(name="programArgs")
    def program_args(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Arguments to pass during Flink job submission through the programArgsList parameter.
        """
        return pulumi.get(self, "program_args")

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

    @_builtins.property
    @pulumi.getter(name="startingSavepoint")
    def starting_savepoint(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Job savepoint.
        """
        return pulumi.get(self, "starting_savepoint")

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

    @_builtins.property
    @pulumi.getter
    def status(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Deployment status. The possible values are `CANCELED`, `CANCELLING`, `CANCELLING_REQUESTED`, `CREATED`, `DELETE_REQUESTED`, `DELETING`, `FAILED`, `FAILING`, `FINISHED`, `INITIALIZING`, `RECONCILING`, `RESTARTING`, `RUNNING`, `SAVING`, `SAVING_AND_STOP`, `SAVING_AND_STOP_REQUESTED` and `SUSPENDED`.
        """
        return pulumi.get(self, "status")

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

    @_builtins.property
    @pulumi.getter(name="versionId")
    def version_id(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        ApplicationVersion ID.
        """
        return pulumi.get(self, "version_id")

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


if not MYPY:
    class FlinkJarApplicationVersionFileInfoArgsDict(TypedDict):
        file_sha256: NotRequired[pulumi.Input[_builtins.str]]
        """
        sha256 of the file if known.
        """
        file_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        The size of the file in bytes.
        """
        file_status: NotRequired[pulumi.Input[_builtins.str]]
        """
        Indicates whether the uploaded .jar file has been verified by the system and deployment ready. The possible values are `FAILED`, `INITIAL` and `READY`.
        """
        url: NotRequired[pulumi.Input[_builtins.str]]
        """
        The pre-signed url of the bucket where the .jar file is uploaded. Becomes null when the JarApplicationVersion is ready or failed.
        """
        verify_error_code: NotRequired[pulumi.Input[_builtins.int]]
        """
        In the case file_status is FAILED, the error code of the failure. The possible values are `1`, `2` and `3`.
        """
        verify_error_message: NotRequired[pulumi.Input[_builtins.str]]
        """
        In the case file_status is FAILED, may contain details about the failure.
        """
elif False:
    FlinkJarApplicationVersionFileInfoArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkJarApplicationVersionFileInfoArgs:
    def __init__(__self__, *,
                 file_sha256: Optional[pulumi.Input[_builtins.str]] = None,
                 file_size: Optional[pulumi.Input[_builtins.int]] = None,
                 file_status: Optional[pulumi.Input[_builtins.str]] = None,
                 url: Optional[pulumi.Input[_builtins.str]] = None,
                 verify_error_code: Optional[pulumi.Input[_builtins.int]] = None,
                 verify_error_message: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] file_sha256: sha256 of the file if known.
        :param pulumi.Input[_builtins.int] file_size: The size of the file in bytes.
        :param pulumi.Input[_builtins.str] file_status: Indicates whether the uploaded .jar file has been verified by the system and deployment ready. The possible values are `FAILED`, `INITIAL` and `READY`.
        :param pulumi.Input[_builtins.str] url: The pre-signed url of the bucket where the .jar file is uploaded. Becomes null when the JarApplicationVersion is ready or failed.
        :param pulumi.Input[_builtins.int] verify_error_code: In the case file_status is FAILED, the error code of the failure. The possible values are `1`, `2` and `3`.
        :param pulumi.Input[_builtins.str] verify_error_message: In the case file_status is FAILED, may contain details about the failure.
        """
        if file_sha256 is not None:
            pulumi.set(__self__, "file_sha256", file_sha256)
        if file_size is not None:
            pulumi.set(__self__, "file_size", file_size)
        if file_status is not None:
            pulumi.set(__self__, "file_status", file_status)
        if url is not None:
            pulumi.set(__self__, "url", url)
        if verify_error_code is not None:
            pulumi.set(__self__, "verify_error_code", verify_error_code)
        if verify_error_message is not None:
            pulumi.set(__self__, "verify_error_message", verify_error_message)

    @_builtins.property
    @pulumi.getter(name="fileSha256")
    def file_sha256(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        sha256 of the file if known.
        """
        return pulumi.get(self, "file_sha256")

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

    @_builtins.property
    @pulumi.getter(name="fileSize")
    def file_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The size of the file in bytes.
        """
        return pulumi.get(self, "file_size")

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

    @_builtins.property
    @pulumi.getter(name="fileStatus")
    def file_status(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Indicates whether the uploaded .jar file has been verified by the system and deployment ready. The possible values are `FAILED`, `INITIAL` and `READY`.
        """
        return pulumi.get(self, "file_status")

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

    @_builtins.property
    @pulumi.getter
    def url(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The pre-signed url of the bucket where the .jar file is uploaded. Becomes null when the JarApplicationVersion is ready or failed.
        """
        return pulumi.get(self, "url")

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

    @_builtins.property
    @pulumi.getter(name="verifyErrorCode")
    def verify_error_code(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        In the case file_status is FAILED, the error code of the failure. The possible values are `1`, `2` and `3`.
        """
        return pulumi.get(self, "verify_error_code")

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

    @_builtins.property
    @pulumi.getter(name="verifyErrorMessage")
    def verify_error_message(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        In the case file_status is FAILED, may contain details about the failure.
        """
        return pulumi.get(self, "verify_error_message")

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


if not MYPY:
    class FlinkServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    FlinkServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration
        :param pulumi.Input[_builtins.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)

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

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

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class FlinkTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    FlinkTagArgsDict: TypeAlias = Mapping[str, Any]

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

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

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

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

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


if not MYPY:
    class FlinkTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    FlinkTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class FlinkTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

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


if not MYPY:
    class GovernanceAccessAccessDataArgsDict(TypedDict):
        acls: pulumi.Input[Sequence[pulumi.Input['GovernanceAccessAccessDataAclArgsDict']]]
        """
        Required property. Acls. Changing this property forces recreation of the resource.
        """
        project: pulumi.Input[_builtins.str]
        """
        Project name. Changing this property forces recreation of the resource.
        """
        service_name: pulumi.Input[_builtins.str]
        """
        Service name. Changing this property forces recreation of the resource.
        """
        username: NotRequired[pulumi.Input[_builtins.str]]
        """
        The service username assigned to the access. Changing this property forces recreation of the resource.
        """
elif False:
    GovernanceAccessAccessDataArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GovernanceAccessAccessDataArgs:
    def __init__(__self__, *,
                 acls: pulumi.Input[Sequence[pulumi.Input['GovernanceAccessAccessDataAclArgs']]],
                 project: pulumi.Input[_builtins.str],
                 service_name: pulumi.Input[_builtins.str],
                 username: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['GovernanceAccessAccessDataAclArgs']]] acls: Required property. Acls. Changing this property forces recreation of the resource.
        :param pulumi.Input[_builtins.str] project: Project name. Changing this property forces recreation of the resource.
        :param pulumi.Input[_builtins.str] service_name: Service name. Changing this property forces recreation of the resource.
        :param pulumi.Input[_builtins.str] username: The service username assigned to the access. Changing this property forces recreation of the resource.
        """
        pulumi.set(__self__, "acls", acls)
        pulumi.set(__self__, "project", project)
        pulumi.set(__self__, "service_name", service_name)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @_builtins.property
    @pulumi.getter
    def acls(self) -> pulumi.Input[Sequence[pulumi.Input['GovernanceAccessAccessDataAclArgs']]]:
        """
        Required property. Acls. Changing this property forces recreation of the resource.
        """
        return pulumi.get(self, "acls")

    @acls.setter
    def acls(self, value: pulumi.Input[Sequence[pulumi.Input['GovernanceAccessAccessDataAclArgs']]]):
        pulumi.set(self, "acls", value)

    @_builtins.property
    @pulumi.getter
    def project(self) -> pulumi.Input[_builtins.str]:
        """
        Project name. Changing this property forces recreation of the resource.
        """
        return pulumi.get(self, "project")

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

    @_builtins.property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> pulumi.Input[_builtins.str]:
        """
        Service name. Changing this property forces recreation of the resource.
        """
        return pulumi.get(self, "service_name")

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

    @_builtins.property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The service username assigned to the access. Changing this property forces recreation of the resource.
        """
        return pulumi.get(self, "username")

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


if not MYPY:
    class GovernanceAccessAccessDataAclArgsDict(TypedDict):
        operation: pulumi.Input[_builtins.str]
        """
        An enumeration. The possible values are `Read` and `Write`. Changing this property forces recreation of the resource.
        """
        permission_type: pulumi.Input[_builtins.str]
        """
        An enumeration. The possible value is `ALLOW`. Changing this property forces recreation of the resource.
        """
        resource_name: pulumi.Input[_builtins.str]
        """
        Acl resource name. Maximum length: `256`. Changing this property forces recreation of the resource.
        """
        resource_type: pulumi.Input[_builtins.str]
        """
        An enumeration. The possible value is `Topic`. Changing this property forces recreation of the resource.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        The IP address from which a principal is allowed or denied access to the resource. Use `*` for all hosts. Maximum length: `256`. Changing this property forces recreation of the resource.
        """
        id: NotRequired[pulumi.Input[_builtins.str]]
        """
        Acl ID.
        """
        pattern_type: NotRequired[pulumi.Input[_builtins.str]]
        """
        An enumeration. The possible value is `LITERAL`.
        """
        principal: NotRequired[pulumi.Input[_builtins.str]]
        """
        Acl principal.
        """
elif False:
    GovernanceAccessAccessDataAclArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GovernanceAccessAccessDataAclArgs:
    def __init__(__self__, *,
                 operation: pulumi.Input[_builtins.str],
                 permission_type: pulumi.Input[_builtins.str],
                 resource_name: pulumi.Input[_builtins.str],
                 resource_type: pulumi.Input[_builtins.str],
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 id: Optional[pulumi.Input[_builtins.str]] = None,
                 pattern_type: Optional[pulumi.Input[_builtins.str]] = None,
                 principal: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] operation: An enumeration. The possible values are `Read` and `Write`. Changing this property forces recreation of the resource.
        :param pulumi.Input[_builtins.str] permission_type: An enumeration. The possible value is `ALLOW`. Changing this property forces recreation of the resource.
        :param pulumi.Input[_builtins.str] resource_name: Acl resource name. Maximum length: `256`. Changing this property forces recreation of the resource.
        :param pulumi.Input[_builtins.str] resource_type: An enumeration. The possible value is `Topic`. Changing this property forces recreation of the resource.
        :param pulumi.Input[_builtins.str] host: The IP address from which a principal is allowed or denied access to the resource. Use `*` for all hosts. Maximum length: `256`. Changing this property forces recreation of the resource.
        :param pulumi.Input[_builtins.str] id: Acl ID.
        :param pulumi.Input[_builtins.str] pattern_type: An enumeration. The possible value is `LITERAL`.
        :param pulumi.Input[_builtins.str] principal: Acl principal.
        """
        pulumi.set(__self__, "operation", operation)
        pulumi.set(__self__, "permission_type", permission_type)
        pulumi.set(__self__, "resource_name", resource_name)
        pulumi.set(__self__, "resource_type", resource_type)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if id is not None:
            pulumi.set(__self__, "id", id)
        if pattern_type is not None:
            pulumi.set(__self__, "pattern_type", pattern_type)
        if principal is not None:
            pulumi.set(__self__, "principal", principal)

    @_builtins.property
    @pulumi.getter
    def operation(self) -> pulumi.Input[_builtins.str]:
        """
        An enumeration. The possible values are `Read` and `Write`. Changing this property forces recreation of the resource.
        """
        return pulumi.get(self, "operation")

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

    @_builtins.property
    @pulumi.getter(name="permissionType")
    def permission_type(self) -> pulumi.Input[_builtins.str]:
        """
        An enumeration. The possible value is `ALLOW`. Changing this property forces recreation of the resource.
        """
        return pulumi.get(self, "permission_type")

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

    @_builtins.property
    @pulumi.getter(name="resourceName")
    def resource_name(self) -> pulumi.Input[_builtins.str]:
        """
        Acl resource name. Maximum length: `256`. Changing this property forces recreation of the resource.
        """
        return pulumi.get(self, "resource_name")

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

    @_builtins.property
    @pulumi.getter(name="resourceType")
    def resource_type(self) -> pulumi.Input[_builtins.str]:
        """
        An enumeration. The possible value is `Topic`. Changing this property forces recreation of the resource.
        """
        return pulumi.get(self, "resource_type")

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

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The IP address from which a principal is allowed or denied access to the resource. Use `*` for all hosts. Maximum length: `256`. Changing this property forces recreation of the resource.
        """
        return pulumi.get(self, "host")

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

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

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

    @_builtins.property
    @pulumi.getter(name="patternType")
    def pattern_type(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        An enumeration. The possible value is `LITERAL`.
        """
        return pulumi.get(self, "pattern_type")

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

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

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


if not MYPY:
    class GovernanceAccessTimeoutsArgsDict(TypedDict):
        create: NotRequired[pulumi.Input[_builtins.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).
        """
        delete: NotRequired[pulumi.Input[_builtins.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.
        """
        read: NotRequired[pulumi.Input[_builtins.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.
        """
        update: NotRequired[pulumi.Input[_builtins.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).
        """
elif False:
    GovernanceAccessTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GovernanceAccessTimeoutsArgs:
    def __init__(__self__, *,
                 create: Optional[pulumi.Input[_builtins.str]] = None,
                 delete: Optional[pulumi.Input[_builtins.str]] = None,
                 read: Optional[pulumi.Input[_builtins.str]] = None,
                 update: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.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[_builtins.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[_builtins.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[_builtins.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)

    @_builtins.property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "create", value)

    @_builtins.property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "delete", value)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "read", value)

    @_builtins.property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "update", value)


if not MYPY:
    class GrafanaComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    GrafanaComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GrafanaComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

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

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

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

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

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

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

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

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

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

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

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

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

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

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

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

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

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

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


if not MYPY:
    class GrafanaGrafanaArgsDict(TypedDict):
        uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Grafana server URIs.
        """
elif False:
    GrafanaGrafanaArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GrafanaGrafanaArgs:
    def __init__(__self__, *,
                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uris: Grafana server URIs.
        """
        if uris is not None:
            pulumi.set(__self__, "uris", uris)

    @_builtins.property
    @pulumi.getter
    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Grafana server URIs.
        """
        return pulumi.get(self, "uris")

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


if not MYPY:
    class GrafanaGrafanaUserConfigArgsDict(TypedDict):
        additional_backup_regions: NotRequired[pulumi.Input[_builtins.str]]
        """
        Additional Cloud Regions for Backup Replication.
        """
        alerting_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Setting has no effect with Grafana 11 and onward. Enable or disable Grafana legacy alerting functionality. This should not be enabled with unified*alerting*enabled.
        """
        alerting_error_or_timeout: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `alerting`, `keep_state`. Default error or timeout setting for new alerting rules.
        """
        alerting_max_annotations_to_keep: NotRequired[pulumi.Input[_builtins.int]]
        """
        Max number of alert annotations that Grafana stores. 0 (default) keeps all alert annotations. Example: `0`.
        """
        alerting_nodata_or_nullvalues: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `alerting`, `keep_state`, `no_data`, `ok`. Default value for 'no data or null values' for new alerting rules.
        """
        allow_embedding: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow embedding Grafana dashboards with iframe/frame/object/embed tags. Disabled by default to limit impact of clickjacking.
        """
        auth_azuread: NotRequired[pulumi.Input['GrafanaGrafanaUserConfigAuthAzureadArgsDict']]
        """
        Azure AD OAuth integration
        """
        auth_basic_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable or disable basic authentication form, used by Grafana built-in login.
        """
        auth_generic_oauth: NotRequired[pulumi.Input['GrafanaGrafanaUserConfigAuthGenericOauthArgsDict']]
        """
        Generic OAuth integration
        """
        auth_github: NotRequired[pulumi.Input['GrafanaGrafanaUserConfigAuthGithubArgsDict']]
        """
        Github Auth integration
        """
        auth_gitlab: NotRequired[pulumi.Input['GrafanaGrafanaUserConfigAuthGitlabArgsDict']]
        """
        GitLab Auth integration
        """
        auth_google: NotRequired[pulumi.Input['GrafanaGrafanaUserConfigAuthGoogleArgsDict']]
        """
        Google Auth integration
        """
        cookie_samesite: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `lax`, `none`, `strict`. Cookie SameSite attribute: `strict` prevents sending cookie for cross-site requests, effectively disabling direct linking from other sites to Grafana. `lax` is the default value.
        """
        custom_domain: NotRequired[pulumi.Input[_builtins.str]]
        """
        Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. When you set a custom domain for a service deployed in a VPC, the service certificate is only created for the public-* hostname and the custom domain. Example: `grafana.example.org`.
        """
        dashboard_previews_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable browsing of dashboards in grid (pictures) mode. This feature is new in Grafana 9 and is quite resource intensive. It may cause low-end plans to work more slowly while the dashboard previews are rendering.
        """
        dashboard_scenes_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable use of the Grafana Scenes Library as the dashboard engine. i.e. the `dashboardScene` feature flag. Upstream blog post at https://grafana.com/blog/2024/10/31/grafana-dashboards-are-now-powered-by-scenes-big-changes-same-ui/.
        """
        dashboards_min_refresh_interval: NotRequired[pulumi.Input[_builtins.str]]
        """
        Signed sequence of decimal numbers, followed by a unit suffix (ms, s, m, h, d), e.g. 30s, 1h. Example: `5s`.
        """
        dashboards_versions_to_keep: NotRequired[pulumi.Input[_builtins.int]]
        """
        Dashboard versions to keep per dashboard. Example: `20`.
        """
        dataproxy_send_user_header: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Send `X-Grafana-User` header to data source.
        """
        dataproxy_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        Timeout for data proxy requests in seconds. Example: `30`.
        """
        date_formats: NotRequired[pulumi.Input['GrafanaGrafanaUserConfigDateFormatsArgsDict']]
        """
        Grafana date format specifications
        """
        disable_gravatar: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Set to true to disable gravatar. Defaults to false (gravatar is enabled).
        """
        editors_can_admin: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Editors can manage folders, teams and dashboards created by them.
        """
        external_image_storage: NotRequired[pulumi.Input['GrafanaGrafanaUserConfigExternalImageStorageArgsDict']]
        """
        External image store settings
        """
        google_analytics_ua_id: NotRequired[pulumi.Input[_builtins.str]]
        """
        Google Analytics ID. Example: `UA-123456-4`.
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['GrafanaGrafanaUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        metrics_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable Grafana's /metrics endpoint.
        """
        oauth_allow_insecure_email_lookup: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enforce user lookup based on email instead of the unique ID provided by the IdP. This setup introduces significant security risks, such as potential phishing, spoofing, and other data breaches.
        """
        private_access: NotRequired[pulumi.Input['GrafanaGrafanaUserConfigPrivateAccessArgsDict']]
        """
        Allow access to selected service ports from private networks
        """
        privatelink_access: NotRequired[pulumi.Input['GrafanaGrafanaUserConfigPrivatelinkAccessArgsDict']]
        """
        Allow access to selected service components through Privatelink
        """
        project_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        public_access: NotRequired[pulumi.Input['GrafanaGrafanaUserConfigPublicAccessArgsDict']]
        """
        Allow access to selected service ports from the public Internet
        """
        recovery_basebackup_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of the basebackup to restore in forked service. Example: `backup-20191112t091354293891z`.
        """
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        service_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        smtp_server: NotRequired[pulumi.Input['GrafanaGrafanaUserConfigSmtpServerArgsDict']]
        """
        SMTP server settings
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
        unified_alerting_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable or disable Grafana unified alerting functionality. By default this is enabled and any legacy alerts will be migrated on upgrade to Grafana 9+. To stay on legacy alerting, set unified*alerting*enabled to false and alerting_enabled to true. See https://grafana.com/docs/grafana/latest/alerting/ for more details.
        """
        user_auto_assign_org: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Auto-assign new users on signup to main organization. Defaults to false.
        """
        user_auto_assign_org_role: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `Admin`, `Editor`, `Viewer`. Set role for new signups. Defaults to Viewer.
        """
        viewers_can_edit: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Users with view-only permission can edit but not save dashboards.
        """
        wal: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Setting to enable/disable Write-Ahead Logging. The default value is false (disabled).
        """
elif False:
    GrafanaGrafanaUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GrafanaGrafanaUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[_builtins.str]] = None,
                 alerting_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 alerting_error_or_timeout: Optional[pulumi.Input[_builtins.str]] = None,
                 alerting_max_annotations_to_keep: Optional[pulumi.Input[_builtins.int]] = None,
                 alerting_nodata_or_nullvalues: Optional[pulumi.Input[_builtins.str]] = None,
                 allow_embedding: Optional[pulumi.Input[_builtins.bool]] = None,
                 auth_azuread: Optional[pulumi.Input['GrafanaGrafanaUserConfigAuthAzureadArgs']] = None,
                 auth_basic_enabled: Optional[pulumi.Input[_builtins.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[_builtins.str]] = None,
                 custom_domain: Optional[pulumi.Input[_builtins.str]] = None,
                 dashboard_previews_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 dashboard_scenes_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 dashboards_min_refresh_interval: Optional[pulumi.Input[_builtins.str]] = None,
                 dashboards_versions_to_keep: Optional[pulumi.Input[_builtins.int]] = None,
                 dataproxy_send_user_header: Optional[pulumi.Input[_builtins.bool]] = None,
                 dataproxy_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 date_formats: Optional[pulumi.Input['GrafanaGrafanaUserConfigDateFormatsArgs']] = None,
                 disable_gravatar: Optional[pulumi.Input[_builtins.bool]] = None,
                 editors_can_admin: Optional[pulumi.Input[_builtins.bool]] = None,
                 external_image_storage: Optional[pulumi.Input['GrafanaGrafanaUserConfigExternalImageStorageArgs']] = None,
                 google_analytics_ua_id: Optional[pulumi.Input[_builtins.str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['GrafanaGrafanaUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 metrics_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 oauth_allow_insecure_email_lookup: Optional[pulumi.Input[_builtins.bool]] = None,
                 private_access: Optional[pulumi.Input['GrafanaGrafanaUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['GrafanaGrafanaUserConfigPrivatelinkAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 public_access: Optional[pulumi.Input['GrafanaGrafanaUserConfigPublicAccessArgs']] = None,
                 recovery_basebackup_name: Optional[pulumi.Input[_builtins.str]] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 service_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 smtp_server: Optional[pulumi.Input['GrafanaGrafanaUserConfigSmtpServerArgs']] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None,
                 unified_alerting_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 user_auto_assign_org: Optional[pulumi.Input[_builtins.bool]] = None,
                 user_auto_assign_org_role: Optional[pulumi.Input[_builtins.str]] = None,
                 viewers_can_edit: Optional[pulumi.Input[_builtins.bool]] = None,
                 wal: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[_builtins.bool] alerting_enabled: Setting has no effect with Grafana 11 and onward. Enable or disable Grafana legacy alerting functionality. This should not be enabled with unified*alerting*enabled.
        :param pulumi.Input[_builtins.str] alerting_error_or_timeout: Enum: `alerting`, `keep_state`. Default error or timeout setting for new alerting rules.
        :param pulumi.Input[_builtins.int] alerting_max_annotations_to_keep: Max number of alert annotations that Grafana stores. 0 (default) keeps all alert annotations. Example: `0`.
        :param pulumi.Input[_builtins.str] alerting_nodata_or_nullvalues: Enum: `alerting`, `keep_state`, `no_data`, `ok`. Default value for 'no data or null values' for new alerting rules.
        :param pulumi.Input[_builtins.bool] allow_embedding: Allow embedding Grafana dashboards with iframe/frame/object/embed tags. Disabled by default to limit impact of clickjacking.
        :param pulumi.Input['GrafanaGrafanaUserConfigAuthAzureadArgs'] auth_azuread: Azure AD OAuth integration
        :param pulumi.Input[_builtins.bool] auth_basic_enabled: Enable or disable basic authentication form, used by Grafana built-in login.
        :param pulumi.Input['GrafanaGrafanaUserConfigAuthGenericOauthArgs'] auth_generic_oauth: Generic OAuth integration
        :param pulumi.Input['GrafanaGrafanaUserConfigAuthGithubArgs'] auth_github: Github Auth integration
        :param pulumi.Input['GrafanaGrafanaUserConfigAuthGitlabArgs'] auth_gitlab: GitLab Auth integration
        :param pulumi.Input['GrafanaGrafanaUserConfigAuthGoogleArgs'] auth_google: Google Auth integration
        :param pulumi.Input[_builtins.str] cookie_samesite: Enum: `lax`, `none`, `strict`. Cookie SameSite attribute: `strict` prevents sending cookie for cross-site requests, effectively disabling direct linking from other sites to Grafana. `lax` is the default value.
        :param pulumi.Input[_builtins.str] custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. When you set a custom domain for a service deployed in a VPC, the service certificate is only created for the public-* hostname and the custom domain. Example: `grafana.example.org`.
        :param pulumi.Input[_builtins.bool] dashboard_previews_enabled: Enable browsing of dashboards in grid (pictures) mode. This feature is new in Grafana 9 and is quite resource intensive. It may cause low-end plans to work more slowly while the dashboard previews are rendering.
        :param pulumi.Input[_builtins.bool] dashboard_scenes_enabled: Enable use of the Grafana Scenes Library as the dashboard engine. i.e. the `dashboardScene` feature flag. Upstream blog post at https://grafana.com/blog/2024/10/31/grafana-dashboards-are-now-powered-by-scenes-big-changes-same-ui/.
        :param pulumi.Input[_builtins.str] dashboards_min_refresh_interval: Signed sequence of decimal numbers, followed by a unit suffix (ms, s, m, h, d), e.g. 30s, 1h. Example: `5s`.
        :param pulumi.Input[_builtins.int] dashboards_versions_to_keep: Dashboard versions to keep per dashboard. Example: `20`.
        :param pulumi.Input[_builtins.bool] dataproxy_send_user_header: Send `X-Grafana-User` header to data source.
        :param pulumi.Input[_builtins.int] dataproxy_timeout: Timeout for data proxy requests in seconds. Example: `30`.
        :param pulumi.Input['GrafanaGrafanaUserConfigDateFormatsArgs'] date_formats: Grafana date format specifications
        :param pulumi.Input[_builtins.bool] disable_gravatar: Set to true to disable gravatar. Defaults to false (gravatar is enabled).
        :param pulumi.Input[_builtins.bool] editors_can_admin: Editors can manage folders, teams and dashboards created by them.
        :param pulumi.Input['GrafanaGrafanaUserConfigExternalImageStorageArgs'] external_image_storage: External image store settings
        :param pulumi.Input[_builtins.str] google_analytics_ua_id: Google Analytics ID. Example: `UA-123456-4`.
        :param pulumi.Input[Sequence[pulumi.Input['GrafanaGrafanaUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[_builtins.bool] metrics_enabled: Enable Grafana's /metrics endpoint.
        :param pulumi.Input[_builtins.bool] oauth_allow_insecure_email_lookup: Enforce user lookup based on email instead of the unique ID provided by the IdP. This setup introduces significant security risks, such as potential phishing, spoofing, and other data breaches.
        :param pulumi.Input['GrafanaGrafanaUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks
        :param pulumi.Input['GrafanaGrafanaUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink
        :param pulumi.Input[_builtins.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. Example: `anotherprojectname`.
        :param pulumi.Input['GrafanaGrafanaUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
        :param pulumi.Input[_builtins.str] recovery_basebackup_name: Name of the basebackup to restore in forked service. Example: `backup-20191112t091354293891z`.
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input[_builtins.str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        :param pulumi.Input['GrafanaGrafanaUserConfigSmtpServerArgs'] smtp_server: SMTP server settings
        :param pulumi.Input[_builtins.bool] static_ips: Use static public IP addresses.
        :param pulumi.Input[_builtins.bool] unified_alerting_enabled: Enable or disable Grafana unified alerting functionality. By default this is enabled and any legacy alerts will be migrated on upgrade to Grafana 9+. To stay on legacy alerting, set unified*alerting*enabled to false and alerting_enabled to true. See https://grafana.com/docs/grafana/latest/alerting/ for more details.
        :param pulumi.Input[_builtins.bool] user_auto_assign_org: Auto-assign new users on signup to main organization. Defaults to false.
        :param pulumi.Input[_builtins.str] user_auto_assign_org_role: Enum: `Admin`, `Editor`, `Viewer`. Set role for new signups. Defaults to Viewer.
        :param pulumi.Input[_builtins.bool] viewers_can_edit: Users with view-only permission can edit but not save dashboards.
        :param pulumi.Input[_builtins.bool] wal: Setting to enable/disable Write-Ahead Logging. The default value is false (disabled).
        """
        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 dashboard_scenes_enabled is not None:
            pulumi.set(__self__, "dashboard_scenes_enabled", dashboard_scenes_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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `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_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        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 unified_alerting_enabled is not None:
            pulumi.set(__self__, "unified_alerting_enabled", unified_alerting_enabled)
        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)
        if wal is not None:
            pulumi.set(__self__, "wal", wal)

    @_builtins.property
    @pulumi.getter(name="additionalBackupRegions")
    def additional_backup_regions(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @_builtins.property
    @pulumi.getter(name="alertingEnabled")
    def alerting_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Setting has no effect with Grafana 11 and onward. Enable or disable Grafana legacy alerting functionality. This should not be enabled with unified*alerting*enabled.
        """
        return pulumi.get(self, "alerting_enabled")

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

    @_builtins.property
    @pulumi.getter(name="alertingErrorOrTimeout")
    def alerting_error_or_timeout(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `alerting`, `keep_state`. Default error or timeout setting for new alerting rules.
        """
        return pulumi.get(self, "alerting_error_or_timeout")

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

    @_builtins.property
    @pulumi.getter(name="alertingMaxAnnotationsToKeep")
    def alerting_max_annotations_to_keep(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Max number of alert annotations that Grafana stores. 0 (default) keeps all alert annotations. Example: `0`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "alerting_max_annotations_to_keep", value)

    @_builtins.property
    @pulumi.getter(name="alertingNodataOrNullvalues")
    def alerting_nodata_or_nullvalues(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `alerting`, `keep_state`, `no_data`, `ok`. Default value for 'no data or null values' for new alerting rules.
        """
        return pulumi.get(self, "alerting_nodata_or_nullvalues")

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

    @_builtins.property
    @pulumi.getter(name="allowEmbedding")
    def allow_embedding(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow embedding Grafana dashboards with iframe/frame/object/embed tags. Disabled by default to limit impact of clickjacking.
        """
        return pulumi.get(self, "allow_embedding")

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

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

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

    @_builtins.property
    @pulumi.getter(name="authBasicEnabled")
    def auth_basic_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable or disable basic authentication form, used by Grafana built-in login.
        """
        return pulumi.get(self, "auth_basic_enabled")

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

    @_builtins.property
    @pulumi.getter(name="authGenericOauth")
    def auth_generic_oauth(self) -> Optional[pulumi.Input['GrafanaGrafanaUserConfigAuthGenericOauthArgs']]:
        """
        Generic OAuth integration
        """
        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)

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

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

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

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

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

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

    @_builtins.property
    @pulumi.getter(name="cookieSamesite")
    def cookie_samesite(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `lax`, `none`, `strict`. Cookie SameSite attribute: `strict` prevents sending cookie for cross-site requests, effectively disabling direct linking from other sites to Grafana. `lax` is the default value.
        """
        return pulumi.get(self, "cookie_samesite")

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

    @_builtins.property
    @pulumi.getter(name="customDomain")
    def custom_domain(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. When you set a custom domain for a service deployed in a VPC, the service certificate is only created for the public-* hostname and the custom domain. Example: `grafana.example.org`.
        """
        return pulumi.get(self, "custom_domain")

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

    @_builtins.property
    @pulumi.getter(name="dashboardPreviewsEnabled")
    def dashboard_previews_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable browsing of dashboards in grid (pictures) mode. This feature is new in Grafana 9 and is quite resource intensive. It may cause low-end plans to work more slowly while the dashboard previews are rendering.
        """
        return pulumi.get(self, "dashboard_previews_enabled")

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

    @_builtins.property
    @pulumi.getter(name="dashboardScenesEnabled")
    def dashboard_scenes_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable use of the Grafana Scenes Library as the dashboard engine. i.e. the `dashboardScene` feature flag. Upstream blog post at https://grafana.com/blog/2024/10/31/grafana-dashboards-are-now-powered-by-scenes-big-changes-same-ui/.
        """
        return pulumi.get(self, "dashboard_scenes_enabled")

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

    @_builtins.property
    @pulumi.getter(name="dashboardsMinRefreshInterval")
    def dashboards_min_refresh_interval(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Signed sequence of decimal numbers, followed by a unit suffix (ms, s, m, h, d), e.g. 30s, 1h. Example: `5s`.
        """
        return pulumi.get(self, "dashboards_min_refresh_interval")

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

    @_builtins.property
    @pulumi.getter(name="dashboardsVersionsToKeep")
    def dashboards_versions_to_keep(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Dashboard versions to keep per dashboard. Example: `20`.
        """
        return pulumi.get(self, "dashboards_versions_to_keep")

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

    @_builtins.property
    @pulumi.getter(name="dataproxySendUserHeader")
    def dataproxy_send_user_header(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Send `X-Grafana-User` header to data source.
        """
        return pulumi.get(self, "dataproxy_send_user_header")

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

    @_builtins.property
    @pulumi.getter(name="dataproxyTimeout")
    def dataproxy_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Timeout for data proxy requests in seconds. Example: `30`.
        """
        return pulumi.get(self, "dataproxy_timeout")

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

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

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

    @_builtins.property
    @pulumi.getter(name="disableGravatar")
    def disable_gravatar(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Set to true to disable gravatar. Defaults to false (gravatar is enabled).
        """
        return pulumi.get(self, "disable_gravatar")

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

    @_builtins.property
    @pulumi.getter(name="editorsCanAdmin")
    def editors_can_admin(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Editors can manage folders, teams and dashboards created by them.
        """
        return pulumi.get(self, "editors_can_admin")

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

    @_builtins.property
    @pulumi.getter(name="externalImageStorage")
    def external_image_storage(self) -> Optional[pulumi.Input['GrafanaGrafanaUserConfigExternalImageStorageArgs']]:
        """
        External image store settings
        """
        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)

    @_builtins.property
    @pulumi.getter(name="googleAnalyticsUaId")
    def google_analytics_ua_id(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Google Analytics ID. Example: `UA-123456-4`.
        """
        return pulumi.get(self, "google_analytics_ua_id")

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

    @_builtins.property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['GrafanaGrafanaUserConfigIpFilterObjectArgs']]]]:
        """
        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['GrafanaGrafanaUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

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

    @_builtins.property
    @pulumi.getter(name="metricsEnabled")
    def metrics_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable Grafana's /metrics endpoint.
        """
        return pulumi.get(self, "metrics_enabled")

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

    @_builtins.property
    @pulumi.getter(name="oauthAllowInsecureEmailLookup")
    def oauth_allow_insecure_email_lookup(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enforce user lookup based on email instead of the unique ID provided by the IdP. This setup introduces significant security risks, such as potential phishing, spoofing, and other data breaches.
        """
        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[_builtins.bool]]):
        pulumi.set(self, "oauth_allow_insecure_email_lookup", value)

    @_builtins.property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['GrafanaGrafanaUserConfigPrivateAccessArgs']]:
        """
        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['GrafanaGrafanaUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @_builtins.property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['GrafanaGrafanaUserConfigPrivatelinkAccessArgs']]:
        """
        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['GrafanaGrafanaUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)

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

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

    @_builtins.property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['GrafanaGrafanaUserConfigPublicAccessArgs']]:
        """
        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['GrafanaGrafanaUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

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

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

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

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

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

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

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

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

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

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

    @_builtins.property
    @pulumi.getter(name="unifiedAlertingEnabled")
    def unified_alerting_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable or disable Grafana unified alerting functionality. By default this is enabled and any legacy alerts will be migrated on upgrade to Grafana 9+. To stay on legacy alerting, set unified*alerting*enabled to false and alerting_enabled to true. See https://grafana.com/docs/grafana/latest/alerting/ for more details.
        """
        return pulumi.get(self, "unified_alerting_enabled")

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

    @_builtins.property
    @pulumi.getter(name="userAutoAssignOrg")
    def user_auto_assign_org(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Auto-assign new users on signup to main organization. Defaults to false.
        """
        return pulumi.get(self, "user_auto_assign_org")

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

    @_builtins.property
    @pulumi.getter(name="userAutoAssignOrgRole")
    def user_auto_assign_org_role(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `Admin`, `Editor`, `Viewer`. Set role for new signups. Defaults to Viewer.
        """
        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[_builtins.str]]):
        pulumi.set(self, "user_auto_assign_org_role", value)

    @_builtins.property
    @pulumi.getter(name="viewersCanEdit")
    def viewers_can_edit(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Users with view-only permission can edit but not save dashboards.
        """
        return pulumi.get(self, "viewers_can_edit")

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

    @_builtins.property
    @pulumi.getter
    def wal(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Setting to enable/disable Write-Ahead Logging. The default value is false (disabled).
        """
        return pulumi.get(self, "wal")

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


if not MYPY:
    class GrafanaGrafanaUserConfigAuthAzureadArgsDict(TypedDict):
        auth_url: pulumi.Input[_builtins.str]
        """
        Authorization URL. Example: `https://login.microsoftonline.com/<AZURE_TENANT_ID>/oauth2/v2.0/authorize`.
        """
        client_id: pulumi.Input[_builtins.str]
        """
        Client ID from provider. Example: `b1ba0bf54a4c2c0a1c29`.
        """
        client_secret: pulumi.Input[_builtins.str]
        """
        Client secret from provider. Example: `bfa6gea4f129076761dcba8ce5e1e406bd83af7b`.
        """
        token_url: pulumi.Input[_builtins.str]
        """
        Token URL. Example: `https://login.microsoftonline.com/<AZURE_TENANT_ID>/oauth2/v2.0/token`.
        """
        allow_sign_up: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Automatically sign-up users on successful sign-in.
        """
        allowed_domains: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allowed domains.
        """
        allowed_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Require users to belong to one of given groups.
        """
elif False:
    GrafanaGrafanaUserConfigAuthAzureadArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GrafanaGrafanaUserConfigAuthAzureadArgs:
    def __init__(__self__, *,
                 auth_url: pulumi.Input[_builtins.str],
                 client_id: pulumi.Input[_builtins.str],
                 client_secret: pulumi.Input[_builtins.str],
                 token_url: pulumi.Input[_builtins.str],
                 allow_sign_up: Optional[pulumi.Input[_builtins.bool]] = None,
                 allowed_domains: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 allowed_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[_builtins.str] auth_url: Authorization URL. Example: `https://login.microsoftonline.com/<AZURE_TENANT_ID>/oauth2/v2.0/authorize`.
        :param pulumi.Input[_builtins.str] client_id: Client ID from provider. Example: `b1ba0bf54a4c2c0a1c29`.
        :param pulumi.Input[_builtins.str] client_secret: Client secret from provider. Example: `bfa6gea4f129076761dcba8ce5e1e406bd83af7b`.
        :param pulumi.Input[_builtins.str] token_url: Token URL. Example: `https://login.microsoftonline.com/<AZURE_TENANT_ID>/oauth2/v2.0/token`.
        :param pulumi.Input[_builtins.bool] allow_sign_up: Automatically sign-up users on successful sign-in.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allowed_domains: Allowed domains.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allowed_groups: Require users to belong to one of given groups.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="authUrl")
    def auth_url(self) -> pulumi.Input[_builtins.str]:
        """
        Authorization URL. Example: `https://login.microsoftonline.com/<AZURE_TENANT_ID>/oauth2/v2.0/authorize`.
        """
        return pulumi.get(self, "auth_url")

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

    @_builtins.property
    @pulumi.getter(name="clientId")
    def client_id(self) -> pulumi.Input[_builtins.str]:
        """
        Client ID from provider. Example: `b1ba0bf54a4c2c0a1c29`.
        """
        return pulumi.get(self, "client_id")

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

    @_builtins.property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> pulumi.Input[_builtins.str]:
        """
        Client secret from provider. Example: `bfa6gea4f129076761dcba8ce5e1e406bd83af7b`.
        """
        return pulumi.get(self, "client_secret")

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

    @_builtins.property
    @pulumi.getter(name="tokenUrl")
    def token_url(self) -> pulumi.Input[_builtins.str]:
        """
        Token URL. Example: `https://login.microsoftonline.com/<AZURE_TENANT_ID>/oauth2/v2.0/token`.
        """
        return pulumi.get(self, "token_url")

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

    @_builtins.property
    @pulumi.getter(name="allowSignUp")
    def allow_sign_up(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Automatically sign-up users on successful sign-in.
        """
        return pulumi.get(self, "allow_sign_up")

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

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

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

    @_builtins.property
    @pulumi.getter(name="allowedGroups")
    def allowed_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Require users to belong to one of given groups.
        """
        return pulumi.get(self, "allowed_groups")

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


if not MYPY:
    class GrafanaGrafanaUserConfigAuthGenericOauthArgsDict(TypedDict):
        api_url: pulumi.Input[_builtins.str]
        """
        API URL. Example: `https://yourprovider.com/api`.
        """
        auth_url: pulumi.Input[_builtins.str]
        """
        Authorization URL. Example: `https://yourprovider.com/oauth/authorize`.
        """
        client_id: pulumi.Input[_builtins.str]
        """
        Client ID from provider. Example: `b1ba0bf54a4c2c0a1c29`.
        """
        client_secret: pulumi.Input[_builtins.str]
        """
        Client secret from provider. Example: `bfa6gea4f129076761dcba8ce5e1e406bd83af7b`.
        """
        token_url: pulumi.Input[_builtins.str]
        """
        Token URL. Example: `https://yourprovider.com/oauth/token`.
        """
        allow_sign_up: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Automatically sign-up users on successful sign-in.
        """
        allowed_domains: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allowed domains.
        """
        allowed_organizations: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Require user to be member of one of the listed organizations.
        """
        auto_login: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow users to bypass the login screen and automatically log in.
        """
        name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of the OAuth integration. Example: `My authentication`.
        """
        scopes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        OAuth scopes.
        """
        use_refresh_token: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Set to true to use refresh token and check access token expiration.
        """
elif False:
    GrafanaGrafanaUserConfigAuthGenericOauthArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GrafanaGrafanaUserConfigAuthGenericOauthArgs:
    def __init__(__self__, *,
                 api_url: pulumi.Input[_builtins.str],
                 auth_url: pulumi.Input[_builtins.str],
                 client_id: pulumi.Input[_builtins.str],
                 client_secret: pulumi.Input[_builtins.str],
                 token_url: pulumi.Input[_builtins.str],
                 allow_sign_up: Optional[pulumi.Input[_builtins.bool]] = None,
                 allowed_domains: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 allowed_organizations: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 auto_login: Optional[pulumi.Input[_builtins.bool]] = None,
                 name: Optional[pulumi.Input[_builtins.str]] = None,
                 scopes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 use_refresh_token: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] api_url: API URL. Example: `https://yourprovider.com/api`.
        :param pulumi.Input[_builtins.str] auth_url: Authorization URL. Example: `https://yourprovider.com/oauth/authorize`.
        :param pulumi.Input[_builtins.str] client_id: Client ID from provider. Example: `b1ba0bf54a4c2c0a1c29`.
        :param pulumi.Input[_builtins.str] client_secret: Client secret from provider. Example: `bfa6gea4f129076761dcba8ce5e1e406bd83af7b`.
        :param pulumi.Input[_builtins.str] token_url: Token URL. Example: `https://yourprovider.com/oauth/token`.
        :param pulumi.Input[_builtins.bool] allow_sign_up: Automatically sign-up users on successful sign-in.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allowed_domains: Allowed domains.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allowed_organizations: Require user to be member of one of the listed organizations.
        :param pulumi.Input[_builtins.bool] auto_login: Allow users to bypass the login screen and automatically log in.
        :param pulumi.Input[_builtins.str] name: Name of the OAuth integration. Example: `My authentication`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] scopes: OAuth scopes.
        :param pulumi.Input[_builtins.bool] use_refresh_token: Set to true to use refresh token and check access token expiration.
        """
        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)
        if use_refresh_token is not None:
            pulumi.set(__self__, "use_refresh_token", use_refresh_token)

    @_builtins.property
    @pulumi.getter(name="apiUrl")
    def api_url(self) -> pulumi.Input[_builtins.str]:
        """
        API URL. Example: `https://yourprovider.com/api`.
        """
        return pulumi.get(self, "api_url")

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

    @_builtins.property
    @pulumi.getter(name="authUrl")
    def auth_url(self) -> pulumi.Input[_builtins.str]:
        """
        Authorization URL. Example: `https://yourprovider.com/oauth/authorize`.
        """
        return pulumi.get(self, "auth_url")

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

    @_builtins.property
    @pulumi.getter(name="clientId")
    def client_id(self) -> pulumi.Input[_builtins.str]:
        """
        Client ID from provider. Example: `b1ba0bf54a4c2c0a1c29`.
        """
        return pulumi.get(self, "client_id")

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

    @_builtins.property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> pulumi.Input[_builtins.str]:
        """
        Client secret from provider. Example: `bfa6gea4f129076761dcba8ce5e1e406bd83af7b`.
        """
        return pulumi.get(self, "client_secret")

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

    @_builtins.property
    @pulumi.getter(name="tokenUrl")
    def token_url(self) -> pulumi.Input[_builtins.str]:
        """
        Token URL. Example: `https://yourprovider.com/oauth/token`.
        """
        return pulumi.get(self, "token_url")

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

    @_builtins.property
    @pulumi.getter(name="allowSignUp")
    def allow_sign_up(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Automatically sign-up users on successful sign-in.
        """
        return pulumi.get(self, "allow_sign_up")

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

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

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

    @_builtins.property
    @pulumi.getter(name="allowedOrganizations")
    def allowed_organizations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Require user to be member of one of the listed organizations.
        """
        return pulumi.get(self, "allowed_organizations")

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

    @_builtins.property
    @pulumi.getter(name="autoLogin")
    def auto_login(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow users to bypass the login screen and automatically log in.
        """
        return pulumi.get(self, "auto_login")

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

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of the OAuth integration. Example: `My authentication`.
        """
        return pulumi.get(self, "name")

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

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

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

    @_builtins.property
    @pulumi.getter(name="useRefreshToken")
    def use_refresh_token(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Set to true to use refresh token and check access token expiration.
        """
        return pulumi.get(self, "use_refresh_token")

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


if not MYPY:
    class GrafanaGrafanaUserConfigAuthGithubArgsDict(TypedDict):
        client_id: pulumi.Input[_builtins.str]
        """
        Client ID from provider. Example: `b1ba0bf54a4c2c0a1c29`.
        """
        client_secret: pulumi.Input[_builtins.str]
        """
        Client secret from provider. Example: `bfa6gea4f129076761dcba8ce5e1e406bd83af7b`.
        """
        allow_sign_up: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Automatically sign-up users on successful sign-in.
        """
        allowed_organizations: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Require users to belong to one of given organizations.
        """
        auto_login: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow users to bypass the login screen and automatically log in.
        """
        skip_org_role_sync: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Stop automatically syncing user roles.
        """
        team_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]
        """
        Require users to belong to one of given team IDs.
        """
elif False:
    GrafanaGrafanaUserConfigAuthGithubArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GrafanaGrafanaUserConfigAuthGithubArgs:
    def __init__(__self__, *,
                 client_id: pulumi.Input[_builtins.str],
                 client_secret: pulumi.Input[_builtins.str],
                 allow_sign_up: Optional[pulumi.Input[_builtins.bool]] = None,
                 allowed_organizations: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 auto_login: Optional[pulumi.Input[_builtins.bool]] = None,
                 skip_org_role_sync: Optional[pulumi.Input[_builtins.bool]] = None,
                 team_ids: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]] = None):
        """
        :param pulumi.Input[_builtins.str] client_id: Client ID from provider. Example: `b1ba0bf54a4c2c0a1c29`.
        :param pulumi.Input[_builtins.str] client_secret: Client secret from provider. Example: `bfa6gea4f129076761dcba8ce5e1e406bd83af7b`.
        :param pulumi.Input[_builtins.bool] allow_sign_up: Automatically sign-up users on successful sign-in.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allowed_organizations: Require users to belong to one of given organizations.
        :param pulumi.Input[_builtins.bool] auto_login: Allow users to bypass the login screen and automatically log in.
        :param pulumi.Input[_builtins.bool] skip_org_role_sync: Stop automatically syncing user roles.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.int]]] team_ids: Require users to belong to one of given team IDs.
        """
        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 auto_login is not None:
            pulumi.set(__self__, "auto_login", auto_login)
        if skip_org_role_sync is not None:
            pulumi.set(__self__, "skip_org_role_sync", skip_org_role_sync)
        if team_ids is not None:
            pulumi.set(__self__, "team_ids", team_ids)

    @_builtins.property
    @pulumi.getter(name="clientId")
    def client_id(self) -> pulumi.Input[_builtins.str]:
        """
        Client ID from provider. Example: `b1ba0bf54a4c2c0a1c29`.
        """
        return pulumi.get(self, "client_id")

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

    @_builtins.property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> pulumi.Input[_builtins.str]:
        """
        Client secret from provider. Example: `bfa6gea4f129076761dcba8ce5e1e406bd83af7b`.
        """
        return pulumi.get(self, "client_secret")

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

    @_builtins.property
    @pulumi.getter(name="allowSignUp")
    def allow_sign_up(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Automatically sign-up users on successful sign-in.
        """
        return pulumi.get(self, "allow_sign_up")

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

    @_builtins.property
    @pulumi.getter(name="allowedOrganizations")
    def allowed_organizations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Require users to belong to one of given organizations.
        """
        return pulumi.get(self, "allowed_organizations")

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

    @_builtins.property
    @pulumi.getter(name="autoLogin")
    def auto_login(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow users to bypass the login screen and automatically log in.
        """
        return pulumi.get(self, "auto_login")

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

    @_builtins.property
    @pulumi.getter(name="skipOrgRoleSync")
    def skip_org_role_sync(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Stop automatically syncing user roles.
        """
        return pulumi.get(self, "skip_org_role_sync")

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

    @_builtins.property
    @pulumi.getter(name="teamIds")
    def team_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]:
        """
        Require users to belong to one of given team IDs.
        """
        return pulumi.get(self, "team_ids")

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


if not MYPY:
    class GrafanaGrafanaUserConfigAuthGitlabArgsDict(TypedDict):
        allowed_groups: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
        """
        Require users to belong to one of given groups.
        """
        client_id: pulumi.Input[_builtins.str]
        """
        Client ID from provider. Example: `b1ba0bf54a4c2c0a1c29`.
        """
        client_secret: pulumi.Input[_builtins.str]
        """
        Client secret from provider. Example: `bfa6gea4f129076761dcba8ce5e1e406bd83af7b`.
        """
        allow_sign_up: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Automatically sign-up users on successful sign-in.
        """
        api_url: NotRequired[pulumi.Input[_builtins.str]]
        """
        This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/api/v4`.
        """
        auth_url: NotRequired[pulumi.Input[_builtins.str]]
        """
        This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/authorize`.
        """
        token_url: NotRequired[pulumi.Input[_builtins.str]]
        """
        This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/token`.
        """
elif False:
    GrafanaGrafanaUserConfigAuthGitlabArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GrafanaGrafanaUserConfigAuthGitlabArgs:
    def __init__(__self__, *,
                 allowed_groups: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
                 client_id: pulumi.Input[_builtins.str],
                 client_secret: pulumi.Input[_builtins.str],
                 allow_sign_up: Optional[pulumi.Input[_builtins.bool]] = None,
                 api_url: Optional[pulumi.Input[_builtins.str]] = None,
                 auth_url: Optional[pulumi.Input[_builtins.str]] = None,
                 token_url: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allowed_groups: Require users to belong to one of given groups.
        :param pulumi.Input[_builtins.str] client_id: Client ID from provider. Example: `b1ba0bf54a4c2c0a1c29`.
        :param pulumi.Input[_builtins.str] client_secret: Client secret from provider. Example: `bfa6gea4f129076761dcba8ce5e1e406bd83af7b`.
        :param pulumi.Input[_builtins.bool] allow_sign_up: Automatically sign-up users on successful sign-in.
        :param pulumi.Input[_builtins.str] api_url: This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/api/v4`.
        :param pulumi.Input[_builtins.str] auth_url: This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/authorize`.
        :param pulumi.Input[_builtins.str] token_url: This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/token`.
        """
        pulumi.set(__self__, "allowed_groups", allowed_groups)
        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 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)

    @_builtins.property
    @pulumi.getter(name="allowedGroups")
    def allowed_groups(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
        """
        Require users to belong to one of given groups.
        """
        return pulumi.get(self, "allowed_groups")

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

    @_builtins.property
    @pulumi.getter(name="clientId")
    def client_id(self) -> pulumi.Input[_builtins.str]:
        """
        Client ID from provider. Example: `b1ba0bf54a4c2c0a1c29`.
        """
        return pulumi.get(self, "client_id")

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

    @_builtins.property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> pulumi.Input[_builtins.str]:
        """
        Client secret from provider. Example: `bfa6gea4f129076761dcba8ce5e1e406bd83af7b`.
        """
        return pulumi.get(self, "client_secret")

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

    @_builtins.property
    @pulumi.getter(name="allowSignUp")
    def allow_sign_up(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Automatically sign-up users on successful sign-in.
        """
        return pulumi.get(self, "allow_sign_up")

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

    @_builtins.property
    @pulumi.getter(name="apiUrl")
    def api_url(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/api/v4`.
        """
        return pulumi.get(self, "api_url")

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

    @_builtins.property
    @pulumi.getter(name="authUrl")
    def auth_url(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/authorize`.
        """
        return pulumi.get(self, "auth_url")

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

    @_builtins.property
    @pulumi.getter(name="tokenUrl")
    def token_url(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        This only needs to be set when using self hosted GitLab. Example: `https://gitlab.com/oauth/token`.
        """
        return pulumi.get(self, "token_url")

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


if not MYPY:
    class GrafanaGrafanaUserConfigAuthGoogleArgsDict(TypedDict):
        allowed_domains: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
        """
        Domains allowed to sign-in to this Grafana.
        """
        client_id: pulumi.Input[_builtins.str]
        """
        Client ID from provider. Example: `b1ba0bf54a4c2c0a1c29`.
        """
        client_secret: pulumi.Input[_builtins.str]
        """
        Client secret from provider. Example: `bfa6gea4f129076761dcba8ce5e1e406bd83af7b`.
        """
        allow_sign_up: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Automatically sign-up users on successful sign-in.
        """
elif False:
    GrafanaGrafanaUserConfigAuthGoogleArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GrafanaGrafanaUserConfigAuthGoogleArgs:
    def __init__(__self__, *,
                 allowed_domains: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
                 client_id: pulumi.Input[_builtins.str],
                 client_secret: pulumi.Input[_builtins.str],
                 allow_sign_up: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allowed_domains: Domains allowed to sign-in to this Grafana.
        :param pulumi.Input[_builtins.str] client_id: Client ID from provider. Example: `b1ba0bf54a4c2c0a1c29`.
        :param pulumi.Input[_builtins.str] client_secret: Client secret from provider. Example: `bfa6gea4f129076761dcba8ce5e1e406bd83af7b`.
        :param pulumi.Input[_builtins.bool] allow_sign_up: Automatically sign-up users on successful sign-in.
        """
        pulumi.set(__self__, "allowed_domains", allowed_domains)
        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)

    @_builtins.property
    @pulumi.getter(name="allowedDomains")
    def allowed_domains(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
        """
        Domains allowed to sign-in to this Grafana.
        """
        return pulumi.get(self, "allowed_domains")

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

    @_builtins.property
    @pulumi.getter(name="clientId")
    def client_id(self) -> pulumi.Input[_builtins.str]:
        """
        Client ID from provider. Example: `b1ba0bf54a4c2c0a1c29`.
        """
        return pulumi.get(self, "client_id")

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

    @_builtins.property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> pulumi.Input[_builtins.str]:
        """
        Client secret from provider. Example: `bfa6gea4f129076761dcba8ce5e1e406bd83af7b`.
        """
        return pulumi.get(self, "client_secret")

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

    @_builtins.property
    @pulumi.getter(name="allowSignUp")
    def allow_sign_up(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Automatically sign-up users on successful sign-in.
        """
        return pulumi.get(self, "allow_sign_up")

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


if not MYPY:
    class GrafanaGrafanaUserConfigDateFormatsArgsDict(TypedDict):
        default_timezone: NotRequired[pulumi.Input[_builtins.str]]
        """
        Default time zone for user preferences. Value `browser` uses browser local time zone. Example: `Europe/Helsinki`.
        """
        full_date: NotRequired[pulumi.Input[_builtins.str]]
        """
        Moment.js style format string for cases where full date is shown. Example: `YYYY MM DD`.
        """
        interval_day: NotRequired[pulumi.Input[_builtins.str]]
        """
        Moment.js style format string used when a time requiring day accuracy is shown. Example: `MM/DD`.
        """
        interval_hour: NotRequired[pulumi.Input[_builtins.str]]
        """
        Moment.js style format string used when a time requiring hour accuracy is shown. Example: `MM/DD HH:mm`.
        """
        interval_minute: NotRequired[pulumi.Input[_builtins.str]]
        """
        Moment.js style format string used when a time requiring minute accuracy is shown. Example: `HH:mm`.
        """
        interval_month: NotRequired[pulumi.Input[_builtins.str]]
        """
        Moment.js style format string used when a time requiring month accuracy is shown. Example: `YYYY-MM`.
        """
        interval_second: NotRequired[pulumi.Input[_builtins.str]]
        """
        Moment.js style format string used when a time requiring second accuracy is shown. Example: `HH:mm:ss`.
        """
        interval_year: NotRequired[pulumi.Input[_builtins.str]]
        """
        Moment.js style format string used when a time requiring year accuracy is shown. Example: `YYYY`.
        """
elif False:
    GrafanaGrafanaUserConfigDateFormatsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GrafanaGrafanaUserConfigDateFormatsArgs:
    def __init__(__self__, *,
                 default_timezone: Optional[pulumi.Input[_builtins.str]] = None,
                 full_date: Optional[pulumi.Input[_builtins.str]] = None,
                 interval_day: Optional[pulumi.Input[_builtins.str]] = None,
                 interval_hour: Optional[pulumi.Input[_builtins.str]] = None,
                 interval_minute: Optional[pulumi.Input[_builtins.str]] = None,
                 interval_month: Optional[pulumi.Input[_builtins.str]] = None,
                 interval_second: Optional[pulumi.Input[_builtins.str]] = None,
                 interval_year: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] default_timezone: Default time zone for user preferences. Value `browser` uses browser local time zone. Example: `Europe/Helsinki`.
        :param pulumi.Input[_builtins.str] full_date: Moment.js style format string for cases where full date is shown. Example: `YYYY MM DD`.
        :param pulumi.Input[_builtins.str] interval_day: Moment.js style format string used when a time requiring day accuracy is shown. Example: `MM/DD`.
        :param pulumi.Input[_builtins.str] interval_hour: Moment.js style format string used when a time requiring hour accuracy is shown. Example: `MM/DD HH:mm`.
        :param pulumi.Input[_builtins.str] interval_minute: Moment.js style format string used when a time requiring minute accuracy is shown. Example: `HH:mm`.
        :param pulumi.Input[_builtins.str] interval_month: Moment.js style format string used when a time requiring month accuracy is shown. Example: `YYYY-MM`.
        :param pulumi.Input[_builtins.str] interval_second: Moment.js style format string used when a time requiring second accuracy is shown. Example: `HH:mm:ss`.
        :param pulumi.Input[_builtins.str] interval_year: Moment.js style format string used when a time requiring year accuracy is shown. Example: `YYYY`.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="defaultTimezone")
    def default_timezone(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Default time zone for user preferences. Value `browser` uses browser local time zone. Example: `Europe/Helsinki`.
        """
        return pulumi.get(self, "default_timezone")

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

    @_builtins.property
    @pulumi.getter(name="fullDate")
    def full_date(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Moment.js style format string for cases where full date is shown. Example: `YYYY MM DD`.
        """
        return pulumi.get(self, "full_date")

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

    @_builtins.property
    @pulumi.getter(name="intervalDay")
    def interval_day(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Moment.js style format string used when a time requiring day accuracy is shown. Example: `MM/DD`.
        """
        return pulumi.get(self, "interval_day")

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

    @_builtins.property
    @pulumi.getter(name="intervalHour")
    def interval_hour(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Moment.js style format string used when a time requiring hour accuracy is shown. Example: `MM/DD HH:mm`.
        """
        return pulumi.get(self, "interval_hour")

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

    @_builtins.property
    @pulumi.getter(name="intervalMinute")
    def interval_minute(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Moment.js style format string used when a time requiring minute accuracy is shown. Example: `HH:mm`.
        """
        return pulumi.get(self, "interval_minute")

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

    @_builtins.property
    @pulumi.getter(name="intervalMonth")
    def interval_month(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Moment.js style format string used when a time requiring month accuracy is shown. Example: `YYYY-MM`.
        """
        return pulumi.get(self, "interval_month")

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

    @_builtins.property
    @pulumi.getter(name="intervalSecond")
    def interval_second(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Moment.js style format string used when a time requiring second accuracy is shown. Example: `HH:mm:ss`.
        """
        return pulumi.get(self, "interval_second")

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

    @_builtins.property
    @pulumi.getter(name="intervalYear")
    def interval_year(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Moment.js style format string used when a time requiring year accuracy is shown. Example: `YYYY`.
        """
        return pulumi.get(self, "interval_year")

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


if not MYPY:
    class GrafanaGrafanaUserConfigExternalImageStorageArgsDict(TypedDict):
        access_key: pulumi.Input[_builtins.str]
        """
        S3 access key. Requires permissions to the S3 bucket for the s3:PutObject and s3:PutObjectAcl actions. Example: `AAAAAAAAAAAAAAAAAAA`.
        """
        bucket_url: pulumi.Input[_builtins.str]
        """
        Bucket URL for S3. Example: `https://grafana.s3-ap-southeast-2.amazonaws.com/`.
        """
        provider: pulumi.Input[_builtins.str]
        """
        Enum: `s3`. External image store provider.
        """
        secret_key: pulumi.Input[_builtins.str]
        """
        S3 secret key. Example: `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`.
        """
elif False:
    GrafanaGrafanaUserConfigExternalImageStorageArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GrafanaGrafanaUserConfigExternalImageStorageArgs:
    def __init__(__self__, *,
                 access_key: pulumi.Input[_builtins.str],
                 bucket_url: pulumi.Input[_builtins.str],
                 provider: pulumi.Input[_builtins.str],
                 secret_key: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] access_key: S3 access key. Requires permissions to the S3 bucket for the s3:PutObject and s3:PutObjectAcl actions. Example: `AAAAAAAAAAAAAAAAAAA`.
        :param pulumi.Input[_builtins.str] bucket_url: Bucket URL for S3. Example: `https://grafana.s3-ap-southeast-2.amazonaws.com/`.
        :param pulumi.Input[_builtins.str] provider: Enum: `s3`. External image store provider.
        :param pulumi.Input[_builtins.str] secret_key: S3 secret key. Example: `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> pulumi.Input[_builtins.str]:
        """
        S3 access key. Requires permissions to the S3 bucket for the s3:PutObject and s3:PutObjectAcl actions. Example: `AAAAAAAAAAAAAAAAAAA`.
        """
        return pulumi.get(self, "access_key")

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

    @_builtins.property
    @pulumi.getter(name="bucketUrl")
    def bucket_url(self) -> pulumi.Input[_builtins.str]:
        """
        Bucket URL for S3. Example: `https://grafana.s3-ap-southeast-2.amazonaws.com/`.
        """
        return pulumi.get(self, "bucket_url")

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

    @_builtins.property
    @pulumi.getter
    def provider(self) -> pulumi.Input[_builtins.str]:
        """
        Enum: `s3`. External image store provider.
        """
        return pulumi.get(self, "provider")

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

    @_builtins.property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> pulumi.Input[_builtins.str]:
        """
        S3 secret key. Example: `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`.
        """
        return pulumi.get(self, "secret_key")

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


if not MYPY:
    class GrafanaGrafanaUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    GrafanaGrafanaUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GrafanaGrafanaUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

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

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

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


if not MYPY:
    class GrafanaGrafanaUserConfigPrivateAccessArgsDict(TypedDict):
        grafana: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to grafana with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
elif False:
    GrafanaGrafanaUserConfigPrivateAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GrafanaGrafanaUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 grafana: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] grafana: Allow clients to connect to grafana with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        if grafana is not None:
            pulumi.set(__self__, "grafana", grafana)

    @_builtins.property
    @pulumi.getter
    def grafana(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to grafana with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "grafana")

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


if not MYPY:
    class GrafanaGrafanaUserConfigPrivatelinkAccessArgsDict(TypedDict):
        grafana: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable grafana.
        """
elif False:
    GrafanaGrafanaUserConfigPrivatelinkAccessArgsDict: TypeAlias = Mapping[str, Any]

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

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

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


if not MYPY:
    class GrafanaGrafanaUserConfigPublicAccessArgsDict(TypedDict):
        grafana: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to grafana from the public internet for service nodes that are in a project VPC or another type of private network.
        """
elif False:
    GrafanaGrafanaUserConfigPublicAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GrafanaGrafanaUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 grafana: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] grafana: Allow clients to connect to grafana from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        if grafana is not None:
            pulumi.set(__self__, "grafana", grafana)

    @_builtins.property
    @pulumi.getter
    def grafana(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to grafana from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "grafana")

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


if not MYPY:
    class GrafanaGrafanaUserConfigSmtpServerArgsDict(TypedDict):
        from_address: pulumi.Input[_builtins.str]
        """
        Address used for sending emails. Example: `yourgrafanauser@yourdomain.example.com`.
        """
        host: pulumi.Input[_builtins.str]
        """
        Server hostname or IP. Example: `smtp.example.com`.
        """
        port: pulumi.Input[_builtins.int]
        """
        SMTP server port. Example: `25`.
        """
        from_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name used in outgoing emails, defaults to Grafana.
        """
        password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Password for SMTP authentication. Example: `ein0eemeev5eeth3Ahfu`.
        """
        skip_verify: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Skip verifying server certificate. Defaults to false.
        """
        starttls_policy: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `MandatoryStartTLS`, `NoStartTLS`, `OpportunisticStartTLS`. Either OpportunisticStartTLS, MandatoryStartTLS or NoStartTLS. Default is OpportunisticStartTLS.
        """
        username: NotRequired[pulumi.Input[_builtins.str]]
        """
        Username for SMTP authentication. Example: `smtpuser`.
        """
elif False:
    GrafanaGrafanaUserConfigSmtpServerArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GrafanaGrafanaUserConfigSmtpServerArgs:
    def __init__(__self__, *,
                 from_address: pulumi.Input[_builtins.str],
                 host: pulumi.Input[_builtins.str],
                 port: pulumi.Input[_builtins.int],
                 from_name: Optional[pulumi.Input[_builtins.str]] = None,
                 password: Optional[pulumi.Input[_builtins.str]] = None,
                 skip_verify: Optional[pulumi.Input[_builtins.bool]] = None,
                 starttls_policy: Optional[pulumi.Input[_builtins.str]] = None,
                 username: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] from_address: Address used for sending emails. Example: `yourgrafanauser@yourdomain.example.com`.
        :param pulumi.Input[_builtins.str] host: Server hostname or IP. Example: `smtp.example.com`.
        :param pulumi.Input[_builtins.int] port: SMTP server port. Example: `25`.
        :param pulumi.Input[_builtins.str] from_name: Name used in outgoing emails, defaults to Grafana.
        :param pulumi.Input[_builtins.str] password: Password for SMTP authentication. Example: `ein0eemeev5eeth3Ahfu`.
        :param pulumi.Input[_builtins.bool] skip_verify: Skip verifying server certificate. Defaults to false.
        :param pulumi.Input[_builtins.str] starttls_policy: Enum: `MandatoryStartTLS`, `NoStartTLS`, `OpportunisticStartTLS`. Either OpportunisticStartTLS, MandatoryStartTLS or NoStartTLS. Default is OpportunisticStartTLS.
        :param pulumi.Input[_builtins.str] username: Username for SMTP authentication. Example: `smtpuser`.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="fromAddress")
    def from_address(self) -> pulumi.Input[_builtins.str]:
        """
        Address used for sending emails. Example: `yourgrafanauser@yourdomain.example.com`.
        """
        return pulumi.get(self, "from_address")

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

    @_builtins.property
    @pulumi.getter
    def host(self) -> pulumi.Input[_builtins.str]:
        """
        Server hostname or IP. Example: `smtp.example.com`.
        """
        return pulumi.get(self, "host")

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

    @_builtins.property
    @pulumi.getter
    def port(self) -> pulumi.Input[_builtins.int]:
        """
        SMTP server port. Example: `25`.
        """
        return pulumi.get(self, "port")

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

    @_builtins.property
    @pulumi.getter(name="fromName")
    def from_name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name used in outgoing emails, defaults to Grafana.
        """
        return pulumi.get(self, "from_name")

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

    @_builtins.property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Password for SMTP authentication. Example: `ein0eemeev5eeth3Ahfu`.
        """
        return pulumi.get(self, "password")

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

    @_builtins.property
    @pulumi.getter(name="skipVerify")
    def skip_verify(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Skip verifying server certificate. Defaults to false.
        """
        return pulumi.get(self, "skip_verify")

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

    @_builtins.property
    @pulumi.getter(name="starttlsPolicy")
    def starttls_policy(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `MandatoryStartTLS`, `NoStartTLS`, `OpportunisticStartTLS`. Either OpportunisticStartTLS, MandatoryStartTLS or NoStartTLS. Default is OpportunisticStartTLS.
        """
        return pulumi.get(self, "starttls_policy")

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

    @_builtins.property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Username for SMTP authentication. Example: `smtpuser`.
        """
        return pulumi.get(self, "username")

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


if not MYPY:
    class GrafanaServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    GrafanaServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GrafanaServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration
        :param pulumi.Input[_builtins.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)

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

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

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class GrafanaTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    GrafanaTagArgsDict: TypeAlias = Mapping[str, Any]

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

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

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

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

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


if not MYPY:
    class GrafanaTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    GrafanaTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GrafanaTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

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


if not MYPY:
    class InfluxDbComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    InfluxDbComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InfluxDbComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

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

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

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

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

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

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

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

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

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

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

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

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

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

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

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

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

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

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


if not MYPY:
    class InfluxDbInfluxdbArgsDict(TypedDict):
        database_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of the default InfluxDB database
        """
        password: NotRequired[pulumi.Input[_builtins.str]]
        """
        InfluxDB password
        """
        uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        InfluxDB server URIs.
        """
        username: NotRequired[pulumi.Input[_builtins.str]]
        """
        InfluxDB username
        """
elif False:
    InfluxDbInfluxdbArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InfluxDbInfluxdbArgs:
    def __init__(__self__, *,
                 database_name: Optional[pulumi.Input[_builtins.str]] = None,
                 password: Optional[pulumi.Input[_builtins.str]] = None,
                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 username: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] database_name: Name of the default InfluxDB database
        :param pulumi.Input[_builtins.str] password: InfluxDB password
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uris: InfluxDB server URIs.
        :param pulumi.Input[_builtins.str] username: InfluxDB username
        """
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if uris is not None:
            pulumi.set(__self__, "uris", uris)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @_builtins.property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of the default InfluxDB database
        """
        return pulumi.get(self, "database_name")

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

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

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

    @_builtins.property
    @pulumi.getter
    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        InfluxDB server URIs.
        """
        return pulumi.get(self, "uris")

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

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

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


if not MYPY:
    class InfluxDbInfluxdbUserConfigArgsDict(TypedDict):
        additional_backup_regions: NotRequired[pulumi.Input[_builtins.str]]
        """
        Additional Cloud Regions for Backup Replication.
        """
        custom_domain: NotRequired[pulumi.Input[_builtins.str]]
        """
        Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. When you set a custom domain for a service deployed in a VPC, the service certificate is only created for the public-* hostname and the custom domain. Example: `grafana.example.org`.
        """
        influxdb: NotRequired[pulumi.Input['InfluxDbInfluxdbUserConfigInfluxdbArgsDict']]
        """
        influxdb.conf configuration values
        """
        influxdb_version: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `1.8`, and newer. InfluxDB major version. Default: `1.8`.
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['InfluxDbInfluxdbUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        private_access: NotRequired[pulumi.Input['InfluxDbInfluxdbUserConfigPrivateAccessArgsDict']]
        """
        Allow access to selected service ports from private networks
        """
        privatelink_access: NotRequired[pulumi.Input['InfluxDbInfluxdbUserConfigPrivatelinkAccessArgsDict']]
        """
        Allow access to selected service components through Privatelink
        """
        project_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        public_access: NotRequired[pulumi.Input['InfluxDbInfluxdbUserConfigPublicAccessArgsDict']]
        """
        Allow access to selected service ports from the public Internet
        """
        recovery_basebackup_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of the basebackup to restore in forked service. Example: `backup-20191112t091354293891z`.
        """
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        service_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
elif False:
    InfluxDbInfluxdbUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InfluxDbInfluxdbUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[_builtins.str]] = None,
                 custom_domain: Optional[pulumi.Input[_builtins.str]] = None,
                 influxdb: Optional[pulumi.Input['InfluxDbInfluxdbUserConfigInfluxdbArgs']] = None,
                 influxdb_version: Optional[pulumi.Input[_builtins.str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['InfluxDbInfluxdbUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 private_access: Optional[pulumi.Input['InfluxDbInfluxdbUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['InfluxDbInfluxdbUserConfigPrivatelinkAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 public_access: Optional[pulumi.Input['InfluxDbInfluxdbUserConfigPublicAccessArgs']] = None,
                 recovery_basebackup_name: Optional[pulumi.Input[_builtins.str]] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 service_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[_builtins.str] custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. When you set a custom domain for a service deployed in a VPC, the service certificate is only created for the public-* hostname and the custom domain. Example: `grafana.example.org`.
        :param pulumi.Input['InfluxDbInfluxdbUserConfigInfluxdbArgs'] influxdb: influxdb.conf configuration values
        :param pulumi.Input[_builtins.str] influxdb_version: Enum: `1.8`, and newer. InfluxDB major version. Default: `1.8`.
        :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[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.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. Example: `anotherprojectname`.
        :param pulumi.Input['InfluxDbInfluxdbUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
        :param pulumi.Input[_builtins.str] recovery_basebackup_name: Name of the basebackup to restore in forked service. Example: `backup-20191112t091354293891z`.
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input[_builtins.str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        :param pulumi.Input[_builtins.bool] static_ips: Use static public IP addresses.
        """
        if additional_backup_regions is not None:
            warnings.warn("""This property is deprecated.""", DeprecationWarning)
            pulumi.log.warn("""additional_backup_regions is deprecated: This property is deprecated.""")
        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 influxdb_version is not None:
            pulumi.set(__self__, "influxdb_version", influxdb_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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `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_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        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)

    @_builtins.property
    @pulumi.getter(name="additionalBackupRegions")
    @_utilities.deprecated("""This property is deprecated.""")
    def additional_backup_regions(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @_builtins.property
    @pulumi.getter(name="customDomain")
    def custom_domain(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. When you set a custom domain for a service deployed in a VPC, the service certificate is only created for the public-* hostname and the custom domain. Example: `grafana.example.org`.
        """
        return pulumi.get(self, "custom_domain")

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

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="influxdbVersion")
    def influxdb_version(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `1.8`, and newer. InfluxDB major version. Default: `1.8`.
        """
        return pulumi.get(self, "influxdb_version")

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

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

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

    @_builtins.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)

    @_builtins.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)

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

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

    @_builtins.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)

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

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

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

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

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

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

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

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


if not MYPY:
    class InfluxDbInfluxdbUserConfigInfluxdbArgsDict(TypedDict):
        log_queries_after: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum duration in seconds before a query is logged as a slow query. Setting this to 0 (the default) will never log slow queries.
        """
        max_connection_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum number of connections to InfluxDB. Setting this to 0 (default) means no limit. If using max_connection_limit, it is recommended to set the value to be large enough in order to not block clients unnecessarily.
        """
        max_row_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of rows returned in a non-chunked query. Setting this to 0 (the default) allows an unlimited number to be returned.
        """
        max_select_buckets: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of `GROUP BY time()` buckets that can be processed in a query. Setting this to 0 (the default) allows an unlimited number to be processed.
        """
        max_select_point: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of points that can be processed in a SELECT statement. Setting this to 0 (the default) allows an unlimited number to be processed.
        """
        query_log_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether queries should be logged before execution. May log sensitive data contained within a query.
        """
        query_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum duration in seconds before a query is killed. Setting this to 0 (the default) will never kill slow queries.
        """
elif False:
    InfluxDbInfluxdbUserConfigInfluxdbArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InfluxDbInfluxdbUserConfigInfluxdbArgs:
    def __init__(__self__, *,
                 log_queries_after: Optional[pulumi.Input[_builtins.int]] = None,
                 max_connection_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 max_row_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 max_select_buckets: Optional[pulumi.Input[_builtins.int]] = None,
                 max_select_point: Optional[pulumi.Input[_builtins.int]] = None,
                 query_log_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 query_timeout: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.int] log_queries_after: The maximum duration in seconds before a query is logged as a slow query. Setting this to 0 (the default) will never log slow queries.
        :param pulumi.Input[_builtins.int] max_connection_limit: Maximum number of connections to InfluxDB. Setting this to 0 (default) means no limit. If using max_connection_limit, it is recommended to set the value to be large enough in order to not block clients unnecessarily.
        :param pulumi.Input[_builtins.int] max_row_limit: The maximum number of rows returned in a non-chunked query. Setting this to 0 (the default) allows an unlimited number to be returned.
        :param pulumi.Input[_builtins.int] max_select_buckets: The maximum number of `GROUP BY time()` buckets that can be processed in a query. Setting this to 0 (the default) allows an unlimited number to be processed.
        :param pulumi.Input[_builtins.int] max_select_point: The maximum number of points that can be processed in a SELECT statement. Setting this to 0 (the default) allows an unlimited number to be processed.
        :param pulumi.Input[_builtins.bool] query_log_enabled: Whether queries should be logged before execution. May log sensitive data contained within a query.
        :param pulumi.Input[_builtins.int] query_timeout: The maximum duration in seconds before a query is killed. Setting this to 0 (the default) will never kill slow queries.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="logQueriesAfter")
    def log_queries_after(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum duration in seconds before a query is logged as a slow query. Setting this to 0 (the default) will never log slow queries.
        """
        return pulumi.get(self, "log_queries_after")

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

    @_builtins.property
    @pulumi.getter(name="maxConnectionLimit")
    def max_connection_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum number of connections to InfluxDB. Setting this to 0 (default) means no limit. If using max_connection_limit, it is recommended to set the value to be large enough in order to not block clients unnecessarily.
        """
        return pulumi.get(self, "max_connection_limit")

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

    @_builtins.property
    @pulumi.getter(name="maxRowLimit")
    def max_row_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of rows returned in a non-chunked query. Setting this to 0 (the default) allows an unlimited number to be returned.
        """
        return pulumi.get(self, "max_row_limit")

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

    @_builtins.property
    @pulumi.getter(name="maxSelectBuckets")
    def max_select_buckets(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of `GROUP BY time()` buckets that can be processed in a query. Setting this to 0 (the default) allows an unlimited number to be processed.
        """
        return pulumi.get(self, "max_select_buckets")

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

    @_builtins.property
    @pulumi.getter(name="maxSelectPoint")
    def max_select_point(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of points that can be processed in a SELECT statement. Setting this to 0 (the default) allows an unlimited number to be processed.
        """
        return pulumi.get(self, "max_select_point")

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

    @_builtins.property
    @pulumi.getter(name="queryLogEnabled")
    def query_log_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether queries should be logged before execution. May log sensitive data contained within a query.
        """
        return pulumi.get(self, "query_log_enabled")

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

    @_builtins.property
    @pulumi.getter(name="queryTimeout")
    def query_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum duration in seconds before a query is killed. Setting this to 0 (the default) will never kill slow queries.
        """
        return pulumi.get(self, "query_timeout")

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


if not MYPY:
    class InfluxDbInfluxdbUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    InfluxDbInfluxdbUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InfluxDbInfluxdbUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

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

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

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


if not MYPY:
    class InfluxDbInfluxdbUserConfigPrivateAccessArgsDict(TypedDict):
        influxdb: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to influxdb with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        user_backup: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to user_backup with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
elif False:
    InfluxDbInfluxdbUserConfigPrivateAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InfluxDbInfluxdbUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 influxdb: Optional[pulumi.Input[_builtins.bool]] = None,
                 user_backup: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] influxdb: Allow clients to connect to influxdb with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] user_backup: Allow clients to connect to user_backup with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        if influxdb is not None:
            pulumi.set(__self__, "influxdb", influxdb)
        if user_backup is not None:
            pulumi.set(__self__, "user_backup", user_backup)

    @_builtins.property
    @pulumi.getter
    def influxdb(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to influxdb with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "influxdb")

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

    @_builtins.property
    @pulumi.getter(name="userBackup")
    def user_backup(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to user_backup with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "user_backup")

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


if not MYPY:
    class InfluxDbInfluxdbUserConfigPrivatelinkAccessArgsDict(TypedDict):
        influxdb: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable influxdb.
        """
        user_backup: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable user_backup.
        """
elif False:
    InfluxDbInfluxdbUserConfigPrivatelinkAccessArgsDict: TypeAlias = Mapping[str, Any]

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

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

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

    @_builtins.property
    @pulumi.getter(name="userBackup")
    def user_backup(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable user_backup.
        """
        return pulumi.get(self, "user_backup")

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


if not MYPY:
    class InfluxDbInfluxdbUserConfigPublicAccessArgsDict(TypedDict):
        influxdb: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to influxdb from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        user_backup: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to user_backup from the public internet for service nodes that are in a project VPC or another type of private network.
        """
elif False:
    InfluxDbInfluxdbUserConfigPublicAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InfluxDbInfluxdbUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 influxdb: Optional[pulumi.Input[_builtins.bool]] = None,
                 user_backup: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] influxdb: Allow clients to connect to influxdb from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] user_backup: Allow clients to connect to user_backup from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        if influxdb is not None:
            pulumi.set(__self__, "influxdb", influxdb)
        if user_backup is not None:
            pulumi.set(__self__, "user_backup", user_backup)

    @_builtins.property
    @pulumi.getter
    def influxdb(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to influxdb from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "influxdb")

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

    @_builtins.property
    @pulumi.getter(name="userBackup")
    def user_backup(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to user_backup from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "user_backup")

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


if not MYPY:
    class InfluxDbServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    InfluxDbServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InfluxDbServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration
        :param pulumi.Input[_builtins.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)

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

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

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class InfluxDbTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    InfluxDbTagArgsDict: TypeAlias = Mapping[str, Any]

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

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

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

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

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


if not MYPY:
    class InfluxDbTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    InfluxDbTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class InfluxDbTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

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


if not MYPY:
    class KafkaComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    KafkaComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

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

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

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

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

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

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

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

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

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

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

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

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

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

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

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

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

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

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


if not MYPY:
    class KafkaConnectComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    KafkaConnectComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaConnectComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

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

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

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

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

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

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

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

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

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

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

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

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

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

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

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

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

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

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


if not MYPY:
    class KafkaConnectKafkaConnectUserConfigArgsDict(TypedDict):
        additional_backup_regions: NotRequired[pulumi.Input[_builtins.str]]
        """
        Additional Cloud Regions for Backup Replication.
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['KafkaConnectKafkaConnectUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        kafka_connect: NotRequired[pulumi.Input['KafkaConnectKafkaConnectUserConfigKafkaConnectArgsDict']]
        """
        Kafka Connect configuration values
        """
        plugin_versions: NotRequired[pulumi.Input[Sequence[pulumi.Input['KafkaConnectKafkaConnectUserConfigPluginVersionArgsDict']]]]
        """
        The plugin selected by the user
        """
        private_access: NotRequired[pulumi.Input['KafkaConnectKafkaConnectUserConfigPrivateAccessArgsDict']]
        """
        Allow access to selected service ports from private networks
        """
        privatelink_access: NotRequired[pulumi.Input['KafkaConnectKafkaConnectUserConfigPrivatelinkAccessArgsDict']]
        """
        Allow access to selected service components through Privatelink
        """
        public_access: NotRequired[pulumi.Input['KafkaConnectKafkaConnectUserConfigPublicAccessArgsDict']]
        """
        Allow access to selected service ports from the public Internet
        """
        sasl_oauthbearer_allowed_urls: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        List of allowed URLs for SASL OAUTHBEARER authentication. Only HTTPS URLs are allowed for security reasons.
        """
        secret_providers: NotRequired[pulumi.Input[Sequence[pulumi.Input['KafkaConnectKafkaConnectUserConfigSecretProviderArgsDict']]]]
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
elif False:
    KafkaConnectKafkaConnectUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaConnectKafkaConnectUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[_builtins.str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['KafkaConnectKafkaConnectUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 kafka_connect: Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigKafkaConnectArgs']] = None,
                 plugin_versions: Optional[pulumi.Input[Sequence[pulumi.Input['KafkaConnectKafkaConnectUserConfigPluginVersionArgs']]]] = None,
                 private_access: Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigPrivatelinkAccessArgs']] = None,
                 public_access: Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigPublicAccessArgs']] = None,
                 sasl_oauthbearer_allowed_urls: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 secret_providers: Optional[pulumi.Input[Sequence[pulumi.Input['KafkaConnectKafkaConnectUserConfigSecretProviderArgs']]]] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[Sequence[pulumi.Input['KafkaConnectKafkaConnectUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input['KafkaConnectKafkaConnectUserConfigKafkaConnectArgs'] kafka_connect: Kafka Connect configuration values
        :param pulumi.Input[Sequence[pulumi.Input['KafkaConnectKafkaConnectUserConfigPluginVersionArgs']]] plugin_versions: The plugin selected by the user
        :param pulumi.Input['KafkaConnectKafkaConnectUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks
        :param pulumi.Input['KafkaConnectKafkaConnectUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink
        :param pulumi.Input['KafkaConnectKafkaConnectUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] sasl_oauthbearer_allowed_urls: List of allowed URLs for SASL OAUTHBEARER authentication. Only HTTPS URLs are allowed for security reasons.
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input[_builtins.bool] static_ips: Use static public IP addresses.
        """
        if additional_backup_regions is not None:
            warnings.warn("""This property is deprecated.""", DeprecationWarning)
            pulumi.log.warn("""additional_backup_regions is deprecated: This property is deprecated.""")
        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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `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 plugin_versions is not None:
            pulumi.set(__self__, "plugin_versions", plugin_versions)
        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 sasl_oauthbearer_allowed_urls is not None:
            pulumi.set(__self__, "sasl_oauthbearer_allowed_urls", sasl_oauthbearer_allowed_urls)
        if secret_providers is not None:
            pulumi.set(__self__, "secret_providers", secret_providers)
        if service_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)

    @_builtins.property
    @pulumi.getter(name="additionalBackupRegions")
    @_utilities.deprecated("""This property is deprecated.""")
    def additional_backup_regions(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KafkaConnectKafkaConnectUserConfigIpFilterObjectArgs']]]]:
        """
        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['KafkaConnectKafkaConnectUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

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

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

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

    @_builtins.property
    @pulumi.getter(name="pluginVersions")
    def plugin_versions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KafkaConnectKafkaConnectUserConfigPluginVersionArgs']]]]:
        """
        The plugin selected by the user
        """
        return pulumi.get(self, "plugin_versions")

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

    @_builtins.property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigPrivateAccessArgs']]:
        """
        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['KafkaConnectKafkaConnectUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @_builtins.property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigPrivatelinkAccessArgs']]:
        """
        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['KafkaConnectKafkaConnectUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)

    @_builtins.property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigPublicAccessArgs']]:
        """
        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['KafkaConnectKafkaConnectUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

    @_builtins.property
    @pulumi.getter(name="saslOauthbearerAllowedUrls")
    def sasl_oauthbearer_allowed_urls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        List of allowed URLs for SASL OAUTHBEARER authentication. Only HTTPS URLs are allowed for security reasons.
        """
        return pulumi.get(self, "sasl_oauthbearer_allowed_urls")

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

    @_builtins.property
    @pulumi.getter(name="secretProviders")
    def secret_providers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KafkaConnectKafkaConnectUserConfigSecretProviderArgs']]]]:
        return pulumi.get(self, "secret_providers")

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

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

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

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

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


if not MYPY:
    class KafkaConnectKafkaConnectUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    KafkaConnectKafkaConnectUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaConnectKafkaConnectUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

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

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

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


if not MYPY:
    class KafkaConnectKafkaConnectUserConfigKafkaConnectArgsDict(TypedDict):
        connector_client_config_override_policy: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `All`, `None`. Defines what client configurations can be overridden by the connector. Default is None.
        """
        consumer_auto_offset_reset: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `earliest`, `latest`. What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
        """
        consumer_fetch_max_bytes: NotRequired[pulumi.Input[_builtins.int]]
        """
        Records are fetched in batches by the consumer, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that the consumer can make progress. As such, this is not a absolute maximum.
        """
        consumer_isolation_level: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `read_committed`, `read_uncommitted`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
        """
        consumer_max_partition_fetch_bytes: NotRequired[pulumi.Input[_builtins.int]]
        """
        Records are fetched in batches by the consumer.If the first record batch in the first non-empty partition of the fetch is larger than this limit, the batch will still be returned to ensure that the consumer can make progress.
        """
        consumer_max_poll_interval_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum delay in milliseconds between invocations of poll() when using consumer group management (defaults to 300000).
        """
        consumer_max_poll_records: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of records returned in a single call to poll() (defaults to 500).
        """
        offset_flush_interval_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The interval at which to try committing offsets for tasks (defaults to 60000).
        """
        offset_flush_timeout_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt (defaults to 5000).
        """
        producer_batch_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        This setting gives the upper bound of the batch size to be sent. If there are fewer than this many bytes accumulated for this partition, the producer will `linger` for the linger.ms time waiting for more records to show up. A batch size of zero will disable batching entirely (defaults to 16384).
        """
        producer_buffer_memory: NotRequired[pulumi.Input[_builtins.int]]
        """
        The total bytes of memory the producer can use to buffer records waiting to be sent to the broker (defaults to 33554432).
        """
        producer_compression_type: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
        """
        producer_linger_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        This setting gives the upper bound on the delay for batching: once there is batch.size worth of records for a partition it will be sent immediately regardless of this setting, however if there are fewer than this many bytes accumulated for this partition the producer will `linger` for the specified time waiting for more records to show up. Defaults to 0.
        """
        producer_max_request_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests.
        """
        scheduled_rebalance_max_delay_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum delay that is scheduled in order to wait for the return of one or more departed workers before rebalancing and reassigning their connectors and tasks to the group. During this period the connectors and tasks of the departed workers remain unassigned. Defaults to 5 minutes.
        """
        session_timeout_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The timeout in milliseconds used to detect failures when using Kafka’s group management facilities (defaults to 10000).
        """
elif False:
    KafkaConnectKafkaConnectUserConfigKafkaConnectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaConnectKafkaConnectUserConfigKafkaConnectArgs:
    def __init__(__self__, *,
                 connector_client_config_override_policy: Optional[pulumi.Input[_builtins.str]] = None,
                 consumer_auto_offset_reset: Optional[pulumi.Input[_builtins.str]] = None,
                 consumer_fetch_max_bytes: Optional[pulumi.Input[_builtins.int]] = None,
                 consumer_isolation_level: Optional[pulumi.Input[_builtins.str]] = None,
                 consumer_max_partition_fetch_bytes: Optional[pulumi.Input[_builtins.int]] = None,
                 consumer_max_poll_interval_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 consumer_max_poll_records: Optional[pulumi.Input[_builtins.int]] = None,
                 offset_flush_interval_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 offset_flush_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_batch_size: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_buffer_memory: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_compression_type: Optional[pulumi.Input[_builtins.str]] = None,
                 producer_linger_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_max_request_size: Optional[pulumi.Input[_builtins.int]] = None,
                 scheduled_rebalance_max_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.str] connector_client_config_override_policy: Enum: `All`, `None`. Defines what client configurations can be overridden by the connector. Default is None.
        :param pulumi.Input[_builtins.str] consumer_auto_offset_reset: Enum: `earliest`, `latest`. What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
        :param pulumi.Input[_builtins.int] consumer_fetch_max_bytes: Records are fetched in batches by the consumer, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that the consumer can make progress. As such, this is not a absolute maximum.
        :param pulumi.Input[_builtins.str] consumer_isolation_level: Enum: `read_committed`, `read_uncommitted`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
        :param pulumi.Input[_builtins.int] consumer_max_partition_fetch_bytes: Records are fetched in batches by the consumer.If the first record batch in the first non-empty partition of the fetch is larger than this limit, the batch will still be returned to ensure that the consumer can make progress.
        :param pulumi.Input[_builtins.int] consumer_max_poll_interval_ms: The maximum delay in milliseconds between invocations of poll() when using consumer group management (defaults to 300000).
        :param pulumi.Input[_builtins.int] consumer_max_poll_records: The maximum number of records returned in a single call to poll() (defaults to 500).
        :param pulumi.Input[_builtins.int] offset_flush_interval_ms: The interval at which to try committing offsets for tasks (defaults to 60000).
        :param pulumi.Input[_builtins.int] offset_flush_timeout_ms: Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt (defaults to 5000).
        :param pulumi.Input[_builtins.int] producer_batch_size: This setting gives the upper bound of the batch size to be sent. If there are fewer than this many bytes accumulated for this partition, the producer will `linger` for the linger.ms time waiting for more records to show up. A batch size of zero will disable batching entirely (defaults to 16384).
        :param pulumi.Input[_builtins.int] producer_buffer_memory: The total bytes of memory the producer can use to buffer records waiting to be sent to the broker (defaults to 33554432).
        :param pulumi.Input[_builtins.str] producer_compression_type: Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
        :param pulumi.Input[_builtins.int] producer_linger_ms: This setting gives the upper bound on the delay for batching: once there is batch.size worth of records for a partition it will be sent immediately regardless of this setting, however if there are fewer than this many bytes accumulated for this partition the producer will `linger` for the specified time waiting for more records to show up. Defaults to 0.
        :param pulumi.Input[_builtins.int] producer_max_request_size: This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests.
        :param pulumi.Input[_builtins.int] scheduled_rebalance_max_delay_ms: The maximum delay that is scheduled in order to wait for the return of one or more departed workers before rebalancing and reassigning their connectors and tasks to the group. During this period the connectors and tasks of the departed workers remain unassigned. Defaults to 5 minutes.
        :param pulumi.Input[_builtins.int] session_timeout_ms: The timeout in milliseconds used to detect failures when using Kafka’s group management facilities (defaults to 10000).
        """
        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)

    @_builtins.property
    @pulumi.getter(name="connectorClientConfigOverridePolicy")
    def connector_client_config_override_policy(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `All`, `None`. Defines what client configurations can be overridden by the connector. Default is None.
        """
        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[_builtins.str]]):
        pulumi.set(self, "connector_client_config_override_policy", value)

    @_builtins.property
    @pulumi.getter(name="consumerAutoOffsetReset")
    def consumer_auto_offset_reset(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `earliest`, `latest`. What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
        """
        return pulumi.get(self, "consumer_auto_offset_reset")

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

    @_builtins.property
    @pulumi.getter(name="consumerFetchMaxBytes")
    def consumer_fetch_max_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Records are fetched in batches by the consumer, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that the consumer can make progress. As such, this is not a absolute maximum.
        """
        return pulumi.get(self, "consumer_fetch_max_bytes")

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

    @_builtins.property
    @pulumi.getter(name="consumerIsolationLevel")
    def consumer_isolation_level(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `read_committed`, `read_uncommitted`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
        """
        return pulumi.get(self, "consumer_isolation_level")

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

    @_builtins.property
    @pulumi.getter(name="consumerMaxPartitionFetchBytes")
    def consumer_max_partition_fetch_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Records are fetched in batches by the consumer.If the first record batch in the first non-empty partition of the fetch is larger than this limit, the batch will still be returned to ensure that the consumer can make progress.
        """
        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[_builtins.int]]):
        pulumi.set(self, "consumer_max_partition_fetch_bytes", value)

    @_builtins.property
    @pulumi.getter(name="consumerMaxPollIntervalMs")
    def consumer_max_poll_interval_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum delay in milliseconds between invocations of poll() when using consumer group management (defaults to 300000).
        """
        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[_builtins.int]]):
        pulumi.set(self, "consumer_max_poll_interval_ms", value)

    @_builtins.property
    @pulumi.getter(name="consumerMaxPollRecords")
    def consumer_max_poll_records(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of records returned in a single call to poll() (defaults to 500).
        """
        return pulumi.get(self, "consumer_max_poll_records")

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

    @_builtins.property
    @pulumi.getter(name="offsetFlushIntervalMs")
    def offset_flush_interval_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The interval at which to try committing offsets for tasks (defaults to 60000).
        """
        return pulumi.get(self, "offset_flush_interval_ms")

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

    @_builtins.property
    @pulumi.getter(name="offsetFlushTimeoutMs")
    def offset_flush_timeout_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt (defaults to 5000).
        """
        return pulumi.get(self, "offset_flush_timeout_ms")

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

    @_builtins.property
    @pulumi.getter(name="producerBatchSize")
    def producer_batch_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        This setting gives the upper bound of the batch size to be sent. If there are fewer than this many bytes accumulated for this partition, the producer will `linger` for the linger.ms time waiting for more records to show up. A batch size of zero will disable batching entirely (defaults to 16384).
        """
        return pulumi.get(self, "producer_batch_size")

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

    @_builtins.property
    @pulumi.getter(name="producerBufferMemory")
    def producer_buffer_memory(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The total bytes of memory the producer can use to buffer records waiting to be sent to the broker (defaults to 33554432).
        """
        return pulumi.get(self, "producer_buffer_memory")

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

    @_builtins.property
    @pulumi.getter(name="producerCompressionType")
    def producer_compression_type(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
        """
        return pulumi.get(self, "producer_compression_type")

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

    @_builtins.property
    @pulumi.getter(name="producerLingerMs")
    def producer_linger_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        This setting gives the upper bound on the delay for batching: once there is batch.size worth of records for a partition it will be sent immediately regardless of this setting, however if there are fewer than this many bytes accumulated for this partition the producer will `linger` for the specified time waiting for more records to show up. Defaults to 0.
        """
        return pulumi.get(self, "producer_linger_ms")

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

    @_builtins.property
    @pulumi.getter(name="producerMaxRequestSize")
    def producer_max_request_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests.
        """
        return pulumi.get(self, "producer_max_request_size")

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

    @_builtins.property
    @pulumi.getter(name="scheduledRebalanceMaxDelayMs")
    def scheduled_rebalance_max_delay_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum delay that is scheduled in order to wait for the return of one or more departed workers before rebalancing and reassigning their connectors and tasks to the group. During this period the connectors and tasks of the departed workers remain unassigned. Defaults to 5 minutes.
        """
        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[_builtins.int]]):
        pulumi.set(self, "scheduled_rebalance_max_delay_ms", value)

    @_builtins.property
    @pulumi.getter(name="sessionTimeoutMs")
    def session_timeout_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The timeout in milliseconds used to detect failures when using Kafka’s group management facilities (defaults to 10000).
        """
        return pulumi.get(self, "session_timeout_ms")

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


if not MYPY:
    class KafkaConnectKafkaConnectUserConfigPluginVersionArgsDict(TypedDict):
        plugin_name: pulumi.Input[_builtins.str]
        """
        The name of the plugin. Example: `debezium-connector`.
        """
        version: pulumi.Input[_builtins.str]
        """
        The version of the plugin. Example: `2.5.0`.
        """
elif False:
    KafkaConnectKafkaConnectUserConfigPluginVersionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaConnectKafkaConnectUserConfigPluginVersionArgs:
    def __init__(__self__, *,
                 plugin_name: pulumi.Input[_builtins.str],
                 version: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] plugin_name: The name of the plugin. Example: `debezium-connector`.
        :param pulumi.Input[_builtins.str] version: The version of the plugin. Example: `2.5.0`.
        """
        pulumi.set(__self__, "plugin_name", plugin_name)
        pulumi.set(__self__, "version", version)

    @_builtins.property
    @pulumi.getter(name="pluginName")
    def plugin_name(self) -> pulumi.Input[_builtins.str]:
        """
        The name of the plugin. Example: `debezium-connector`.
        """
        return pulumi.get(self, "plugin_name")

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

    @_builtins.property
    @pulumi.getter
    def version(self) -> pulumi.Input[_builtins.str]:
        """
        The version of the plugin. Example: `2.5.0`.
        """
        return pulumi.get(self, "version")

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


if not MYPY:
    class KafkaConnectKafkaConnectUserConfigPrivateAccessArgsDict(TypedDict):
        kafka_connect: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to kafka_connect with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
elif False:
    KafkaConnectKafkaConnectUserConfigPrivateAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaConnectKafkaConnectUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 kafka_connect: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] kafka_connect: Allow clients to connect to kafka_connect with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        if kafka_connect is not None:
            pulumi.set(__self__, "kafka_connect", kafka_connect)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @_builtins.property
    @pulumi.getter(name="kafkaConnect")
    def kafka_connect(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to kafka_connect with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "kafka_connect")

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

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "prometheus")

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


if not MYPY:
    class KafkaConnectKafkaConnectUserConfigPrivatelinkAccessArgsDict(TypedDict):
        jolokia: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable jolokia.
        """
        kafka_connect: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable kafka_connect.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable prometheus.
        """
elif False:
    KafkaConnectKafkaConnectUserConfigPrivatelinkAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaConnectKafkaConnectUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 jolokia: Optional[pulumi.Input[_builtins.bool]] = None,
                 kafka_connect: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] jolokia: Enable jolokia.
        :param pulumi.Input[_builtins.bool] kafka_connect: Enable kafka_connect.
        :param pulumi.Input[_builtins.bool] prometheus: Enable prometheus.
        """
        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)

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

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

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

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

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

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


if not MYPY:
    class KafkaConnectKafkaConnectUserConfigPublicAccessArgsDict(TypedDict):
        kafka_connect: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to kafka_connect from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
elif False:
    KafkaConnectKafkaConnectUserConfigPublicAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaConnectKafkaConnectUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 kafka_connect: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] kafka_connect: Allow clients to connect to kafka_connect from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        if kafka_connect is not None:
            pulumi.set(__self__, "kafka_connect", kafka_connect)
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)

    @_builtins.property
    @pulumi.getter(name="kafkaConnect")
    def kafka_connect(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to kafka_connect from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "kafka_connect")

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

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "prometheus")

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


if not MYPY:
    class KafkaConnectKafkaConnectUserConfigSecretProviderArgsDict(TypedDict):
        name: pulumi.Input[_builtins.str]
        """
        Name of the secret provider. Used to reference secrets in connector config.
        """
        aws: NotRequired[pulumi.Input['KafkaConnectKafkaConnectUserConfigSecretProviderAwsArgsDict']]
        """
        AWS secret provider configuration
        """
        vault: NotRequired[pulumi.Input['KafkaConnectKafkaConnectUserConfigSecretProviderVaultArgsDict']]
        """
        Vault secret provider configuration
        """
elif False:
    KafkaConnectKafkaConnectUserConfigSecretProviderArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaConnectKafkaConnectUserConfigSecretProviderArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[_builtins.str],
                 aws: Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigSecretProviderAwsArgs']] = None,
                 vault: Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigSecretProviderVaultArgs']] = None):
        """
        :param pulumi.Input[_builtins.str] name: Name of the secret provider. Used to reference secrets in connector config.
        :param pulumi.Input['KafkaConnectKafkaConnectUserConfigSecretProviderAwsArgs'] aws: AWS secret provider configuration
        :param pulumi.Input['KafkaConnectKafkaConnectUserConfigSecretProviderVaultArgs'] vault: Vault secret provider configuration
        """
        pulumi.set(__self__, "name", name)
        if aws is not None:
            pulumi.set(__self__, "aws", aws)
        if vault is not None:
            pulumi.set(__self__, "vault", vault)

    @_builtins.property
    @pulumi.getter
    def name(self) -> pulumi.Input[_builtins.str]:
        """
        Name of the secret provider. Used to reference secrets in connector config.
        """
        return pulumi.get(self, "name")

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

    @_builtins.property
    @pulumi.getter
    def aws(self) -> Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigSecretProviderAwsArgs']]:
        """
        AWS secret provider configuration
        """
        return pulumi.get(self, "aws")

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

    @_builtins.property
    @pulumi.getter
    def vault(self) -> Optional[pulumi.Input['KafkaConnectKafkaConnectUserConfigSecretProviderVaultArgs']]:
        """
        Vault secret provider configuration
        """
        return pulumi.get(self, "vault")

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


if not MYPY:
    class KafkaConnectKafkaConnectUserConfigSecretProviderAwsArgsDict(TypedDict):
        auth_method: pulumi.Input[_builtins.str]
        """
        Enum: `credentials`. Auth method of the vault secret provider.
        """
        region: pulumi.Input[_builtins.str]
        """
        Region used to lookup secrets with AWS SecretManager.
        """
        access_key: NotRequired[pulumi.Input[_builtins.str]]
        """
        Access key used to authenticate with aws.
        """
        secret_key: NotRequired[pulumi.Input[_builtins.str]]
        """
        Secret key used to authenticate with aws.
        """
elif False:
    KafkaConnectKafkaConnectUserConfigSecretProviderAwsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaConnectKafkaConnectUserConfigSecretProviderAwsArgs:
    def __init__(__self__, *,
                 auth_method: pulumi.Input[_builtins.str],
                 region: pulumi.Input[_builtins.str],
                 access_key: Optional[pulumi.Input[_builtins.str]] = None,
                 secret_key: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] auth_method: Enum: `credentials`. Auth method of the vault secret provider.
        :param pulumi.Input[_builtins.str] region: Region used to lookup secrets with AWS SecretManager.
        :param pulumi.Input[_builtins.str] access_key: Access key used to authenticate with aws.
        :param pulumi.Input[_builtins.str] secret_key: Secret key used to authenticate with aws.
        """
        pulumi.set(__self__, "auth_method", auth_method)
        pulumi.set(__self__, "region", region)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)

    @_builtins.property
    @pulumi.getter(name="authMethod")
    def auth_method(self) -> pulumi.Input[_builtins.str]:
        """
        Enum: `credentials`. Auth method of the vault secret provider.
        """
        return pulumi.get(self, "auth_method")

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

    @_builtins.property
    @pulumi.getter
    def region(self) -> pulumi.Input[_builtins.str]:
        """
        Region used to lookup secrets with AWS SecretManager.
        """
        return pulumi.get(self, "region")

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

    @_builtins.property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Access key used to authenticate with aws.
        """
        return pulumi.get(self, "access_key")

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

    @_builtins.property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Secret key used to authenticate with aws.
        """
        return pulumi.get(self, "secret_key")

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


if not MYPY:
    class KafkaConnectKafkaConnectUserConfigSecretProviderVaultArgsDict(TypedDict):
        address: pulumi.Input[_builtins.str]
        """
        Address of the Vault server.
        """
        auth_method: pulumi.Input[_builtins.str]
        """
        Enum: `token`. Auth method of the vault secret provider.
        """
        engine_version: NotRequired[pulumi.Input[_builtins.int]]
        """
        Enum: `1`, `2`, and newer. KV Secrets Engine version of the Vault server instance.
        """
        prefix_path_depth: NotRequired[pulumi.Input[_builtins.int]]
        """
        Prefix path depth of the secrets Engine. Default is 1. If the secrets engine path has more than one segment it has to be increased to the number of segments.
        """
        token: NotRequired[pulumi.Input[_builtins.str]]
        """
        Token used to authenticate with vault and auth method `token`.
        """
elif False:
    KafkaConnectKafkaConnectUserConfigSecretProviderVaultArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaConnectKafkaConnectUserConfigSecretProviderVaultArgs:
    def __init__(__self__, *,
                 address: pulumi.Input[_builtins.str],
                 auth_method: pulumi.Input[_builtins.str],
                 engine_version: Optional[pulumi.Input[_builtins.int]] = None,
                 prefix_path_depth: Optional[pulumi.Input[_builtins.int]] = None,
                 token: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] address: Address of the Vault server.
        :param pulumi.Input[_builtins.str] auth_method: Enum: `token`. Auth method of the vault secret provider.
        :param pulumi.Input[_builtins.int] engine_version: Enum: `1`, `2`, and newer. KV Secrets Engine version of the Vault server instance.
        :param pulumi.Input[_builtins.int] prefix_path_depth: Prefix path depth of the secrets Engine. Default is 1. If the secrets engine path has more than one segment it has to be increased to the number of segments.
        :param pulumi.Input[_builtins.str] token: Token used to authenticate with vault and auth method `token`.
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "auth_method", auth_method)
        if engine_version is not None:
            pulumi.set(__self__, "engine_version", engine_version)
        if prefix_path_depth is not None:
            pulumi.set(__self__, "prefix_path_depth", prefix_path_depth)
        if token is not None:
            pulumi.set(__self__, "token", token)

    @_builtins.property
    @pulumi.getter
    def address(self) -> pulumi.Input[_builtins.str]:
        """
        Address of the Vault server.
        """
        return pulumi.get(self, "address")

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

    @_builtins.property
    @pulumi.getter(name="authMethod")
    def auth_method(self) -> pulumi.Input[_builtins.str]:
        """
        Enum: `token`. Auth method of the vault secret provider.
        """
        return pulumi.get(self, "auth_method")

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

    @_builtins.property
    @pulumi.getter(name="engineVersion")
    def engine_version(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Enum: `1`, `2`, and newer. KV Secrets Engine version of the Vault server instance.
        """
        return pulumi.get(self, "engine_version")

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

    @_builtins.property
    @pulumi.getter(name="prefixPathDepth")
    def prefix_path_depth(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Prefix path depth of the secrets Engine. Default is 1. If the secrets engine path has more than one segment it has to be increased to the number of segments.
        """
        return pulumi.get(self, "prefix_path_depth")

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

    @_builtins.property
    @pulumi.getter
    def token(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Token used to authenticate with vault and auth method `token`.
        """
        return pulumi.get(self, "token")

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


if not MYPY:
    class KafkaConnectServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    KafkaConnectServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaConnectServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration
        :param pulumi.Input[_builtins.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)

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

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

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class KafkaConnectTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    KafkaConnectTagArgsDict: TypeAlias = Mapping[str, Any]

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

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

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

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

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


if not MYPY:
    class KafkaConnectTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    KafkaConnectTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaConnectTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

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


if not MYPY:
    class KafkaConnectorTaskArgsDict(TypedDict):
        connector: NotRequired[pulumi.Input[_builtins.str]]
        """
        The name of the related connector.
        """
        task: NotRequired[pulumi.Input[_builtins.int]]
        """
        The task ID of the task.
        """
elif False:
    KafkaConnectorTaskArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaConnectorTaskArgs:
    def __init__(__self__, *,
                 connector: Optional[pulumi.Input[_builtins.str]] = None,
                 task: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.str] connector: The name of the related connector.
        :param pulumi.Input[_builtins.int] task: The task ID of the task.
        """
        if connector is not None:
            pulumi.set(__self__, "connector", connector)
        if task is not None:
            pulumi.set(__self__, "task", task)

    @_builtins.property
    @pulumi.getter
    def connector(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The name of the related connector.
        """
        return pulumi.get(self, "connector")

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

    @_builtins.property
    @pulumi.getter
    def task(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The task ID of the task.
        """
        return pulumi.get(self, "task")

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


if not MYPY:
    class KafkaKafkaArgsDict(TypedDict):
        access_cert: NotRequired[pulumi.Input[_builtins.str]]
        """
        The Kafka client certificate.
        """
        access_key: NotRequired[pulumi.Input[_builtins.str]]
        """
        The Kafka client certificate key.
        """
        connect_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        The Kafka Connect URI.
        """
        rest_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        The Kafka REST URI.
        """
        schema_registry_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        The Schema Registry URI.
        """
        uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Kafka server URIs.
        """
elif False:
    KafkaKafkaArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaArgs:
    def __init__(__self__, *,
                 access_cert: Optional[pulumi.Input[_builtins.str]] = None,
                 access_key: Optional[pulumi.Input[_builtins.str]] = None,
                 connect_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 rest_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 schema_registry_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[_builtins.str] access_cert: The Kafka client certificate.
        :param pulumi.Input[_builtins.str] access_key: The Kafka client certificate key.
        :param pulumi.Input[_builtins.str] connect_uri: The Kafka Connect URI.
        :param pulumi.Input[_builtins.str] rest_uri: The Kafka REST URI.
        :param pulumi.Input[_builtins.str] schema_registry_uri: The Schema Registry URI.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uris: Kafka server URIs.
        """
        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)
        if uris is not None:
            pulumi.set(__self__, "uris", uris)

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

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

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

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

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

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

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

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

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

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

    @_builtins.property
    @pulumi.getter
    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Kafka server URIs.
        """
        return pulumi.get(self, "uris")

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


if not MYPY:
    class KafkaKafkaUserConfigArgsDict(TypedDict):
        additional_backup_regions: NotRequired[pulumi.Input[_builtins.str]]
        """
        Additional Cloud Regions for Backup Replication.
        """
        aiven_kafka_topic_messages: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow access to read Kafka topic messages in the Aiven Console and REST API.
        """
        backup_interval_hours: NotRequired[pulumi.Input[_builtins.int]]
        """
        Interval in hours between automatic backups. Minimum value is 3 hours. Must be a divisor of 24 (3, 4, 6, 8, 12, 24). (Applicable to ACU plans only). Example: `24`.
        """
        backup_retention_days: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of days to retain automatic backups. Backups older than this value will be automatically deleted. (Applicable to ACU plans only). Example: `7`.
        """
        custom_domain: NotRequired[pulumi.Input[_builtins.str]]
        """
        Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. When you set a custom domain for a service deployed in a VPC, the service certificate is only created for the public-* hostname and the custom domain. Example: `grafana.example.org`.
        """
        follower_fetching: NotRequired[pulumi.Input['KafkaKafkaUserConfigFollowerFetchingArgsDict']]
        """
        Enable follower fetching
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['KafkaKafkaUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        kafka: NotRequired[pulumi.Input['KafkaKafkaUserConfigKafkaArgsDict']]
        """
        Kafka broker configuration values
        """
        kafka_authentication_methods: NotRequired[pulumi.Input['KafkaKafkaUserConfigKafkaAuthenticationMethodsArgsDict']]
        """
        Kafka authentication methods
        """
        kafka_connect: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable Kafka Connect service. Default: `false`.
        """
        kafka_connect_config: NotRequired[pulumi.Input['KafkaKafkaUserConfigKafkaConnectConfigArgsDict']]
        """
        Kafka Connect configuration values
        """
        kafka_connect_plugin_versions: NotRequired[pulumi.Input[Sequence[pulumi.Input['KafkaKafkaUserConfigKafkaConnectPluginVersionArgsDict']]]]
        """
        The plugin selected by the user
        """
        kafka_connect_secret_providers: NotRequired[pulumi.Input[Sequence[pulumi.Input['KafkaKafkaUserConfigKafkaConnectSecretProviderArgsDict']]]]
        kafka_diskless: NotRequired[pulumi.Input['KafkaKafkaUserConfigKafkaDisklessArgsDict']]
        """
        Kafka Diskless configuration values
        """
        kafka_rest: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable Kafka-REST service. Default: `false`.
        """
        kafka_rest_authorization: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable authorization in Kafka-REST service.
        """
        kafka_rest_config: NotRequired[pulumi.Input['KafkaKafkaUserConfigKafkaRestConfigArgsDict']]
        """
        Kafka REST configuration
        """
        kafka_sasl_mechanisms: NotRequired[pulumi.Input['KafkaKafkaUserConfigKafkaSaslMechanismsArgsDict']]
        """
        Kafka SASL mechanisms
        """
        kafka_version: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `3.1`, `3.2`, `3.3`, `3.4`, `3.5`, `3.6`, `3.7`, `3.8`, `3.9`, `4.0`, `4.1`, and newer. Kafka major version.
        """
        letsencrypt_sasl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use a Let's Encrypt certificate authority (CA) for Kafka SASL authentication. (Default: False).
        """
        letsencrypt_sasl_privatelink: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use a Let's Encrypt certificate authority (CA) for Kafka SASL authentication via Privatelink. (Default: False).
        """
        private_access: NotRequired[pulumi.Input['KafkaKafkaUserConfigPrivateAccessArgsDict']]
        """
        Allow access to selected service ports from private networks
        """
        privatelink_access: NotRequired[pulumi.Input['KafkaKafkaUserConfigPrivatelinkAccessArgsDict']]
        """
        Allow access to selected service components through Privatelink
        """
        public_access: NotRequired[pulumi.Input['KafkaKafkaUserConfigPublicAccessArgsDict']]
        """
        Allow access to selected service ports from the public Internet
        """
        sasl_oauthbearer_allowed_urls: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        List of allowed URLs for SASL OAUTHBEARER authentication. Only HTTPS URLs are allowed for security reasons.
        """
        schema_registry: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable Schema-Registry service. Default: `false`.
        """
        schema_registry_config: NotRequired[pulumi.Input['KafkaKafkaUserConfigSchemaRegistryConfigArgsDict']]
        """
        Schema Registry configuration
        """
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        single_zone: NotRequired[pulumi.Input['KafkaKafkaUserConfigSingleZoneArgsDict']]
        """
        Single-zone configuration
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
        tiered_storage: NotRequired[pulumi.Input['KafkaKafkaUserConfigTieredStorageArgsDict']]
        """
        Tiered storage configuration
        """
elif False:
    KafkaKafkaUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[_builtins.str]] = None,
                 aiven_kafka_topic_messages: Optional[pulumi.Input[_builtins.bool]] = None,
                 backup_interval_hours: Optional[pulumi.Input[_builtins.int]] = None,
                 backup_retention_days: Optional[pulumi.Input[_builtins.int]] = None,
                 custom_domain: Optional[pulumi.Input[_builtins.str]] = None,
                 follower_fetching: Optional[pulumi.Input['KafkaKafkaUserConfigFollowerFetchingArgs']] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['KafkaKafkaUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 kafka: Optional[pulumi.Input['KafkaKafkaUserConfigKafkaArgs']] = None,
                 kafka_authentication_methods: Optional[pulumi.Input['KafkaKafkaUserConfigKafkaAuthenticationMethodsArgs']] = None,
                 kafka_connect: Optional[pulumi.Input[_builtins.bool]] = None,
                 kafka_connect_config: Optional[pulumi.Input['KafkaKafkaUserConfigKafkaConnectConfigArgs']] = None,
                 kafka_connect_plugin_versions: Optional[pulumi.Input[Sequence[pulumi.Input['KafkaKafkaUserConfigKafkaConnectPluginVersionArgs']]]] = None,
                 kafka_connect_secret_providers: Optional[pulumi.Input[Sequence[pulumi.Input['KafkaKafkaUserConfigKafkaConnectSecretProviderArgs']]]] = None,
                 kafka_diskless: Optional[pulumi.Input['KafkaKafkaUserConfigKafkaDisklessArgs']] = None,
                 kafka_rest: Optional[pulumi.Input[_builtins.bool]] = None,
                 kafka_rest_authorization: Optional[pulumi.Input[_builtins.bool]] = None,
                 kafka_rest_config: Optional[pulumi.Input['KafkaKafkaUserConfigKafkaRestConfigArgs']] = None,
                 kafka_sasl_mechanisms: Optional[pulumi.Input['KafkaKafkaUserConfigKafkaSaslMechanismsArgs']] = None,
                 kafka_version: Optional[pulumi.Input[_builtins.str]] = None,
                 letsencrypt_sasl: Optional[pulumi.Input[_builtins.bool]] = None,
                 letsencrypt_sasl_privatelink: Optional[pulumi.Input[_builtins.bool]] = None,
                 private_access: Optional[pulumi.Input['KafkaKafkaUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['KafkaKafkaUserConfigPrivatelinkAccessArgs']] = None,
                 public_access: Optional[pulumi.Input['KafkaKafkaUserConfigPublicAccessArgs']] = None,
                 sasl_oauthbearer_allowed_urls: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 schema_registry: Optional[pulumi.Input[_builtins.bool]] = None,
                 schema_registry_config: Optional[pulumi.Input['KafkaKafkaUserConfigSchemaRegistryConfigArgs']] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 single_zone: Optional[pulumi.Input['KafkaKafkaUserConfigSingleZoneArgs']] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None,
                 tiered_storage: Optional[pulumi.Input['KafkaKafkaUserConfigTieredStorageArgs']] = None):
        """
        :param pulumi.Input[_builtins.str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[_builtins.bool] aiven_kafka_topic_messages: Allow access to read Kafka topic messages in the Aiven Console and REST API.
        :param pulumi.Input[_builtins.int] backup_interval_hours: Interval in hours between automatic backups. Minimum value is 3 hours. Must be a divisor of 24 (3, 4, 6, 8, 12, 24). (Applicable to ACU plans only). Example: `24`.
        :param pulumi.Input[_builtins.int] backup_retention_days: Number of days to retain automatic backups. Backups older than this value will be automatically deleted. (Applicable to ACU plans only). Example: `7`.
        :param pulumi.Input[_builtins.str] custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. When you set a custom domain for a service deployed in a VPC, the service certificate is only created for the public-* hostname and the custom domain. Example: `grafana.example.org`.
        :param pulumi.Input['KafkaKafkaUserConfigFollowerFetchingArgs'] follower_fetching: Enable follower fetching
        :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[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.bool] kafka_connect: Enable Kafka Connect service. Default: `false`.
        :param pulumi.Input['KafkaKafkaUserConfigKafkaConnectConfigArgs'] kafka_connect_config: Kafka Connect configuration values
        :param pulumi.Input[Sequence[pulumi.Input['KafkaKafkaUserConfigKafkaConnectPluginVersionArgs']]] kafka_connect_plugin_versions: The plugin selected by the user
        :param pulumi.Input['KafkaKafkaUserConfigKafkaDisklessArgs'] kafka_diskless: Kafka Diskless configuration values
        :param pulumi.Input[_builtins.bool] kafka_rest: Enable Kafka-REST service. Default: `false`.
        :param pulumi.Input[_builtins.bool] kafka_rest_authorization: Enable authorization in Kafka-REST service.
        :param pulumi.Input['KafkaKafkaUserConfigKafkaRestConfigArgs'] kafka_rest_config: Kafka REST configuration
        :param pulumi.Input['KafkaKafkaUserConfigKafkaSaslMechanismsArgs'] kafka_sasl_mechanisms: Kafka SASL mechanisms
        :param pulumi.Input[_builtins.str] kafka_version: Enum: `3.1`, `3.2`, `3.3`, `3.4`, `3.5`, `3.6`, `3.7`, `3.8`, `3.9`, `4.0`, `4.1`, and newer. Kafka major version.
        :param pulumi.Input[_builtins.bool] letsencrypt_sasl: Use a Let's Encrypt certificate authority (CA) for Kafka SASL authentication. (Default: False).
        :param pulumi.Input[_builtins.bool] letsencrypt_sasl_privatelink: Use a Let's Encrypt certificate authority (CA) for Kafka SASL authentication via Privatelink. (Default: False).
        :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[Sequence[pulumi.Input[_builtins.str]]] sasl_oauthbearer_allowed_urls: List of allowed URLs for SASL OAUTHBEARER authentication. Only HTTPS URLs are allowed for security reasons.
        :param pulumi.Input[_builtins.bool] schema_registry: Enable Schema-Registry service. Default: `false`.
        :param pulumi.Input['KafkaKafkaUserConfigSchemaRegistryConfigArgs'] schema_registry_config: Schema Registry configuration
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input['KafkaKafkaUserConfigSingleZoneArgs'] single_zone: Single-zone configuration
        :param pulumi.Input[_builtins.bool] static_ips: Use static public IP addresses.
        :param pulumi.Input['KafkaKafkaUserConfigTieredStorageArgs'] tiered_storage: Tiered storage configuration
        """
        if additional_backup_regions is not None:
            warnings.warn("""This property is deprecated.""", DeprecationWarning)
            pulumi.log.warn("""additional_backup_regions is deprecated: This property is deprecated.""")
        if additional_backup_regions is not None:
            pulumi.set(__self__, "additional_backup_regions", additional_backup_regions)
        if aiven_kafka_topic_messages is not None:
            pulumi.set(__self__, "aiven_kafka_topic_messages", aiven_kafka_topic_messages)
        if backup_interval_hours is not None:
            pulumi.set(__self__, "backup_interval_hours", backup_interval_hours)
        if backup_retention_days is not None:
            pulumi.set(__self__, "backup_retention_days", backup_retention_days)
        if custom_domain is not None:
            pulumi.set(__self__, "custom_domain", custom_domain)
        if follower_fetching is not None:
            pulumi.set(__self__, "follower_fetching", follower_fetching)
        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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `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_connect_plugin_versions is not None:
            pulumi.set(__self__, "kafka_connect_plugin_versions", kafka_connect_plugin_versions)
        if kafka_connect_secret_providers is not None:
            pulumi.set(__self__, "kafka_connect_secret_providers", kafka_connect_secret_providers)
        if kafka_diskless is not None:
            pulumi.set(__self__, "kafka_diskless", kafka_diskless)
        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_sasl_mechanisms is not None:
            pulumi.set(__self__, "kafka_sasl_mechanisms", kafka_sasl_mechanisms)
        if kafka_version is not None:
            pulumi.set(__self__, "kafka_version", kafka_version)
        if letsencrypt_sasl is not None:
            pulumi.set(__self__, "letsencrypt_sasl", letsencrypt_sasl)
        if letsencrypt_sasl_privatelink is not None:
            pulumi.set(__self__, "letsencrypt_sasl_privatelink", letsencrypt_sasl_privatelink)
        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 sasl_oauthbearer_allowed_urls is not None:
            pulumi.set(__self__, "sasl_oauthbearer_allowed_urls", sasl_oauthbearer_allowed_urls)
        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 service_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        if single_zone is not None:
            pulumi.set(__self__, "single_zone", single_zone)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)
        if tiered_storage is not None:
            pulumi.set(__self__, "tiered_storage", tiered_storage)

    @_builtins.property
    @pulumi.getter(name="additionalBackupRegions")
    @_utilities.deprecated("""This property is deprecated.""")
    def additional_backup_regions(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @_builtins.property
    @pulumi.getter(name="aivenKafkaTopicMessages")
    def aiven_kafka_topic_messages(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow access to read Kafka topic messages in the Aiven Console and REST API.
        """
        return pulumi.get(self, "aiven_kafka_topic_messages")

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

    @_builtins.property
    @pulumi.getter(name="backupIntervalHours")
    def backup_interval_hours(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Interval in hours between automatic backups. Minimum value is 3 hours. Must be a divisor of 24 (3, 4, 6, 8, 12, 24). (Applicable to ACU plans only). Example: `24`.
        """
        return pulumi.get(self, "backup_interval_hours")

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

    @_builtins.property
    @pulumi.getter(name="backupRetentionDays")
    def backup_retention_days(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of days to retain automatic backups. Backups older than this value will be automatically deleted. (Applicable to ACU plans only). Example: `7`.
        """
        return pulumi.get(self, "backup_retention_days")

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

    @_builtins.property
    @pulumi.getter(name="customDomain")
    def custom_domain(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. When you set a custom domain for a service deployed in a VPC, the service certificate is only created for the public-* hostname and the custom domain. Example: `grafana.example.org`.
        """
        return pulumi.get(self, "custom_domain")

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

    @_builtins.property
    @pulumi.getter(name="followerFetching")
    def follower_fetching(self) -> Optional[pulumi.Input['KafkaKafkaUserConfigFollowerFetchingArgs']]:
        """
        Enable follower fetching
        """
        return pulumi.get(self, "follower_fetching")

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

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

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

    @_builtins.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)

    @_builtins.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)

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

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

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="kafkaConnectPluginVersions")
    def kafka_connect_plugin_versions(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KafkaKafkaUserConfigKafkaConnectPluginVersionArgs']]]]:
        """
        The plugin selected by the user
        """
        return pulumi.get(self, "kafka_connect_plugin_versions")

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

    @_builtins.property
    @pulumi.getter(name="kafkaConnectSecretProviders")
    def kafka_connect_secret_providers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KafkaKafkaUserConfigKafkaConnectSecretProviderArgs']]]]:
        return pulumi.get(self, "kafka_connect_secret_providers")

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

    @_builtins.property
    @pulumi.getter(name="kafkaDiskless")
    def kafka_diskless(self) -> Optional[pulumi.Input['KafkaKafkaUserConfigKafkaDisklessArgs']]:
        """
        Kafka Diskless configuration values
        """
        return pulumi.get(self, "kafka_diskless")

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

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

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

    @_builtins.property
    @pulumi.getter(name="kafkaRestAuthorization")
    def kafka_rest_authorization(self) -> Optional[pulumi.Input[_builtins.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[_builtins.bool]]):
        pulumi.set(self, "kafka_rest_authorization", value)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="kafkaSaslMechanisms")
    def kafka_sasl_mechanisms(self) -> Optional[pulumi.Input['KafkaKafkaUserConfigKafkaSaslMechanismsArgs']]:
        """
        Kafka SASL mechanisms
        """
        return pulumi.get(self, "kafka_sasl_mechanisms")

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

    @_builtins.property
    @pulumi.getter(name="kafkaVersion")
    def kafka_version(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `3.1`, `3.2`, `3.3`, `3.4`, `3.5`, `3.6`, `3.7`, `3.8`, `3.9`, `4.0`, `4.1`, and newer. Kafka major version.
        """
        return pulumi.get(self, "kafka_version")

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

    @_builtins.property
    @pulumi.getter(name="letsencryptSasl")
    def letsencrypt_sasl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Use a Let's Encrypt certificate authority (CA) for Kafka SASL authentication. (Default: False).
        """
        return pulumi.get(self, "letsencrypt_sasl")

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

    @_builtins.property
    @pulumi.getter(name="letsencryptSaslPrivatelink")
    def letsencrypt_sasl_privatelink(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Use a Let's Encrypt certificate authority (CA) for Kafka SASL authentication via Privatelink. (Default: False).
        """
        return pulumi.get(self, "letsencrypt_sasl_privatelink")

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

    @_builtins.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)

    @_builtins.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)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="saslOauthbearerAllowedUrls")
    def sasl_oauthbearer_allowed_urls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        List of allowed URLs for SASL OAUTHBEARER authentication. Only HTTPS URLs are allowed for security reasons.
        """
        return pulumi.get(self, "sasl_oauthbearer_allowed_urls")

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

    @_builtins.property
    @pulumi.getter(name="schemaRegistry")
    def schema_registry(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable Schema-Registry service. Default: `false`.
        """
        return pulumi.get(self, "schema_registry")

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

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

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

    @_builtins.property
    @pulumi.getter(name="singleZone")
    def single_zone(self) -> Optional[pulumi.Input['KafkaKafkaUserConfigSingleZoneArgs']]:
        """
        Single-zone configuration
        """
        return pulumi.get(self, "single_zone")

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

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

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

    @_builtins.property
    @pulumi.getter(name="tieredStorage")
    def tiered_storage(self) -> Optional[pulumi.Input['KafkaKafkaUserConfigTieredStorageArgs']]:
        """
        Tiered storage configuration
        """
        return pulumi.get(self, "tiered_storage")

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


if not MYPY:
    class KafkaKafkaUserConfigFollowerFetchingArgsDict(TypedDict):
        enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether to enable the follower fetching functionality.
        """
elif False:
    KafkaKafkaUserConfigFollowerFetchingArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigFollowerFetchingArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] enabled: Whether to enable the follower fetching functionality.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether to enable the follower fetching functionality.
        """
        return pulumi.get(self, "enabled")

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


if not MYPY:
    class KafkaKafkaUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    KafkaKafkaUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

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

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

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


if not MYPY:
    class KafkaKafkaUserConfigKafkaArgsDict(TypedDict):
        auto_create_topics_enable: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable auto-creation of topics. (Default: true).
        """
        compression_type: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `gzip`, `lz4`, `producer`, `snappy`, `uncompressed`, `zstd`. Specify the final compression type for a given topic. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `uncompressed` which is equivalent to no compression; and `producer` which means retain the original compression codec set by the producer.(Default: producer).
        """
        connections_max_idle_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        Idle connections timeout: the server socket processor threads close the connections that idle for longer than this. (Default: 600000 ms (10 minutes)). Example: `540000`.
        """
        default_replication_factor: NotRequired[pulumi.Input[_builtins.int]]
        """
        Replication factor for auto-created topics (Default: 3).
        """
        group_initial_rebalance_delay_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The amount of time, in milliseconds, the group coordinator will wait for more consumers to join a new group before performing the first rebalance. A longer delay means potentially fewer rebalances, but increases the time until processing begins. The default value for this is 3 seconds. During development and testing it might be desirable to set this to 0 in order to not delay test execution time. (Default: 3000 ms (3 seconds)). Example: `3000`.
        """
        group_max_session_timeout_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. Default: 1800000 ms (30 minutes).
        """
        group_min_session_timeout_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. (Default: 6000 ms (6 seconds)). Example: `6000`.
        """
        log_cleaner_delete_retention_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        How long are delete records retained? (Default: 86400000 (1 day)).
        """
        log_cleaner_max_compaction_lag_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum amount of time message will remain uncompacted. Only applicable for logs that are being compacted. (Default: 9223372036854775807 ms (Long.MAX_VALUE)).
        """
        log_cleaner_min_cleanable_ratio: NotRequired[pulumi.Input[_builtins.float]]
        """
        Controls log compactor frequency. Larger value means more frequent compactions but also more space wasted for logs. Consider setting log.cleaner.max.compaction.lag.ms to enforce compactions sooner, instead of setting a very high value for this option. (Default: 0.5). Example: `0.5`.
        """
        log_cleaner_min_compaction_lag_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted. (Default: 0 ms).
        """
        log_cleanup_policy: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `compact`, `compact,delete`, `delete`. The default cleanup policy for segments beyond the retention window (Default: delete).
        """
        log_flush_interval_messages: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of messages accumulated on a log partition before messages are flushed to disk (Default: 9223372036854775807 (Long.MAX_VALUE)).
        """
        log_flush_interval_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum time in ms that a message in any topic is kept in memory (page-cache) before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used (Default: null).
        """
        log_index_interval_bytes: NotRequired[pulumi.Input[_builtins.int]]
        """
        The interval with which Kafka adds an entry to the offset index (Default: 4096 bytes (4 kibibytes)). Example: `4096`.
        """
        log_index_size_max_bytes: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum size in bytes of the offset index (Default: 10485760 (10 mebibytes)).
        """
        log_local_retention_bytes: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum size of local log segments that can grow for a partition before it gets eligible for deletion. If set to -2, the value of log.retention.bytes is used. The effective value should always be less than or equal to log.retention.bytes value. (Default: -2).
        """
        log_local_retention_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of milliseconds to keep the local log segments before it gets eligible for deletion. If set to -2, the value of log.retention.ms is used. The effective value should always be less than or equal to log.retention.ms value. (Default: -2).
        """
        log_message_downconversion_enable: NotRequired[pulumi.Input[_builtins.bool]]
        """
        This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests. (Default: true).
        """
        log_message_timestamp_after_max_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message. If message.timestamp.type=CreateTime, a message will be rejected if the difference in timestamp exceeds this threshold. Applies only for messages with timestamps later than the broker's timestamp. (Default: 9223372036854775807 (Long.MAX_VALUE)).
        """
        log_message_timestamp_before_max_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message. If message.timestamp.type=CreateTime, a message will be rejected if the difference in timestamp exceeds this threshold. Applies only for messages with timestamps earlier than the broker's timestamp. (Default: 9223372036854775807 (Long.MAX_VALUE)).
        """
        log_message_timestamp_difference_max_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message (Default: 9223372036854775807 (Long.MAX_VALUE)).
        """
        log_message_timestamp_type: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `CreateTime`, `LogAppendTime`. Define whether the timestamp in the message is message create time or log append time. (Default: CreateTime).
        """
        log_preallocate: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Should pre allocate file when create new segment? (Default: false).
        """
        log_retention_bytes: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum size of the log before deleting messages (Default: -1).
        """
        log_retention_hours: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of hours to keep a log file before deleting it. Use -1 for unlimited retention or 1 or higher. Setting 0 is invalid and prevents Kafka from starting. (Default: 168 hours, or 1 week).
        """
        log_retention_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied. (Default: null, log.retention.hours applies).
        """
        log_roll_jitter_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used (Default: null).
        """
        log_roll_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum time before a new log segment is rolled out (in milliseconds). (Default: null, log.roll.hours applies (Default: 168, 7 days)).
        """
        log_segment_bytes: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum size of a single log file (Default: 1073741824 bytes (1 gibibyte)).
        """
        log_segment_delete_delay_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The amount of time to wait before deleting a file from the filesystem (Default: 60000 ms (1 minute)). Example: `60000`.
        """
        max_connections_per_ip: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of connections allowed from each ip address (Default: 2147483647).
        """
        max_incremental_fetch_session_cache_slots: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of incremental fetch sessions that the broker will maintain. (Default: 1000). Example: `1000`.
        """
        message_max_bytes: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum size of message that the server can receive. (Default: 1048588 bytes (1 mebibyte + 12 bytes)).
        """
        min_insync_replicas: NotRequired[pulumi.Input[_builtins.int]]
        """
        When a producer sets acks to `all` (or `-1`), min.insync.replicas specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. (Default: 1). Example: `1`.
        """
        num_partitions: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of partitions for auto-created topics (Default: 1).
        """
        offsets_retention_minutes: NotRequired[pulumi.Input[_builtins.int]]
        """
        Log retention window in minutes for offsets topic (Default: 10080 minutes (7 days)). Example: `10080`.
        """
        producer_purgatory_purge_interval_requests: NotRequired[pulumi.Input[_builtins.int]]
        """
        The purge interval (in number of requests) of the producer request purgatory (Default: 1000).
        """
        replica_fetch_max_bytes: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of bytes of messages to attempt to fetch for each partition . This is not an absolute maximum, if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that progress can be made. (Default: 1048576 bytes (1 mebibytes)).
        """
        replica_fetch_response_max_bytes: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum bytes expected for the entire fetch response. Records are fetched in batches, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that progress can be made. As such, this is not an absolute maximum. (Default: 10485760 bytes (10 mebibytes)).
        """
        sasl_oauthbearer_expected_audience: NotRequired[pulumi.Input[_builtins.str]]
        """
        The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences. (Default: null).
        """
        sasl_oauthbearer_expected_issuer: NotRequired[pulumi.Input[_builtins.str]]
        """
        Optional setting for the broker to use to verify that the JWT was created by the expected issuer.(Default: null).
        """
        sasl_oauthbearer_jwks_endpoint_url: NotRequired[pulumi.Input[_builtins.str]]
        """
        OIDC JWKS endpoint URL. By setting this the SASL SSL OAuth2/OIDC authentication is enabled. See also other options for SASL OAuth2/OIDC. (Default: null).
        """
        sasl_oauthbearer_sub_claim_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of the scope from which to extract the subject claim from the JWT.(Default: sub).
        """
        socket_request_max_bytes: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of bytes in a socket request (Default: 104857600 bytes).
        """
        transaction_partition_verification_enable: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable verification that checks that the partition has been added to the transaction before writing transactional records to the partition. (Default: true).
        """
        transaction_remove_expired_transaction_cleanup_interval_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The interval at which to remove transactions that have expired due to transactional.id.expiration.ms passing (Default: 3600000 ms (1 hour)).
        """
        transaction_state_log_segment_bytes: NotRequired[pulumi.Input[_builtins.int]]
        """
        The transaction topic segment bytes should be kept relatively small in order to facilitate faster log compaction and cache loads (Default: 104857600 bytes (100 mebibytes)).
        """
elif False:
    KafkaKafkaUserConfigKafkaArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigKafkaArgs:
    def __init__(__self__, *,
                 auto_create_topics_enable: Optional[pulumi.Input[_builtins.bool]] = None,
                 compression_type: Optional[pulumi.Input[_builtins.str]] = None,
                 connections_max_idle_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 default_replication_factor: Optional[pulumi.Input[_builtins.int]] = None,
                 group_initial_rebalance_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 group_max_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 group_min_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 log_cleaner_delete_retention_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 log_cleaner_max_compaction_lag_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 log_cleaner_min_cleanable_ratio: Optional[pulumi.Input[_builtins.float]] = None,
                 log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 log_cleanup_policy: Optional[pulumi.Input[_builtins.str]] = None,
                 log_flush_interval_messages: Optional[pulumi.Input[_builtins.int]] = None,
                 log_flush_interval_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 log_index_interval_bytes: Optional[pulumi.Input[_builtins.int]] = None,
                 log_index_size_max_bytes: Optional[pulumi.Input[_builtins.int]] = None,
                 log_local_retention_bytes: Optional[pulumi.Input[_builtins.int]] = None,
                 log_local_retention_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 log_message_downconversion_enable: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_message_timestamp_after_max_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 log_message_timestamp_before_max_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 log_message_timestamp_difference_max_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 log_message_timestamp_type: Optional[pulumi.Input[_builtins.str]] = None,
                 log_preallocate: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_retention_bytes: Optional[pulumi.Input[_builtins.int]] = None,
                 log_retention_hours: Optional[pulumi.Input[_builtins.int]] = None,
                 log_retention_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 log_roll_jitter_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 log_roll_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 log_segment_bytes: Optional[pulumi.Input[_builtins.int]] = None,
                 log_segment_delete_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 max_connections_per_ip: Optional[pulumi.Input[_builtins.int]] = None,
                 max_incremental_fetch_session_cache_slots: Optional[pulumi.Input[_builtins.int]] = None,
                 message_max_bytes: Optional[pulumi.Input[_builtins.int]] = None,
                 min_insync_replicas: Optional[pulumi.Input[_builtins.int]] = None,
                 num_partitions: Optional[pulumi.Input[_builtins.int]] = None,
                 offsets_retention_minutes: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_purgatory_purge_interval_requests: Optional[pulumi.Input[_builtins.int]] = None,
                 replica_fetch_max_bytes: Optional[pulumi.Input[_builtins.int]] = None,
                 replica_fetch_response_max_bytes: Optional[pulumi.Input[_builtins.int]] = None,
                 sasl_oauthbearer_expected_audience: Optional[pulumi.Input[_builtins.str]] = None,
                 sasl_oauthbearer_expected_issuer: Optional[pulumi.Input[_builtins.str]] = None,
                 sasl_oauthbearer_jwks_endpoint_url: Optional[pulumi.Input[_builtins.str]] = None,
                 sasl_oauthbearer_sub_claim_name: Optional[pulumi.Input[_builtins.str]] = None,
                 socket_request_max_bytes: Optional[pulumi.Input[_builtins.int]] = None,
                 transaction_partition_verification_enable: Optional[pulumi.Input[_builtins.bool]] = None,
                 transaction_remove_expired_transaction_cleanup_interval_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 transaction_state_log_segment_bytes: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.bool] auto_create_topics_enable: Enable auto-creation of topics. (Default: true).
        :param pulumi.Input[_builtins.str] compression_type: Enum: `gzip`, `lz4`, `producer`, `snappy`, `uncompressed`, `zstd`. Specify the final compression type for a given topic. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `uncompressed` which is equivalent to no compression; and `producer` which means retain the original compression codec set by the producer.(Default: producer).
        :param pulumi.Input[_builtins.int] connections_max_idle_ms: Idle connections timeout: the server socket processor threads close the connections that idle for longer than this. (Default: 600000 ms (10 minutes)). Example: `540000`.
        :param pulumi.Input[_builtins.int] default_replication_factor: Replication factor for auto-created topics (Default: 3).
        :param pulumi.Input[_builtins.int] group_initial_rebalance_delay_ms: The amount of time, in milliseconds, the group coordinator will wait for more consumers to join a new group before performing the first rebalance. A longer delay means potentially fewer rebalances, but increases the time until processing begins. The default value for this is 3 seconds. During development and testing it might be desirable to set this to 0 in order to not delay test execution time. (Default: 3000 ms (3 seconds)). Example: `3000`.
        :param pulumi.Input[_builtins.int] group_max_session_timeout_ms: The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. Default: 1800000 ms (30 minutes).
        :param pulumi.Input[_builtins.int] group_min_session_timeout_ms: The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. (Default: 6000 ms (6 seconds)). Example: `6000`.
        :param pulumi.Input[_builtins.int] log_cleaner_delete_retention_ms: How long are delete records retained? (Default: 86400000 (1 day)).
        :param pulumi.Input[_builtins.int] log_cleaner_max_compaction_lag_ms: The maximum amount of time message will remain uncompacted. Only applicable for logs that are being compacted. (Default: 9223372036854775807 ms (Long.MAX_VALUE)).
        :param pulumi.Input[_builtins.float] log_cleaner_min_cleanable_ratio: Controls log compactor frequency. Larger value means more frequent compactions but also more space wasted for logs. Consider setting log.cleaner.max.compaction.lag.ms to enforce compactions sooner, instead of setting a very high value for this option. (Default: 0.5). Example: `0.5`.
        :param pulumi.Input[_builtins.int] log_cleaner_min_compaction_lag_ms: The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted. (Default: 0 ms).
        :param pulumi.Input[_builtins.str] log_cleanup_policy: Enum: `compact`, `compact,delete`, `delete`. The default cleanup policy for segments beyond the retention window (Default: delete).
        :param pulumi.Input[_builtins.int] log_flush_interval_messages: The number of messages accumulated on a log partition before messages are flushed to disk (Default: 9223372036854775807 (Long.MAX_VALUE)).
        :param pulumi.Input[_builtins.int] log_flush_interval_ms: The maximum time in ms that a message in any topic is kept in memory (page-cache) before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used (Default: null).
        :param pulumi.Input[_builtins.int] log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index (Default: 4096 bytes (4 kibibytes)). Example: `4096`.
        :param pulumi.Input[_builtins.int] log_index_size_max_bytes: The maximum size in bytes of the offset index (Default: 10485760 (10 mebibytes)).
        :param pulumi.Input[_builtins.int] log_local_retention_bytes: The maximum size of local log segments that can grow for a partition before it gets eligible for deletion. If set to -2, the value of log.retention.bytes is used. The effective value should always be less than or equal to log.retention.bytes value. (Default: -2).
        :param pulumi.Input[_builtins.int] log_local_retention_ms: The number of milliseconds to keep the local log segments before it gets eligible for deletion. If set to -2, the value of log.retention.ms is used. The effective value should always be less than or equal to log.retention.ms value. (Default: -2).
        :param pulumi.Input[_builtins.bool] log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests. (Default: true).
        :param pulumi.Input[_builtins.int] log_message_timestamp_after_max_ms: The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message. If message.timestamp.type=CreateTime, a message will be rejected if the difference in timestamp exceeds this threshold. Applies only for messages with timestamps later than the broker's timestamp. (Default: 9223372036854775807 (Long.MAX_VALUE)).
        :param pulumi.Input[_builtins.int] log_message_timestamp_before_max_ms: The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message. If message.timestamp.type=CreateTime, a message will be rejected if the difference in timestamp exceeds this threshold. Applies only for messages with timestamps earlier than the broker's timestamp. (Default: 9223372036854775807 (Long.MAX_VALUE)).
        :param pulumi.Input[_builtins.int] log_message_timestamp_difference_max_ms: The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message (Default: 9223372036854775807 (Long.MAX_VALUE)).
        :param pulumi.Input[_builtins.str] log_message_timestamp_type: Enum: `CreateTime`, `LogAppendTime`. Define whether the timestamp in the message is message create time or log append time. (Default: CreateTime).
        :param pulumi.Input[_builtins.bool] log_preallocate: Should pre allocate file when create new segment? (Default: false).
        :param pulumi.Input[_builtins.int] log_retention_bytes: The maximum size of the log before deleting messages (Default: -1).
        :param pulumi.Input[_builtins.int] log_retention_hours: The number of hours to keep a log file before deleting it. Use -1 for unlimited retention or 1 or higher. Setting 0 is invalid and prevents Kafka from starting. (Default: 168 hours, or 1 week).
        :param pulumi.Input[_builtins.int] log_retention_ms: The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied. (Default: null, log.retention.hours applies).
        :param pulumi.Input[_builtins.int] log_roll_jitter_ms: The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used (Default: null).
        :param pulumi.Input[_builtins.int] log_roll_ms: The maximum time before a new log segment is rolled out (in milliseconds). (Default: null, log.roll.hours applies (Default: 168, 7 days)).
        :param pulumi.Input[_builtins.int] log_segment_bytes: The maximum size of a single log file (Default: 1073741824 bytes (1 gibibyte)).
        :param pulumi.Input[_builtins.int] log_segment_delete_delay_ms: The amount of time to wait before deleting a file from the filesystem (Default: 60000 ms (1 minute)). Example: `60000`.
        :param pulumi.Input[_builtins.int] max_connections_per_ip: The maximum number of connections allowed from each ip address (Default: 2147483647).
        :param pulumi.Input[_builtins.int] max_incremental_fetch_session_cache_slots: The maximum number of incremental fetch sessions that the broker will maintain. (Default: 1000). Example: `1000`.
        :param pulumi.Input[_builtins.int] message_max_bytes: The maximum size of message that the server can receive. (Default: 1048588 bytes (1 mebibyte + 12 bytes)).
        :param pulumi.Input[_builtins.int] min_insync_replicas: When a producer sets acks to `all` (or `-1`), min.insync.replicas specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. (Default: 1). Example: `1`.
        :param pulumi.Input[_builtins.int] num_partitions: Number of partitions for auto-created topics (Default: 1).
        :param pulumi.Input[_builtins.int] offsets_retention_minutes: Log retention window in minutes for offsets topic (Default: 10080 minutes (7 days)). Example: `10080`.
        :param pulumi.Input[_builtins.int] producer_purgatory_purge_interval_requests: The purge interval (in number of requests) of the producer request purgatory (Default: 1000).
        :param pulumi.Input[_builtins.int] replica_fetch_max_bytes: The number of bytes of messages to attempt to fetch for each partition . This is not an absolute maximum, if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that progress can be made. (Default: 1048576 bytes (1 mebibytes)).
        :param pulumi.Input[_builtins.int] replica_fetch_response_max_bytes: Maximum bytes expected for the entire fetch response. Records are fetched in batches, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that progress can be made. As such, this is not an absolute maximum. (Default: 10485760 bytes (10 mebibytes)).
        :param pulumi.Input[_builtins.str] sasl_oauthbearer_expected_audience: The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences. (Default: null).
        :param pulumi.Input[_builtins.str] sasl_oauthbearer_expected_issuer: Optional setting for the broker to use to verify that the JWT was created by the expected issuer.(Default: null).
        :param pulumi.Input[_builtins.str] sasl_oauthbearer_jwks_endpoint_url: OIDC JWKS endpoint URL. By setting this the SASL SSL OAuth2/OIDC authentication is enabled. See also other options for SASL OAuth2/OIDC. (Default: null).
        :param pulumi.Input[_builtins.str] sasl_oauthbearer_sub_claim_name: Name of the scope from which to extract the subject claim from the JWT.(Default: sub).
        :param pulumi.Input[_builtins.int] socket_request_max_bytes: The maximum number of bytes in a socket request (Default: 104857600 bytes).
        :param pulumi.Input[_builtins.bool] transaction_partition_verification_enable: Enable verification that checks that the partition has been added to the transaction before writing transactional records to the partition. (Default: true).
        :param pulumi.Input[_builtins.int] transaction_remove_expired_transaction_cleanup_interval_ms: The interval at which to remove transactions that have expired due to transactional.id.expiration.ms passing (Default: 3600000 ms (1 hour)).
        :param pulumi.Input[_builtins.int] transaction_state_log_segment_bytes: The transaction topic segment bytes should be kept relatively small in order to facilitate faster log compaction and cache loads (Default: 104857600 bytes (100 mebibytes)).
        """
        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_local_retention_bytes is not None:
            pulumi.set(__self__, "log_local_retention_bytes", log_local_retention_bytes)
        if log_local_retention_ms is not None:
            pulumi.set(__self__, "log_local_retention_ms", log_local_retention_ms)
        if log_message_downconversion_enable is not None:
            pulumi.set(__self__, "log_message_downconversion_enable", log_message_downconversion_enable)
        if log_message_timestamp_after_max_ms is not None:
            pulumi.set(__self__, "log_message_timestamp_after_max_ms", log_message_timestamp_after_max_ms)
        if log_message_timestamp_before_max_ms is not None:
            pulumi.set(__self__, "log_message_timestamp_before_max_ms", log_message_timestamp_before_max_ms)
        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 sasl_oauthbearer_expected_audience is not None:
            pulumi.set(__self__, "sasl_oauthbearer_expected_audience", sasl_oauthbearer_expected_audience)
        if sasl_oauthbearer_expected_issuer is not None:
            pulumi.set(__self__, "sasl_oauthbearer_expected_issuer", sasl_oauthbearer_expected_issuer)
        if sasl_oauthbearer_jwks_endpoint_url is not None:
            pulumi.set(__self__, "sasl_oauthbearer_jwks_endpoint_url", sasl_oauthbearer_jwks_endpoint_url)
        if sasl_oauthbearer_sub_claim_name is not None:
            pulumi.set(__self__, "sasl_oauthbearer_sub_claim_name", sasl_oauthbearer_sub_claim_name)
        if socket_request_max_bytes is not None:
            pulumi.set(__self__, "socket_request_max_bytes", socket_request_max_bytes)
        if transaction_partition_verification_enable is not None:
            pulumi.set(__self__, "transaction_partition_verification_enable", transaction_partition_verification_enable)
        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)

    @_builtins.property
    @pulumi.getter(name="autoCreateTopicsEnable")
    def auto_create_topics_enable(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable auto-creation of topics. (Default: true).
        """
        return pulumi.get(self, "auto_create_topics_enable")

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

    @_builtins.property
    @pulumi.getter(name="compressionType")
    def compression_type(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `gzip`, `lz4`, `producer`, `snappy`, `uncompressed`, `zstd`. Specify the final compression type for a given topic. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `uncompressed` which is equivalent to no compression; and `producer` which means retain the original compression codec set by the producer.(Default: producer).
        """
        return pulumi.get(self, "compression_type")

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

    @_builtins.property
    @pulumi.getter(name="connectionsMaxIdleMs")
    def connections_max_idle_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Idle connections timeout: the server socket processor threads close the connections that idle for longer than this. (Default: 600000 ms (10 minutes)). Example: `540000`.
        """
        return pulumi.get(self, "connections_max_idle_ms")

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

    @_builtins.property
    @pulumi.getter(name="defaultReplicationFactor")
    def default_replication_factor(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Replication factor for auto-created topics (Default: 3).
        """
        return pulumi.get(self, "default_replication_factor")

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

    @_builtins.property
    @pulumi.getter(name="groupInitialRebalanceDelayMs")
    def group_initial_rebalance_delay_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The amount of time, in milliseconds, the group coordinator will wait for more consumers to join a new group before performing the first rebalance. A longer delay means potentially fewer rebalances, but increases the time until processing begins. The default value for this is 3 seconds. During development and testing it might be desirable to set this to 0 in order to not delay test execution time. (Default: 3000 ms (3 seconds)). Example: `3000`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "group_initial_rebalance_delay_ms", value)

    @_builtins.property
    @pulumi.getter(name="groupMaxSessionTimeoutMs")
    def group_max_session_timeout_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. Default: 1800000 ms (30 minutes).
        """
        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[_builtins.int]]):
        pulumi.set(self, "group_max_session_timeout_ms", value)

    @_builtins.property
    @pulumi.getter(name="groupMinSessionTimeoutMs")
    def group_min_session_timeout_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The minimum allowed session timeout for registered consumers. Longer timeouts give consumers more time to process messages in between heartbeats at the cost of a longer time to detect failures. (Default: 6000 ms (6 seconds)). Example: `6000`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "group_min_session_timeout_ms", value)

    @_builtins.property
    @pulumi.getter(name="logCleanerDeleteRetentionMs")
    def log_cleaner_delete_retention_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        How long are delete records retained? (Default: 86400000 (1 day)).
        """
        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[_builtins.int]]):
        pulumi.set(self, "log_cleaner_delete_retention_ms", value)

    @_builtins.property
    @pulumi.getter(name="logCleanerMaxCompactionLagMs")
    def log_cleaner_max_compaction_lag_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum amount of time message will remain uncompacted. Only applicable for logs that are being compacted. (Default: 9223372036854775807 ms (Long.MAX_VALUE)).
        """
        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[_builtins.int]]):
        pulumi.set(self, "log_cleaner_max_compaction_lag_ms", value)

    @_builtins.property
    @pulumi.getter(name="logCleanerMinCleanableRatio")
    def log_cleaner_min_cleanable_ratio(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        Controls log compactor frequency. Larger value means more frequent compactions but also more space wasted for logs. Consider setting log.cleaner.max.compaction.lag.ms to enforce compactions sooner, instead of setting a very high value for this option. (Default: 0.5). Example: `0.5`.
        """
        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[_builtins.float]]):
        pulumi.set(self, "log_cleaner_min_cleanable_ratio", value)

    @_builtins.property
    @pulumi.getter(name="logCleanerMinCompactionLagMs")
    def log_cleaner_min_compaction_lag_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted. (Default: 0 ms).
        """
        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[_builtins.int]]):
        pulumi.set(self, "log_cleaner_min_compaction_lag_ms", value)

    @_builtins.property
    @pulumi.getter(name="logCleanupPolicy")
    def log_cleanup_policy(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `compact`, `compact,delete`, `delete`. The default cleanup policy for segments beyond the retention window (Default: delete).
        """
        return pulumi.get(self, "log_cleanup_policy")

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

    @_builtins.property
    @pulumi.getter(name="logFlushIntervalMessages")
    def log_flush_interval_messages(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of messages accumulated on a log partition before messages are flushed to disk (Default: 9223372036854775807 (Long.MAX_VALUE)).
        """
        return pulumi.get(self, "log_flush_interval_messages")

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

    @_builtins.property
    @pulumi.getter(name="logFlushIntervalMs")
    def log_flush_interval_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum time in ms that a message in any topic is kept in memory (page-cache) before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used (Default: null).
        """
        return pulumi.get(self, "log_flush_interval_ms")

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

    @_builtins.property
    @pulumi.getter(name="logIndexIntervalBytes")
    def log_index_interval_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The interval with which Kafka adds an entry to the offset index (Default: 4096 bytes (4 kibibytes)). Example: `4096`.
        """
        return pulumi.get(self, "log_index_interval_bytes")

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

    @_builtins.property
    @pulumi.getter(name="logIndexSizeMaxBytes")
    def log_index_size_max_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum size in bytes of the offset index (Default: 10485760 (10 mebibytes)).
        """
        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[_builtins.int]]):
        pulumi.set(self, "log_index_size_max_bytes", value)

    @_builtins.property
    @pulumi.getter(name="logLocalRetentionBytes")
    def log_local_retention_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum size of local log segments that can grow for a partition before it gets eligible for deletion. If set to -2, the value of log.retention.bytes is used. The effective value should always be less than or equal to log.retention.bytes value. (Default: -2).
        """
        return pulumi.get(self, "log_local_retention_bytes")

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

    @_builtins.property
    @pulumi.getter(name="logLocalRetentionMs")
    def log_local_retention_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of milliseconds to keep the local log segments before it gets eligible for deletion. If set to -2, the value of log.retention.ms is used. The effective value should always be less than or equal to log.retention.ms value. (Default: -2).
        """
        return pulumi.get(self, "log_local_retention_ms")

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

    @_builtins.property
    @pulumi.getter(name="logMessageDownconversionEnable")
    def log_message_downconversion_enable(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests. (Default: true).
        """
        return pulumi.get(self, "log_message_downconversion_enable")

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

    @_builtins.property
    @pulumi.getter(name="logMessageTimestampAfterMaxMs")
    def log_message_timestamp_after_max_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message. If message.timestamp.type=CreateTime, a message will be rejected if the difference in timestamp exceeds this threshold. Applies only for messages with timestamps later than the broker's timestamp. (Default: 9223372036854775807 (Long.MAX_VALUE)).
        """
        return pulumi.get(self, "log_message_timestamp_after_max_ms")

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

    @_builtins.property
    @pulumi.getter(name="logMessageTimestampBeforeMaxMs")
    def log_message_timestamp_before_max_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message. If message.timestamp.type=CreateTime, a message will be rejected if the difference in timestamp exceeds this threshold. Applies only for messages with timestamps earlier than the broker's timestamp. (Default: 9223372036854775807 (Long.MAX_VALUE)).
        """
        return pulumi.get(self, "log_message_timestamp_before_max_ms")

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

    @_builtins.property
    @pulumi.getter(name="logMessageTimestampDifferenceMaxMs")
    def log_message_timestamp_difference_max_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message (Default: 9223372036854775807 (Long.MAX_VALUE)).
        """
        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[_builtins.int]]):
        pulumi.set(self, "log_message_timestamp_difference_max_ms", value)

    @_builtins.property
    @pulumi.getter(name="logMessageTimestampType")
    def log_message_timestamp_type(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `CreateTime`, `LogAppendTime`. Define whether the timestamp in the message is message create time or log append time. (Default: CreateTime).
        """
        return pulumi.get(self, "log_message_timestamp_type")

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

    @_builtins.property
    @pulumi.getter(name="logPreallocate")
    def log_preallocate(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Should pre allocate file when create new segment? (Default: false).
        """
        return pulumi.get(self, "log_preallocate")

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

    @_builtins.property
    @pulumi.getter(name="logRetentionBytes")
    def log_retention_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum size of the log before deleting messages (Default: -1).
        """
        return pulumi.get(self, "log_retention_bytes")

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

    @_builtins.property
    @pulumi.getter(name="logRetentionHours")
    def log_retention_hours(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of hours to keep a log file before deleting it. Use -1 for unlimited retention or 1 or higher. Setting 0 is invalid and prevents Kafka from starting. (Default: 168 hours, or 1 week).
        """
        return pulumi.get(self, "log_retention_hours")

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

    @_builtins.property
    @pulumi.getter(name="logRetentionMs")
    def log_retention_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of milliseconds to keep a log file before deleting it (in milliseconds), If not set, the value in log.retention.minutes is used. If set to -1, no time limit is applied. (Default: null, log.retention.hours applies).
        """
        return pulumi.get(self, "log_retention_ms")

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

    @_builtins.property
    @pulumi.getter(name="logRollJitterMs")
    def log_roll_jitter_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used (Default: null).
        """
        return pulumi.get(self, "log_roll_jitter_ms")

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

    @_builtins.property
    @pulumi.getter(name="logRollMs")
    def log_roll_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum time before a new log segment is rolled out (in milliseconds). (Default: null, log.roll.hours applies (Default: 168, 7 days)).
        """
        return pulumi.get(self, "log_roll_ms")

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

    @_builtins.property
    @pulumi.getter(name="logSegmentBytes")
    def log_segment_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum size of a single log file (Default: 1073741824 bytes (1 gibibyte)).
        """
        return pulumi.get(self, "log_segment_bytes")

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

    @_builtins.property
    @pulumi.getter(name="logSegmentDeleteDelayMs")
    def log_segment_delete_delay_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The amount of time to wait before deleting a file from the filesystem (Default: 60000 ms (1 minute)). Example: `60000`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "log_segment_delete_delay_ms", value)

    @_builtins.property
    @pulumi.getter(name="maxConnectionsPerIp")
    def max_connections_per_ip(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of connections allowed from each ip address (Default: 2147483647).
        """
        return pulumi.get(self, "max_connections_per_ip")

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

    @_builtins.property
    @pulumi.getter(name="maxIncrementalFetchSessionCacheSlots")
    def max_incremental_fetch_session_cache_slots(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of incremental fetch sessions that the broker will maintain. (Default: 1000). Example: `1000`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "max_incremental_fetch_session_cache_slots", value)

    @_builtins.property
    @pulumi.getter(name="messageMaxBytes")
    def message_max_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum size of message that the server can receive. (Default: 1048588 bytes (1 mebibyte + 12 bytes)).
        """
        return pulumi.get(self, "message_max_bytes")

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

    @_builtins.property
    @pulumi.getter(name="minInsyncReplicas")
    def min_insync_replicas(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        When a producer sets acks to `all` (or `-1`), min.insync.replicas specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. (Default: 1). Example: `1`.
        """
        return pulumi.get(self, "min_insync_replicas")

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

    @_builtins.property
    @pulumi.getter(name="numPartitions")
    def num_partitions(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of partitions for auto-created topics (Default: 1).
        """
        return pulumi.get(self, "num_partitions")

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

    @_builtins.property
    @pulumi.getter(name="offsetsRetentionMinutes")
    def offsets_retention_minutes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Log retention window in minutes for offsets topic (Default: 10080 minutes (7 days)). Example: `10080`.
        """
        return pulumi.get(self, "offsets_retention_minutes")

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

    @_builtins.property
    @pulumi.getter(name="producerPurgatoryPurgeIntervalRequests")
    def producer_purgatory_purge_interval_requests(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The purge interval (in number of requests) of the producer request purgatory (Default: 1000).
        """
        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[_builtins.int]]):
        pulumi.set(self, "producer_purgatory_purge_interval_requests", value)

    @_builtins.property
    @pulumi.getter(name="replicaFetchMaxBytes")
    def replica_fetch_max_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of bytes of messages to attempt to fetch for each partition . This is not an absolute maximum, if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that progress can be made. (Default: 1048576 bytes (1 mebibytes)).
        """
        return pulumi.get(self, "replica_fetch_max_bytes")

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

    @_builtins.property
    @pulumi.getter(name="replicaFetchResponseMaxBytes")
    def replica_fetch_response_max_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum bytes expected for the entire fetch response. Records are fetched in batches, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that progress can be made. As such, this is not an absolute maximum. (Default: 10485760 bytes (10 mebibytes)).
        """
        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[_builtins.int]]):
        pulumi.set(self, "replica_fetch_response_max_bytes", value)

    @_builtins.property
    @pulumi.getter(name="saslOauthbearerExpectedAudience")
    def sasl_oauthbearer_expected_audience(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The (optional) comma-delimited setting for the broker to use to verify that the JWT was issued for one of the expected audiences. (Default: null).
        """
        return pulumi.get(self, "sasl_oauthbearer_expected_audience")

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

    @_builtins.property
    @pulumi.getter(name="saslOauthbearerExpectedIssuer")
    def sasl_oauthbearer_expected_issuer(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Optional setting for the broker to use to verify that the JWT was created by the expected issuer.(Default: null).
        """
        return pulumi.get(self, "sasl_oauthbearer_expected_issuer")

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

    @_builtins.property
    @pulumi.getter(name="saslOauthbearerJwksEndpointUrl")
    def sasl_oauthbearer_jwks_endpoint_url(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        OIDC JWKS endpoint URL. By setting this the SASL SSL OAuth2/OIDC authentication is enabled. See also other options for SASL OAuth2/OIDC. (Default: null).
        """
        return pulumi.get(self, "sasl_oauthbearer_jwks_endpoint_url")

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

    @_builtins.property
    @pulumi.getter(name="saslOauthbearerSubClaimName")
    def sasl_oauthbearer_sub_claim_name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of the scope from which to extract the subject claim from the JWT.(Default: sub).
        """
        return pulumi.get(self, "sasl_oauthbearer_sub_claim_name")

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

    @_builtins.property
    @pulumi.getter(name="socketRequestMaxBytes")
    def socket_request_max_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of bytes in a socket request (Default: 104857600 bytes).
        """
        return pulumi.get(self, "socket_request_max_bytes")

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

    @_builtins.property
    @pulumi.getter(name="transactionPartitionVerificationEnable")
    def transaction_partition_verification_enable(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable verification that checks that the partition has been added to the transaction before writing transactional records to the partition. (Default: true).
        """
        return pulumi.get(self, "transaction_partition_verification_enable")

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

    @_builtins.property
    @pulumi.getter(name="transactionRemoveExpiredTransactionCleanupIntervalMs")
    def transaction_remove_expired_transaction_cleanup_interval_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The interval at which to remove transactions that have expired due to transactional.id.expiration.ms passing (Default: 3600000 ms (1 hour)).
        """
        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[_builtins.int]]):
        pulumi.set(self, "transaction_remove_expired_transaction_cleanup_interval_ms", value)

    @_builtins.property
    @pulumi.getter(name="transactionStateLogSegmentBytes")
    def transaction_state_log_segment_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The transaction topic segment bytes should be kept relatively small in order to facilitate faster log compaction and cache loads (Default: 104857600 bytes (100 mebibytes)).
        """
        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[_builtins.int]]):
        pulumi.set(self, "transaction_state_log_segment_bytes", value)


if not MYPY:
    class KafkaKafkaUserConfigKafkaAuthenticationMethodsArgsDict(TypedDict):
        certificate: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable certificate/SSL authentication. Default: `true`.
        """
        sasl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable SASL authentication. Default: `false`.
        """
elif False:
    KafkaKafkaUserConfigKafkaAuthenticationMethodsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigKafkaAuthenticationMethodsArgs:
    def __init__(__self__, *,
                 certificate: Optional[pulumi.Input[_builtins.bool]] = None,
                 sasl: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] certificate: Enable certificate/SSL authentication. Default: `true`.
        :param pulumi.Input[_builtins.bool] sasl: Enable SASL authentication. Default: `false`.
        """
        if certificate is not None:
            pulumi.set(__self__, "certificate", certificate)
        if sasl is not None:
            pulumi.set(__self__, "sasl", sasl)

    @_builtins.property
    @pulumi.getter
    def certificate(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable certificate/SSL authentication. Default: `true`.
        """
        return pulumi.get(self, "certificate")

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

    @_builtins.property
    @pulumi.getter
    def sasl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable SASL authentication. Default: `false`.
        """
        return pulumi.get(self, "sasl")

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


if not MYPY:
    class KafkaKafkaUserConfigKafkaConnectConfigArgsDict(TypedDict):
        connector_client_config_override_policy: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `All`, `None`. Defines what client configurations can be overridden by the connector. Default is None.
        """
        consumer_auto_offset_reset: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `earliest`, `latest`. What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
        """
        consumer_fetch_max_bytes: NotRequired[pulumi.Input[_builtins.int]]
        """
        Records are fetched in batches by the consumer, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that the consumer can make progress. As such, this is not a absolute maximum.
        """
        consumer_isolation_level: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `read_committed`, `read_uncommitted`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
        """
        consumer_max_partition_fetch_bytes: NotRequired[pulumi.Input[_builtins.int]]
        """
        Records are fetched in batches by the consumer.If the first record batch in the first non-empty partition of the fetch is larger than this limit, the batch will still be returned to ensure that the consumer can make progress.
        """
        consumer_max_poll_interval_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum delay in milliseconds between invocations of poll() when using consumer group management (defaults to 300000).
        """
        consumer_max_poll_records: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of records returned in a single call to poll() (defaults to 500).
        """
        offset_flush_interval_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The interval at which to try committing offsets for tasks (defaults to 60000).
        """
        offset_flush_timeout_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt (defaults to 5000).
        """
        producer_batch_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        This setting gives the upper bound of the batch size to be sent. If there are fewer than this many bytes accumulated for this partition, the producer will `linger` for the linger.ms time waiting for more records to show up. A batch size of zero will disable batching entirely (defaults to 16384).
        """
        producer_buffer_memory: NotRequired[pulumi.Input[_builtins.int]]
        """
        The total bytes of memory the producer can use to buffer records waiting to be sent to the broker (defaults to 33554432).
        """
        producer_compression_type: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
        """
        producer_linger_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        This setting gives the upper bound on the delay for batching: once there is batch.size worth of records for a partition it will be sent immediately regardless of this setting, however if there are fewer than this many bytes accumulated for this partition the producer will `linger` for the specified time waiting for more records to show up. Defaults to 0.
        """
        producer_max_request_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests.
        """
        scheduled_rebalance_max_delay_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum delay that is scheduled in order to wait for the return of one or more departed workers before rebalancing and reassigning their connectors and tasks to the group. During this period the connectors and tasks of the departed workers remain unassigned. Defaults to 5 minutes.
        """
        session_timeout_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The timeout in milliseconds used to detect failures when using Kafka’s group management facilities (defaults to 10000).
        """
elif False:
    KafkaKafkaUserConfigKafkaConnectConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigKafkaConnectConfigArgs:
    def __init__(__self__, *,
                 connector_client_config_override_policy: Optional[pulumi.Input[_builtins.str]] = None,
                 consumer_auto_offset_reset: Optional[pulumi.Input[_builtins.str]] = None,
                 consumer_fetch_max_bytes: Optional[pulumi.Input[_builtins.int]] = None,
                 consumer_isolation_level: Optional[pulumi.Input[_builtins.str]] = None,
                 consumer_max_partition_fetch_bytes: Optional[pulumi.Input[_builtins.int]] = None,
                 consumer_max_poll_interval_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 consumer_max_poll_records: Optional[pulumi.Input[_builtins.int]] = None,
                 offset_flush_interval_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 offset_flush_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_batch_size: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_buffer_memory: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_compression_type: Optional[pulumi.Input[_builtins.str]] = None,
                 producer_linger_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_max_request_size: Optional[pulumi.Input[_builtins.int]] = None,
                 scheduled_rebalance_max_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.str] connector_client_config_override_policy: Enum: `All`, `None`. Defines what client configurations can be overridden by the connector. Default is None.
        :param pulumi.Input[_builtins.str] consumer_auto_offset_reset: Enum: `earliest`, `latest`. What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
        :param pulumi.Input[_builtins.int] consumer_fetch_max_bytes: Records are fetched in batches by the consumer, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that the consumer can make progress. As such, this is not a absolute maximum.
        :param pulumi.Input[_builtins.str] consumer_isolation_level: Enum: `read_committed`, `read_uncommitted`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
        :param pulumi.Input[_builtins.int] consumer_max_partition_fetch_bytes: Records are fetched in batches by the consumer.If the first record batch in the first non-empty partition of the fetch is larger than this limit, the batch will still be returned to ensure that the consumer can make progress.
        :param pulumi.Input[_builtins.int] consumer_max_poll_interval_ms: The maximum delay in milliseconds between invocations of poll() when using consumer group management (defaults to 300000).
        :param pulumi.Input[_builtins.int] consumer_max_poll_records: The maximum number of records returned in a single call to poll() (defaults to 500).
        :param pulumi.Input[_builtins.int] offset_flush_interval_ms: The interval at which to try committing offsets for tasks (defaults to 60000).
        :param pulumi.Input[_builtins.int] offset_flush_timeout_ms: Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt (defaults to 5000).
        :param pulumi.Input[_builtins.int] producer_batch_size: This setting gives the upper bound of the batch size to be sent. If there are fewer than this many bytes accumulated for this partition, the producer will `linger` for the linger.ms time waiting for more records to show up. A batch size of zero will disable batching entirely (defaults to 16384).
        :param pulumi.Input[_builtins.int] producer_buffer_memory: The total bytes of memory the producer can use to buffer records waiting to be sent to the broker (defaults to 33554432).
        :param pulumi.Input[_builtins.str] producer_compression_type: Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
        :param pulumi.Input[_builtins.int] producer_linger_ms: This setting gives the upper bound on the delay for batching: once there is batch.size worth of records for a partition it will be sent immediately regardless of this setting, however if there are fewer than this many bytes accumulated for this partition the producer will `linger` for the specified time waiting for more records to show up. Defaults to 0.
        :param pulumi.Input[_builtins.int] producer_max_request_size: This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests.
        :param pulumi.Input[_builtins.int] scheduled_rebalance_max_delay_ms: The maximum delay that is scheduled in order to wait for the return of one or more departed workers before rebalancing and reassigning their connectors and tasks to the group. During this period the connectors and tasks of the departed workers remain unassigned. Defaults to 5 minutes.
        :param pulumi.Input[_builtins.int] session_timeout_ms: The timeout in milliseconds used to detect failures when using Kafka’s group management facilities (defaults to 10000).
        """
        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)

    @_builtins.property
    @pulumi.getter(name="connectorClientConfigOverridePolicy")
    def connector_client_config_override_policy(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `All`, `None`. Defines what client configurations can be overridden by the connector. Default is None.
        """
        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[_builtins.str]]):
        pulumi.set(self, "connector_client_config_override_policy", value)

    @_builtins.property
    @pulumi.getter(name="consumerAutoOffsetReset")
    def consumer_auto_offset_reset(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `earliest`, `latest`. What to do when there is no initial offset in Kafka or if the current offset does not exist any more on the server. Default is earliest.
        """
        return pulumi.get(self, "consumer_auto_offset_reset")

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

    @_builtins.property
    @pulumi.getter(name="consumerFetchMaxBytes")
    def consumer_fetch_max_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Records are fetched in batches by the consumer, and if the first record batch in the first non-empty partition of the fetch is larger than this value, the record batch will still be returned to ensure that the consumer can make progress. As such, this is not a absolute maximum.
        """
        return pulumi.get(self, "consumer_fetch_max_bytes")

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

    @_builtins.property
    @pulumi.getter(name="consumerIsolationLevel")
    def consumer_isolation_level(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `read_committed`, `read_uncommitted`. Transaction read isolation level. read*uncommitted is the default, but read*committed can be used if consume-exactly-once behavior is desired.
        """
        return pulumi.get(self, "consumer_isolation_level")

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

    @_builtins.property
    @pulumi.getter(name="consumerMaxPartitionFetchBytes")
    def consumer_max_partition_fetch_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Records are fetched in batches by the consumer.If the first record batch in the first non-empty partition of the fetch is larger than this limit, the batch will still be returned to ensure that the consumer can make progress.
        """
        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[_builtins.int]]):
        pulumi.set(self, "consumer_max_partition_fetch_bytes", value)

    @_builtins.property
    @pulumi.getter(name="consumerMaxPollIntervalMs")
    def consumer_max_poll_interval_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum delay in milliseconds between invocations of poll() when using consumer group management (defaults to 300000).
        """
        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[_builtins.int]]):
        pulumi.set(self, "consumer_max_poll_interval_ms", value)

    @_builtins.property
    @pulumi.getter(name="consumerMaxPollRecords")
    def consumer_max_poll_records(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of records returned in a single call to poll() (defaults to 500).
        """
        return pulumi.get(self, "consumer_max_poll_records")

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

    @_builtins.property
    @pulumi.getter(name="offsetFlushIntervalMs")
    def offset_flush_interval_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The interval at which to try committing offsets for tasks (defaults to 60000).
        """
        return pulumi.get(self, "offset_flush_interval_ms")

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

    @_builtins.property
    @pulumi.getter(name="offsetFlushTimeoutMs")
    def offset_flush_timeout_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum number of milliseconds to wait for records to flush and partition offset data to be committed to offset storage before cancelling the process and restoring the offset data to be committed in a future attempt (defaults to 5000).
        """
        return pulumi.get(self, "offset_flush_timeout_ms")

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

    @_builtins.property
    @pulumi.getter(name="producerBatchSize")
    def producer_batch_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        This setting gives the upper bound of the batch size to be sent. If there are fewer than this many bytes accumulated for this partition, the producer will `linger` for the linger.ms time waiting for more records to show up. A batch size of zero will disable batching entirely (defaults to 16384).
        """
        return pulumi.get(self, "producer_batch_size")

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

    @_builtins.property
    @pulumi.getter(name="producerBufferMemory")
    def producer_buffer_memory(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The total bytes of memory the producer can use to buffer records waiting to be sent to the broker (defaults to 33554432).
        """
        return pulumi.get(self, "producer_buffer_memory")

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

    @_builtins.property
    @pulumi.getter(name="producerCompressionType")
    def producer_compression_type(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
        """
        return pulumi.get(self, "producer_compression_type")

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

    @_builtins.property
    @pulumi.getter(name="producerLingerMs")
    def producer_linger_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        This setting gives the upper bound on the delay for batching: once there is batch.size worth of records for a partition it will be sent immediately regardless of this setting, however if there are fewer than this many bytes accumulated for this partition the producer will `linger` for the specified time waiting for more records to show up. Defaults to 0.
        """
        return pulumi.get(self, "producer_linger_ms")

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

    @_builtins.property
    @pulumi.getter(name="producerMaxRequestSize")
    def producer_max_request_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        This setting will limit the number of record batches the producer will send in a single request to avoid sending huge requests.
        """
        return pulumi.get(self, "producer_max_request_size")

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

    @_builtins.property
    @pulumi.getter(name="scheduledRebalanceMaxDelayMs")
    def scheduled_rebalance_max_delay_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum delay that is scheduled in order to wait for the return of one or more departed workers before rebalancing and reassigning their connectors and tasks to the group. During this period the connectors and tasks of the departed workers remain unassigned. Defaults to 5 minutes.
        """
        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[_builtins.int]]):
        pulumi.set(self, "scheduled_rebalance_max_delay_ms", value)

    @_builtins.property
    @pulumi.getter(name="sessionTimeoutMs")
    def session_timeout_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The timeout in milliseconds used to detect failures when using Kafka’s group management facilities (defaults to 10000).
        """
        return pulumi.get(self, "session_timeout_ms")

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


if not MYPY:
    class KafkaKafkaUserConfigKafkaConnectPluginVersionArgsDict(TypedDict):
        plugin_name: pulumi.Input[_builtins.str]
        """
        The name of the plugin. Example: `debezium-connector`.
        """
        version: pulumi.Input[_builtins.str]
        """
        The version of the plugin. Example: `2.5.0`.
        """
elif False:
    KafkaKafkaUserConfigKafkaConnectPluginVersionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigKafkaConnectPluginVersionArgs:
    def __init__(__self__, *,
                 plugin_name: pulumi.Input[_builtins.str],
                 version: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] plugin_name: The name of the plugin. Example: `debezium-connector`.
        :param pulumi.Input[_builtins.str] version: The version of the plugin. Example: `2.5.0`.
        """
        pulumi.set(__self__, "plugin_name", plugin_name)
        pulumi.set(__self__, "version", version)

    @_builtins.property
    @pulumi.getter(name="pluginName")
    def plugin_name(self) -> pulumi.Input[_builtins.str]:
        """
        The name of the plugin. Example: `debezium-connector`.
        """
        return pulumi.get(self, "plugin_name")

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

    @_builtins.property
    @pulumi.getter
    def version(self) -> pulumi.Input[_builtins.str]:
        """
        The version of the plugin. Example: `2.5.0`.
        """
        return pulumi.get(self, "version")

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


if not MYPY:
    class KafkaKafkaUserConfigKafkaConnectSecretProviderArgsDict(TypedDict):
        name: pulumi.Input[_builtins.str]
        """
        Name of the secret provider. Used to reference secrets in connector config.
        """
        aws: NotRequired[pulumi.Input['KafkaKafkaUserConfigKafkaConnectSecretProviderAwsArgsDict']]
        """
        AWS secret provider configuration
        """
        vault: NotRequired[pulumi.Input['KafkaKafkaUserConfigKafkaConnectSecretProviderVaultArgsDict']]
        """
        Vault secret provider configuration
        """
elif False:
    KafkaKafkaUserConfigKafkaConnectSecretProviderArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigKafkaConnectSecretProviderArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[_builtins.str],
                 aws: Optional[pulumi.Input['KafkaKafkaUserConfigKafkaConnectSecretProviderAwsArgs']] = None,
                 vault: Optional[pulumi.Input['KafkaKafkaUserConfigKafkaConnectSecretProviderVaultArgs']] = None):
        """
        :param pulumi.Input[_builtins.str] name: Name of the secret provider. Used to reference secrets in connector config.
        :param pulumi.Input['KafkaKafkaUserConfigKafkaConnectSecretProviderAwsArgs'] aws: AWS secret provider configuration
        :param pulumi.Input['KafkaKafkaUserConfigKafkaConnectSecretProviderVaultArgs'] vault: Vault secret provider configuration
        """
        pulumi.set(__self__, "name", name)
        if aws is not None:
            pulumi.set(__self__, "aws", aws)
        if vault is not None:
            pulumi.set(__self__, "vault", vault)

    @_builtins.property
    @pulumi.getter
    def name(self) -> pulumi.Input[_builtins.str]:
        """
        Name of the secret provider. Used to reference secrets in connector config.
        """
        return pulumi.get(self, "name")

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

    @_builtins.property
    @pulumi.getter
    def aws(self) -> Optional[pulumi.Input['KafkaKafkaUserConfigKafkaConnectSecretProviderAwsArgs']]:
        """
        AWS secret provider configuration
        """
        return pulumi.get(self, "aws")

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

    @_builtins.property
    @pulumi.getter
    def vault(self) -> Optional[pulumi.Input['KafkaKafkaUserConfigKafkaConnectSecretProviderVaultArgs']]:
        """
        Vault secret provider configuration
        """
        return pulumi.get(self, "vault")

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


if not MYPY:
    class KafkaKafkaUserConfigKafkaConnectSecretProviderAwsArgsDict(TypedDict):
        auth_method: pulumi.Input[_builtins.str]
        """
        Enum: `credentials`. Auth method of the vault secret provider.
        """
        region: pulumi.Input[_builtins.str]
        """
        Region used to lookup secrets with AWS SecretManager.
        """
        access_key: NotRequired[pulumi.Input[_builtins.str]]
        """
        Access key used to authenticate with aws.
        """
        secret_key: NotRequired[pulumi.Input[_builtins.str]]
        """
        Secret key used to authenticate with aws.
        """
elif False:
    KafkaKafkaUserConfigKafkaConnectSecretProviderAwsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigKafkaConnectSecretProviderAwsArgs:
    def __init__(__self__, *,
                 auth_method: pulumi.Input[_builtins.str],
                 region: pulumi.Input[_builtins.str],
                 access_key: Optional[pulumi.Input[_builtins.str]] = None,
                 secret_key: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] auth_method: Enum: `credentials`. Auth method of the vault secret provider.
        :param pulumi.Input[_builtins.str] region: Region used to lookup secrets with AWS SecretManager.
        :param pulumi.Input[_builtins.str] access_key: Access key used to authenticate with aws.
        :param pulumi.Input[_builtins.str] secret_key: Secret key used to authenticate with aws.
        """
        pulumi.set(__self__, "auth_method", auth_method)
        pulumi.set(__self__, "region", region)
        if access_key is not None:
            pulumi.set(__self__, "access_key", access_key)
        if secret_key is not None:
            pulumi.set(__self__, "secret_key", secret_key)

    @_builtins.property
    @pulumi.getter(name="authMethod")
    def auth_method(self) -> pulumi.Input[_builtins.str]:
        """
        Enum: `credentials`. Auth method of the vault secret provider.
        """
        return pulumi.get(self, "auth_method")

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

    @_builtins.property
    @pulumi.getter
    def region(self) -> pulumi.Input[_builtins.str]:
        """
        Region used to lookup secrets with AWS SecretManager.
        """
        return pulumi.get(self, "region")

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

    @_builtins.property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Access key used to authenticate with aws.
        """
        return pulumi.get(self, "access_key")

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

    @_builtins.property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Secret key used to authenticate with aws.
        """
        return pulumi.get(self, "secret_key")

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


if not MYPY:
    class KafkaKafkaUserConfigKafkaConnectSecretProviderVaultArgsDict(TypedDict):
        address: pulumi.Input[_builtins.str]
        """
        Address of the Vault server.
        """
        auth_method: pulumi.Input[_builtins.str]
        """
        Enum: `token`. Auth method of the vault secret provider.
        """
        engine_version: NotRequired[pulumi.Input[_builtins.int]]
        """
        Enum: `1`, `2`, and newer. KV Secrets Engine version of the Vault server instance.
        """
        prefix_path_depth: NotRequired[pulumi.Input[_builtins.int]]
        """
        Prefix path depth of the secrets Engine. Default is 1. If the secrets engine path has more than one segment it has to be increased to the number of segments.
        """
        token: NotRequired[pulumi.Input[_builtins.str]]
        """
        Token used to authenticate with vault and auth method `token`.
        """
elif False:
    KafkaKafkaUserConfigKafkaConnectSecretProviderVaultArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigKafkaConnectSecretProviderVaultArgs:
    def __init__(__self__, *,
                 address: pulumi.Input[_builtins.str],
                 auth_method: pulumi.Input[_builtins.str],
                 engine_version: Optional[pulumi.Input[_builtins.int]] = None,
                 prefix_path_depth: Optional[pulumi.Input[_builtins.int]] = None,
                 token: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] address: Address of the Vault server.
        :param pulumi.Input[_builtins.str] auth_method: Enum: `token`. Auth method of the vault secret provider.
        :param pulumi.Input[_builtins.int] engine_version: Enum: `1`, `2`, and newer. KV Secrets Engine version of the Vault server instance.
        :param pulumi.Input[_builtins.int] prefix_path_depth: Prefix path depth of the secrets Engine. Default is 1. If the secrets engine path has more than one segment it has to be increased to the number of segments.
        :param pulumi.Input[_builtins.str] token: Token used to authenticate with vault and auth method `token`.
        """
        pulumi.set(__self__, "address", address)
        pulumi.set(__self__, "auth_method", auth_method)
        if engine_version is not None:
            pulumi.set(__self__, "engine_version", engine_version)
        if prefix_path_depth is not None:
            pulumi.set(__self__, "prefix_path_depth", prefix_path_depth)
        if token is not None:
            pulumi.set(__self__, "token", token)

    @_builtins.property
    @pulumi.getter
    def address(self) -> pulumi.Input[_builtins.str]:
        """
        Address of the Vault server.
        """
        return pulumi.get(self, "address")

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

    @_builtins.property
    @pulumi.getter(name="authMethod")
    def auth_method(self) -> pulumi.Input[_builtins.str]:
        """
        Enum: `token`. Auth method of the vault secret provider.
        """
        return pulumi.get(self, "auth_method")

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

    @_builtins.property
    @pulumi.getter(name="engineVersion")
    def engine_version(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Enum: `1`, `2`, and newer. KV Secrets Engine version of the Vault server instance.
        """
        return pulumi.get(self, "engine_version")

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

    @_builtins.property
    @pulumi.getter(name="prefixPathDepth")
    def prefix_path_depth(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Prefix path depth of the secrets Engine. Default is 1. If the secrets engine path has more than one segment it has to be increased to the number of segments.
        """
        return pulumi.get(self, "prefix_path_depth")

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

    @_builtins.property
    @pulumi.getter
    def token(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Token used to authenticate with vault and auth method `token`.
        """
        return pulumi.get(self, "token")

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


if not MYPY:
    class KafkaKafkaUserConfigKafkaDisklessArgsDict(TypedDict):
        enabled: pulumi.Input[_builtins.bool]
        """
        Whether to enable the Diskless functionality.
        """
elif False:
    KafkaKafkaUserConfigKafkaDisklessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigKafkaDisklessArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[_builtins.bool]):
        """
        :param pulumi.Input[_builtins.bool] enabled: Whether to enable the Diskless functionality.
        """
        pulumi.set(__self__, "enabled", enabled)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> pulumi.Input[_builtins.bool]:
        """
        Whether to enable the Diskless functionality.
        """
        return pulumi.get(self, "enabled")

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


if not MYPY:
    class KafkaKafkaUserConfigKafkaRestConfigArgsDict(TypedDict):
        consumer_enable_auto_commit: NotRequired[pulumi.Input[_builtins.bool]]
        """
        If true the consumer's offset will be periodically committed to Kafka in the background. Default: `true`.
        """
        consumer_idle_disconnect_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the maximum duration (in seconds) a client can remain idle before it is deleted. If a consumer is inactive, it will exit the consumer group, and its state will be discarded. A value of 0 (default) indicates that the consumer will not be disconnected automatically due to inactivity. Default: `0`.
        """
        consumer_request_max_bytes: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum number of bytes in unencoded message keys and values by a single request.
        """
        consumer_request_timeout_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        Enum: `1000`, `15000`, `30000`. The maximum total time to wait for messages for a request if the maximum number of messages has not yet been reached. Default: `1000`.
        """
        name_strategy: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `record_name`, `topic_name`, `topic_record_name`. Name strategy to use when selecting subject for storing schemas. Default: `topic_name`.
        """
        name_strategy_validation: NotRequired[pulumi.Input[_builtins.bool]]
        """
        If true, validate that given schema is registered under expected subject name by the used name strategy when producing messages. Default: `true`.
        """
        producer_acks: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `-1`, `0`, `1`, `all`. The number of acknowledgments the producer requires the leader to have received before considering a request complete. If set to `all` or `-1`, the leader will wait for the full set of in-sync replicas to acknowledge the record. Default: `1`.
        """
        producer_compression_type: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
        """
        producer_linger_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        Wait for up to the given delay to allow batching records together. Default: `0`.
        """
        producer_max_request_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum size of a request in bytes. Note that Kafka broker can also cap the record batch size.
        """
        simpleconsumer_pool_size_max: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum number of SimpleConsumers that can be instantiated per broker. Default: `25`.
        """
elif False:
    KafkaKafkaUserConfigKafkaRestConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigKafkaRestConfigArgs:
    def __init__(__self__, *,
                 consumer_enable_auto_commit: Optional[pulumi.Input[_builtins.bool]] = None,
                 consumer_idle_disconnect_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 consumer_request_max_bytes: Optional[pulumi.Input[_builtins.int]] = None,
                 consumer_request_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 name_strategy: Optional[pulumi.Input[_builtins.str]] = None,
                 name_strategy_validation: Optional[pulumi.Input[_builtins.bool]] = None,
                 producer_acks: Optional[pulumi.Input[_builtins.str]] = None,
                 producer_compression_type: Optional[pulumi.Input[_builtins.str]] = None,
                 producer_linger_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_max_request_size: Optional[pulumi.Input[_builtins.int]] = None,
                 simpleconsumer_pool_size_max: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.bool] consumer_enable_auto_commit: If true the consumer's offset will be periodically committed to Kafka in the background. Default: `true`.
        :param pulumi.Input[_builtins.int] consumer_idle_disconnect_timeout: Specifies the maximum duration (in seconds) a client can remain idle before it is deleted. If a consumer is inactive, it will exit the consumer group, and its state will be discarded. A value of 0 (default) indicates that the consumer will not be disconnected automatically due to inactivity. Default: `0`.
        :param pulumi.Input[_builtins.int] consumer_request_max_bytes: Maximum number of bytes in unencoded message keys and values by a single request.
        :param pulumi.Input[_builtins.int] consumer_request_timeout_ms: Enum: `1000`, `15000`, `30000`. The maximum total time to wait for messages for a request if the maximum number of messages has not yet been reached. Default: `1000`.
        :param pulumi.Input[_builtins.str] name_strategy: Enum: `record_name`, `topic_name`, `topic_record_name`. Name strategy to use when selecting subject for storing schemas. Default: `topic_name`.
        :param pulumi.Input[_builtins.bool] name_strategy_validation: If true, validate that given schema is registered under expected subject name by the used name strategy when producing messages. Default: `true`.
        :param pulumi.Input[_builtins.str] producer_acks: Enum: `-1`, `0`, `1`, `all`. The number of acknowledgments the producer requires the leader to have received before considering a request complete. If set to `all` or `-1`, the leader will wait for the full set of in-sync replicas to acknowledge the record. Default: `1`.
        :param pulumi.Input[_builtins.str] producer_compression_type: Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
        :param pulumi.Input[_builtins.int] producer_linger_ms: Wait for up to the given delay to allow batching records together. Default: `0`.
        :param pulumi.Input[_builtins.int] producer_max_request_size: The maximum size of a request in bytes. Note that Kafka broker can also cap the record batch size.
        :param pulumi.Input[_builtins.int] simpleconsumer_pool_size_max: Maximum number of SimpleConsumers that can be instantiated per broker. Default: `25`.
        """
        if consumer_enable_auto_commit is not None:
            pulumi.set(__self__, "consumer_enable_auto_commit", consumer_enable_auto_commit)
        if consumer_idle_disconnect_timeout is not None:
            pulumi.set(__self__, "consumer_idle_disconnect_timeout", consumer_idle_disconnect_timeout)
        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 name_strategy is not None:
            pulumi.set(__self__, "name_strategy", name_strategy)
        if name_strategy_validation is not None:
            pulumi.set(__self__, "name_strategy_validation", name_strategy_validation)
        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)

    @_builtins.property
    @pulumi.getter(name="consumerEnableAutoCommit")
    def consumer_enable_auto_commit(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        If true the consumer's offset will be periodically committed to Kafka in the background. Default: `true`.
        """
        return pulumi.get(self, "consumer_enable_auto_commit")

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

    @_builtins.property
    @pulumi.getter(name="consumerIdleDisconnectTimeout")
    def consumer_idle_disconnect_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the maximum duration (in seconds) a client can remain idle before it is deleted. If a consumer is inactive, it will exit the consumer group, and its state will be discarded. A value of 0 (default) indicates that the consumer will not be disconnected automatically due to inactivity. Default: `0`.
        """
        return pulumi.get(self, "consumer_idle_disconnect_timeout")

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

    @_builtins.property
    @pulumi.getter(name="consumerRequestMaxBytes")
    def consumer_request_max_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum number of bytes in unencoded message keys and values by a single request.
        """
        return pulumi.get(self, "consumer_request_max_bytes")

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

    @_builtins.property
    @pulumi.getter(name="consumerRequestTimeoutMs")
    def consumer_request_timeout_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Enum: `1000`, `15000`, `30000`. The maximum total time to wait for messages for a request if the maximum number of messages has not yet been reached. Default: `1000`.
        """
        return pulumi.get(self, "consumer_request_timeout_ms")

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

    @_builtins.property
    @pulumi.getter(name="nameStrategy")
    def name_strategy(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `record_name`, `topic_name`, `topic_record_name`. Name strategy to use when selecting subject for storing schemas. Default: `topic_name`.
        """
        return pulumi.get(self, "name_strategy")

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

    @_builtins.property
    @pulumi.getter(name="nameStrategyValidation")
    def name_strategy_validation(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        If true, validate that given schema is registered under expected subject name by the used name strategy when producing messages. Default: `true`.
        """
        return pulumi.get(self, "name_strategy_validation")

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

    @_builtins.property
    @pulumi.getter(name="producerAcks")
    def producer_acks(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `-1`, `0`, `1`, `all`. The number of acknowledgments the producer requires the leader to have received before considering a request complete. If set to `all` or `-1`, the leader will wait for the full set of in-sync replicas to acknowledge the record. Default: `1`.
        """
        return pulumi.get(self, "producer_acks")

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

    @_builtins.property
    @pulumi.getter(name="producerCompressionType")
    def producer_compression_type(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
        """
        return pulumi.get(self, "producer_compression_type")

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

    @_builtins.property
    @pulumi.getter(name="producerLingerMs")
    def producer_linger_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Wait for up to the given delay to allow batching records together. Default: `0`.
        """
        return pulumi.get(self, "producer_linger_ms")

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

    @_builtins.property
    @pulumi.getter(name="producerMaxRequestSize")
    def producer_max_request_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum size of a request in bytes. Note that Kafka broker can also cap the record batch size.
        """
        return pulumi.get(self, "producer_max_request_size")

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

    @_builtins.property
    @pulumi.getter(name="simpleconsumerPoolSizeMax")
    def simpleconsumer_pool_size_max(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum number of SimpleConsumers that can be instantiated per broker. Default: `25`.
        """
        return pulumi.get(self, "simpleconsumer_pool_size_max")

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


if not MYPY:
    class KafkaKafkaUserConfigKafkaSaslMechanismsArgsDict(TypedDict):
        plain: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable PLAIN mechanism. Default: `true`.
        """
        scram_sha256: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable SCRAM-SHA-256 mechanism. Default: `true`.
        """
        scram_sha512: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable SCRAM-SHA-512 mechanism. Default: `true`.
        """
elif False:
    KafkaKafkaUserConfigKafkaSaslMechanismsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigKafkaSaslMechanismsArgs:
    def __init__(__self__, *,
                 plain: Optional[pulumi.Input[_builtins.bool]] = None,
                 scram_sha256: Optional[pulumi.Input[_builtins.bool]] = None,
                 scram_sha512: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] plain: Enable PLAIN mechanism. Default: `true`.
        :param pulumi.Input[_builtins.bool] scram_sha256: Enable SCRAM-SHA-256 mechanism. Default: `true`.
        :param pulumi.Input[_builtins.bool] scram_sha512: Enable SCRAM-SHA-512 mechanism. Default: `true`.
        """
        if plain is not None:
            pulumi.set(__self__, "plain", plain)
        if scram_sha256 is not None:
            pulumi.set(__self__, "scram_sha256", scram_sha256)
        if scram_sha512 is not None:
            pulumi.set(__self__, "scram_sha512", scram_sha512)

    @_builtins.property
    @pulumi.getter
    def plain(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable PLAIN mechanism. Default: `true`.
        """
        return pulumi.get(self, "plain")

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

    @_builtins.property
    @pulumi.getter(name="scramSha256")
    def scram_sha256(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable SCRAM-SHA-256 mechanism. Default: `true`.
        """
        return pulumi.get(self, "scram_sha256")

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

    @_builtins.property
    @pulumi.getter(name="scramSha512")
    def scram_sha512(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable SCRAM-SHA-512 mechanism. Default: `true`.
        """
        return pulumi.get(self, "scram_sha512")

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


if not MYPY:
    class KafkaKafkaUserConfigPrivateAccessArgsDict(TypedDict):
        kafka: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to kafka with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        kafka_connect: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to kafka_connect with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        kafka_rest: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to kafka_rest with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        schema_registry: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to schema_registry with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
elif False:
    KafkaKafkaUserConfigPrivateAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 kafka: Optional[pulumi.Input[_builtins.bool]] = None,
                 kafka_connect: Optional[pulumi.Input[_builtins.bool]] = None,
                 kafka_rest: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None,
                 schema_registry: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] kafka: Allow clients to connect to kafka with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] kafka_connect: Allow clients to connect to kafka_connect with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] kafka_rest: Allow clients to connect to kafka_rest with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] schema_registry: Allow clients to connect to schema_registry with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        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)

    @_builtins.property
    @pulumi.getter
    def kafka(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to kafka with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "kafka")

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

    @_builtins.property
    @pulumi.getter(name="kafkaConnect")
    def kafka_connect(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to kafka_connect with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "kafka_connect")

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

    @_builtins.property
    @pulumi.getter(name="kafkaRest")
    def kafka_rest(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to kafka_rest with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "kafka_rest")

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

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "prometheus")

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

    @_builtins.property
    @pulumi.getter(name="schemaRegistry")
    def schema_registry(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to schema_registry with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "schema_registry")

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


if not MYPY:
    class KafkaKafkaUserConfigPrivatelinkAccessArgsDict(TypedDict):
        jolokia: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable jolokia.
        """
        kafka: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable kafka.
        """
        kafka_connect: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable kafka_connect.
        """
        kafka_rest: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable kafka_rest.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable prometheus.
        """
        schema_registry: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable schema_registry.
        """
elif False:
    KafkaKafkaUserConfigPrivatelinkAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 jolokia: Optional[pulumi.Input[_builtins.bool]] = None,
                 kafka: Optional[pulumi.Input[_builtins.bool]] = None,
                 kafka_connect: Optional[pulumi.Input[_builtins.bool]] = None,
                 kafka_rest: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None,
                 schema_registry: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] jolokia: Enable jolokia.
        :param pulumi.Input[_builtins.bool] kafka: Enable kafka.
        :param pulumi.Input[_builtins.bool] kafka_connect: Enable kafka_connect.
        :param pulumi.Input[_builtins.bool] kafka_rest: Enable kafka_rest.
        :param pulumi.Input[_builtins.bool] prometheus: Enable prometheus.
        :param pulumi.Input[_builtins.bool] schema_registry: Enable schema_registry.
        """
        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)

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

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

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

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

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

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

    @_builtins.property
    @pulumi.getter(name="kafkaRest")
    def kafka_rest(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable kafka_rest.
        """
        return pulumi.get(self, "kafka_rest")

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

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

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

    @_builtins.property
    @pulumi.getter(name="schemaRegistry")
    def schema_registry(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable schema_registry.
        """
        return pulumi.get(self, "schema_registry")

    @schema_registry.setter
    def schema_registry(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "schema_registry", value)


if not MYPY:
    class KafkaKafkaUserConfigPublicAccessArgsDict(TypedDict):
        kafka: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to kafka from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        kafka_connect: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to kafka_connect from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        kafka_rest: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to kafka_rest from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        schema_registry: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to schema_registry from the public internet for service nodes that are in a project VPC or another type of private network.
        """
elif False:
    KafkaKafkaUserConfigPublicAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 kafka: Optional[pulumi.Input[_builtins.bool]] = None,
                 kafka_connect: Optional[pulumi.Input[_builtins.bool]] = None,
                 kafka_rest: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None,
                 schema_registry: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] kafka: Allow clients to connect to kafka from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] kafka_connect: Allow clients to connect to kafka_connect from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] kafka_rest: Allow clients to connect to kafka_rest from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] schema_registry: Allow clients to connect to schema_registry from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        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)

    @_builtins.property
    @pulumi.getter
    def kafka(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to kafka from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "kafka")

    @kafka.setter
    def kafka(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "kafka", value)

    @_builtins.property
    @pulumi.getter(name="kafkaConnect")
    def kafka_connect(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to kafka_connect from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "kafka_connect")

    @kafka_connect.setter
    def kafka_connect(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "kafka_connect", value)

    @_builtins.property
    @pulumi.getter(name="kafkaRest")
    def kafka_rest(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to kafka_rest from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "kafka_rest")

    @kafka_rest.setter
    def kafka_rest(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "kafka_rest", value)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "prometheus", value)

    @_builtins.property
    @pulumi.getter(name="schemaRegistry")
    def schema_registry(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to schema_registry from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "schema_registry")

    @schema_registry.setter
    def schema_registry(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "schema_registry", value)


if not MYPY:
    class KafkaKafkaUserConfigSchemaRegistryConfigArgsDict(TypedDict):
        leader_eligibility: NotRequired[pulumi.Input[_builtins.bool]]
        """
        If true, Karapace / Schema Registry on the service nodes can participate in leader election. It might be needed to disable this when the schemas topic is replicated to a secondary cluster and Karapace / Schema Registry there must not participate in leader election. Defaults to `true`.
        """
        retriable_errors_silenced: NotRequired[pulumi.Input[_builtins.bool]]
        """
        If enabled, kafka errors which can be retried or custom errors specified for the service will not be raised, instead, a warning log is emitted. This will denoise issue tracking systems, i.e. sentry. Defaults to `true`.
        """
        schema_reader_strict_mode: NotRequired[pulumi.Input[_builtins.bool]]
        """
        If enabled, causes the Karapace schema-registry service to shutdown when there are invalid schema records in the `_schemas` topic. Defaults to `false`.
        """
        topic_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        The durable single partition topic that acts as the durable log for the data. This topic must be compacted to avoid losing data due to retention policy. Please note that changing this configuration in an existing Schema Registry / Karapace setup leads to previous schemas being inaccessible, data encoded with them potentially unreadable and schema ID sequence put out of order. It's only possible to do the switch while Schema Registry / Karapace is disabled. Defaults to `_schemas`.
        """
elif False:
    KafkaKafkaUserConfigSchemaRegistryConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigSchemaRegistryConfigArgs:
    def __init__(__self__, *,
                 leader_eligibility: Optional[pulumi.Input[_builtins.bool]] = None,
                 retriable_errors_silenced: Optional[pulumi.Input[_builtins.bool]] = None,
                 schema_reader_strict_mode: Optional[pulumi.Input[_builtins.bool]] = None,
                 topic_name: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.bool] leader_eligibility: If true, Karapace / Schema Registry on the service nodes can participate in leader election. It might be needed to disable this when the schemas topic is replicated to a secondary cluster and Karapace / Schema Registry there must not participate in leader election. Defaults to `true`.
        :param pulumi.Input[_builtins.bool] retriable_errors_silenced: If enabled, kafka errors which can be retried or custom errors specified for the service will not be raised, instead, a warning log is emitted. This will denoise issue tracking systems, i.e. sentry. Defaults to `true`.
        :param pulumi.Input[_builtins.bool] schema_reader_strict_mode: If enabled, causes the Karapace schema-registry service to shutdown when there are invalid schema records in the `_schemas` topic. Defaults to `false`.
        :param pulumi.Input[_builtins.str] topic_name: The durable single partition topic that acts as the durable log for the data. This topic must be compacted to avoid losing data due to retention policy. Please note that changing this configuration in an existing Schema Registry / Karapace setup leads to previous schemas being inaccessible, data encoded with them potentially unreadable and schema ID sequence put out of order. It's only possible to do the switch while Schema Registry / Karapace is disabled. Defaults to `_schemas`.
        """
        if leader_eligibility is not None:
            pulumi.set(__self__, "leader_eligibility", leader_eligibility)
        if retriable_errors_silenced is not None:
            pulumi.set(__self__, "retriable_errors_silenced", retriable_errors_silenced)
        if schema_reader_strict_mode is not None:
            pulumi.set(__self__, "schema_reader_strict_mode", schema_reader_strict_mode)
        if topic_name is not None:
            pulumi.set(__self__, "topic_name", topic_name)

    @_builtins.property
    @pulumi.getter(name="leaderEligibility")
    def leader_eligibility(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        If true, Karapace / Schema Registry on the service nodes can participate in leader election. It might be needed to disable this when the schemas topic is replicated to a secondary cluster and Karapace / Schema Registry there must not participate in leader election. Defaults to `true`.
        """
        return pulumi.get(self, "leader_eligibility")

    @leader_eligibility.setter
    def leader_eligibility(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "leader_eligibility", value)

    @_builtins.property
    @pulumi.getter(name="retriableErrorsSilenced")
    def retriable_errors_silenced(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        If enabled, kafka errors which can be retried or custom errors specified for the service will not be raised, instead, a warning log is emitted. This will denoise issue tracking systems, i.e. sentry. Defaults to `true`.
        """
        return pulumi.get(self, "retriable_errors_silenced")

    @retriable_errors_silenced.setter
    def retriable_errors_silenced(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "retriable_errors_silenced", value)

    @_builtins.property
    @pulumi.getter(name="schemaReaderStrictMode")
    def schema_reader_strict_mode(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        If enabled, causes the Karapace schema-registry service to shutdown when there are invalid schema records in the `_schemas` topic. Defaults to `false`.
        """
        return pulumi.get(self, "schema_reader_strict_mode")

    @schema_reader_strict_mode.setter
    def schema_reader_strict_mode(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "schema_reader_strict_mode", value)

    @_builtins.property
    @pulumi.getter(name="topicName")
    def topic_name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The durable single partition topic that acts as the durable log for the data. This topic must be compacted to avoid losing data due to retention policy. Please note that changing this configuration in an existing Schema Registry / Karapace setup leads to previous schemas being inaccessible, data encoded with them potentially unreadable and schema ID sequence put out of order. It's only possible to do the switch while Schema Registry / Karapace is disabled. Defaults to `_schemas`.
        """
        return pulumi.get(self, "topic_name")

    @topic_name.setter
    def topic_name(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "topic_name", value)


if not MYPY:
    class KafkaKafkaUserConfigSingleZoneArgsDict(TypedDict):
        availability_zone: NotRequired[pulumi.Input[_builtins.str]]
        """
        The availability zone to use for the service. This is only used when enabled is set to true. If not set the service will be allocated in random AZ.The AZ is not guaranteed, and the service may be allocated in a different AZ if the selected AZ is not available. Zones will not be validated and invalid zones will be ignored, falling back to random AZ selection. Common availability zones include: AWS (euc1-az1, euc1-az2, euc1-az3), GCP (europe-west1-a, europe-west1-b, europe-west1-c), Azure (germanywestcentral/1, germanywestcentral/2, germanywestcentral/3). Example: `euc1-az1`.
        """
        enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether to allocate nodes on the same Availability Zone or spread across zones available. By default service nodes are spread across different AZs. The single AZ support is best-effort and may temporarily allocate nodes in different AZs e.g. in case of capacity limitations in one AZ.
        """
elif False:
    KafkaKafkaUserConfigSingleZoneArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigSingleZoneArgs:
    def __init__(__self__, *,
                 availability_zone: Optional[pulumi.Input[_builtins.str]] = None,
                 enabled: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] availability_zone: The availability zone to use for the service. This is only used when enabled is set to true. If not set the service will be allocated in random AZ.The AZ is not guaranteed, and the service may be allocated in a different AZ if the selected AZ is not available. Zones will not be validated and invalid zones will be ignored, falling back to random AZ selection. Common availability zones include: AWS (euc1-az1, euc1-az2, euc1-az3), GCP (europe-west1-a, europe-west1-b, europe-west1-c), Azure (germanywestcentral/1, germanywestcentral/2, germanywestcentral/3). Example: `euc1-az1`.
        :param pulumi.Input[_builtins.bool] enabled: Whether to allocate nodes on the same Availability Zone or spread across zones available. By default service nodes are spread across different AZs. The single AZ support is best-effort and may temporarily allocate nodes in different AZs e.g. in case of capacity limitations in one AZ.
        """
        if availability_zone is not None:
            pulumi.set(__self__, "availability_zone", availability_zone)
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)

    @_builtins.property
    @pulumi.getter(name="availabilityZone")
    def availability_zone(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The availability zone to use for the service. This is only used when enabled is set to true. If not set the service will be allocated in random AZ.The AZ is not guaranteed, and the service may be allocated in a different AZ if the selected AZ is not available. Zones will not be validated and invalid zones will be ignored, falling back to random AZ selection. Common availability zones include: AWS (euc1-az1, euc1-az2, euc1-az3), GCP (europe-west1-a, europe-west1-b, europe-west1-c), Azure (germanywestcentral/1, germanywestcentral/2, germanywestcentral/3). Example: `euc1-az1`.
        """
        return pulumi.get(self, "availability_zone")

    @availability_zone.setter
    def availability_zone(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "availability_zone", value)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether to allocate nodes on the same Availability Zone or spread across zones available. By default service nodes are spread across different AZs. The single AZ support is best-effort and may temporarily allocate nodes in different AZs e.g. in case of capacity limitations in one AZ.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "enabled", value)


if not MYPY:
    class KafkaKafkaUserConfigTieredStorageArgsDict(TypedDict):
        enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether to enable the tiered storage functionality.
        """
        local_cache: NotRequired[pulumi.Input['KafkaKafkaUserConfigTieredStorageLocalCacheArgsDict']]
        """
        Local cache configuration
        """
elif False:
    KafkaKafkaUserConfigTieredStorageArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigTieredStorageArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 local_cache: Optional[pulumi.Input['KafkaKafkaUserConfigTieredStorageLocalCacheArgs']] = None):
        """
        :param pulumi.Input[_builtins.bool] enabled: Whether to enable the tiered storage functionality.
        :param pulumi.Input['KafkaKafkaUserConfigTieredStorageLocalCacheArgs'] local_cache: Local cache configuration
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if local_cache is not None:
            warnings.warn("""This property is deprecated.""", DeprecationWarning)
            pulumi.log.warn("""local_cache is deprecated: This property is deprecated.""")
        if local_cache is not None:
            pulumi.set(__self__, "local_cache", local_cache)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether to enable the tiered storage functionality.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "enabled", value)

    @_builtins.property
    @pulumi.getter(name="localCache")
    @_utilities.deprecated("""This property is deprecated.""")
    def local_cache(self) -> Optional[pulumi.Input['KafkaKafkaUserConfigTieredStorageLocalCacheArgs']]:
        """
        Local cache configuration
        """
        return pulumi.get(self, "local_cache")

    @local_cache.setter
    def local_cache(self, value: Optional[pulumi.Input['KafkaKafkaUserConfigTieredStorageLocalCacheArgs']]):
        pulumi.set(self, "local_cache", value)


if not MYPY:
    class KafkaKafkaUserConfigTieredStorageLocalCacheArgsDict(TypedDict):
        size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Local cache size in bytes. Example: `1073741824`.
        """
elif False:
    KafkaKafkaUserConfigTieredStorageLocalCacheArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaKafkaUserConfigTieredStorageLocalCacheArgs:
    def __init__(__self__, *,
                 size: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.int] size: Local cache size in bytes. Example: `1073741824`.
        """
        if size is not None:
            warnings.warn("""This property is deprecated.""", DeprecationWarning)
            pulumi.log.warn("""size is deprecated: This property is deprecated.""")
        if size is not None:
            pulumi.set(__self__, "size", size)

    @_builtins.property
    @pulumi.getter
    @_utilities.deprecated("""This property is deprecated.""")
    def size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Local cache size in bytes. Example: `1073741824`.
        """
        return pulumi.get(self, "size")

    @size.setter
    def size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "size", value)


if not MYPY:
    class KafkaMirrorMakerComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    KafkaMirrorMakerComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaMirrorMakerComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

    @_builtins.property
    @pulumi.getter
    def component(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Service component name
        """
        return pulumi.get(self, "component")

    @component.setter
    def component(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "component", value)

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

    @connection_uri.setter
    def connection_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "connection_uri", value)

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_authentication_method", value)

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

    @kafka_ssl_ca.setter
    def kafka_ssl_ca(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_ssl_ca", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def route(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Network access route
        """
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "route", value)

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ssl", value)

    @_builtins.property
    @pulumi.getter
    def usage(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        DNS usage name
        """
        return pulumi.get(self, "usage")

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "usage", value)


if not MYPY:
    class KafkaMirrorMakerKafkaMirrormakerUserConfigArgsDict(TypedDict):
        additional_backup_regions: NotRequired[pulumi.Input[_builtins.str]]
        """
        Additional Cloud Regions for Backup Replication.
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['KafkaMirrorMakerKafkaMirrormakerUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        kafka_mirrormaker: NotRequired[pulumi.Input['KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerArgsDict']]
        """
        Kafka MirrorMaker configuration values
        """
        sasl_oauthbearer_allowed_urls: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        List of allowed URLs for SASL OAUTHBEARER authentication. Only HTTPS URLs are allowed for security reasons.
        """
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
elif False:
    KafkaMirrorMakerKafkaMirrormakerUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaMirrorMakerKafkaMirrormakerUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[_builtins.str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['KafkaMirrorMakerKafkaMirrormakerUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 kafka_mirrormaker: Optional[pulumi.Input['KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerArgs']] = None,
                 sasl_oauthbearer_allowed_urls: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[Sequence[pulumi.Input['KafkaMirrorMakerKafkaMirrormakerUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input['KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerArgs'] kafka_mirrormaker: Kafka MirrorMaker configuration values
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] sasl_oauthbearer_allowed_urls: List of allowed URLs for SASL OAUTHBEARER authentication. Only HTTPS URLs are allowed for security reasons.
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input[_builtins.bool] static_ips: Use static public IP addresses.
        """
        if additional_backup_regions is not None:
            warnings.warn("""This property is deprecated.""", DeprecationWarning)
            pulumi.log.warn("""additional_backup_regions is deprecated: This property is deprecated.""")
        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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `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 sasl_oauthbearer_allowed_urls is not None:
            pulumi.set(__self__, "sasl_oauthbearer_allowed_urls", sasl_oauthbearer_allowed_urls)
        if service_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)

    @_builtins.property
    @pulumi.getter(name="additionalBackupRegions")
    @_utilities.deprecated("""This property is deprecated.""")
    def additional_backup_regions(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['KafkaMirrorMakerKafkaMirrormakerUserConfigIpFilterObjectArgs']]]]:
        """
        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['KafkaMirrorMakerKafkaMirrormakerUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "ip_filters", value)

    @_builtins.property
    @pulumi.getter(name="kafkaMirrormaker")
    def kafka_mirrormaker(self) -> Optional[pulumi.Input['KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerArgs']]:
        """
        Kafka MirrorMaker configuration values
        """
        return pulumi.get(self, "kafka_mirrormaker")

    @kafka_mirrormaker.setter
    def kafka_mirrormaker(self, value: Optional[pulumi.Input['KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerArgs']]):
        pulumi.set(self, "kafka_mirrormaker", value)

    @_builtins.property
    @pulumi.getter(name="saslOauthbearerAllowedUrls")
    def sasl_oauthbearer_allowed_urls(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        List of allowed URLs for SASL OAUTHBEARER authentication. Only HTTPS URLs are allowed for security reasons.
        """
        return pulumi.get(self, "sasl_oauthbearer_allowed_urls")

    @sasl_oauthbearer_allowed_urls.setter
    def sasl_oauthbearer_allowed_urls(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "sasl_oauthbearer_allowed_urls", value)

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

    @service_log.setter
    def service_log(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "service_log", value)

    @_builtins.property
    @pulumi.getter(name="staticIps")
    def static_ips(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Use static public IP addresses.
        """
        return pulumi.get(self, "static_ips")

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "static_ips", value)


if not MYPY:
    class KafkaMirrorMakerKafkaMirrormakerUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    KafkaMirrorMakerKafkaMirrormakerUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaMirrorMakerKafkaMirrormakerUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "network", value)

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "description", value)


if not MYPY:
    class KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerArgsDict(TypedDict):
        admin_timeout_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        Timeout for administrative tasks, e.g. detecting new topics, loading of consumer group and offsets. Defaults to 60000 milliseconds (1 minute).
        """
        emit_checkpoints_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether to emit consumer group offset checkpoints to target cluster periodically (default: true).
        """
        emit_checkpoints_interval_seconds: NotRequired[pulumi.Input[_builtins.int]]
        """
        Frequency at which consumer group offset checkpoints are emitted (default: 60, every minute). Example: `60`.
        """
        groups: NotRequired[pulumi.Input[_builtins.str]]
        """
        Consumer groups to replicate. Supports comma-separated group IDs and regexes. Example: `.*`.
        """
        groups_exclude: NotRequired[pulumi.Input[_builtins.str]]
        """
        Exclude groups. Supports comma-separated group IDs and regexes. Excludes take precedence over includes. Example: `console-consumer-.*,connect-.*,__.*`.
        """
        offset_lag_max: NotRequired[pulumi.Input[_builtins.int]]
        """
        How out-of-sync a remote partition can be before it is resynced. Example: `100`.
        """
        refresh_groups_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether to periodically check for new consumer groups. Defaults to `true`.
        """
        refresh_groups_interval_seconds: NotRequired[pulumi.Input[_builtins.int]]
        """
        Frequency of consumer group refresh in seconds. Defaults to 600 seconds (10 minutes).
        """
        refresh_topics_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether to periodically check for new topics and partitions. Defaults to `true`.
        """
        refresh_topics_interval_seconds: NotRequired[pulumi.Input[_builtins.int]]
        """
        Frequency of topic and partitions refresh in seconds. Defaults to 600 seconds (10 minutes).
        """
        sync_group_offsets_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether to periodically write the translated offsets of replicated consumer groups (in the source cluster) to _*consumer*offsets topic in target cluster, as long as no active consumers in that group are connected to the target cluster.
        """
        sync_group_offsets_interval_seconds: NotRequired[pulumi.Input[_builtins.int]]
        """
        Frequency at which consumer group offsets are synced (default: 60, every minute). Example: `60`.
        """
        sync_topic_configs_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether to periodically configure remote topics to match their corresponding upstream topics.
        """
        tasks_max_per_cpu: NotRequired[pulumi.Input[_builtins.int]]
        """
        `tasks.max` is set to this multiplied by the number of CPUs in the service. Default: `1`.
        """
elif False:
    KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaMirrorMakerKafkaMirrormakerUserConfigKafkaMirrormakerArgs:
    def __init__(__self__, *,
                 admin_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 emit_checkpoints_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 emit_checkpoints_interval_seconds: Optional[pulumi.Input[_builtins.int]] = None,
                 groups: Optional[pulumi.Input[_builtins.str]] = None,
                 groups_exclude: Optional[pulumi.Input[_builtins.str]] = None,
                 offset_lag_max: Optional[pulumi.Input[_builtins.int]] = None,
                 refresh_groups_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 refresh_groups_interval_seconds: Optional[pulumi.Input[_builtins.int]] = None,
                 refresh_topics_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 refresh_topics_interval_seconds: Optional[pulumi.Input[_builtins.int]] = None,
                 sync_group_offsets_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 sync_group_offsets_interval_seconds: Optional[pulumi.Input[_builtins.int]] = None,
                 sync_topic_configs_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 tasks_max_per_cpu: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.int] admin_timeout_ms: Timeout for administrative tasks, e.g. detecting new topics, loading of consumer group and offsets. Defaults to 60000 milliseconds (1 minute).
        :param pulumi.Input[_builtins.bool] emit_checkpoints_enabled: Whether to emit consumer group offset checkpoints to target cluster periodically (default: true).
        :param pulumi.Input[_builtins.int] emit_checkpoints_interval_seconds: Frequency at which consumer group offset checkpoints are emitted (default: 60, every minute). Example: `60`.
        :param pulumi.Input[_builtins.str] groups: Consumer groups to replicate. Supports comma-separated group IDs and regexes. Example: `.*`.
        :param pulumi.Input[_builtins.str] groups_exclude: Exclude groups. Supports comma-separated group IDs and regexes. Excludes take precedence over includes. Example: `console-consumer-.*,connect-.*,__.*`.
        :param pulumi.Input[_builtins.int] offset_lag_max: How out-of-sync a remote partition can be before it is resynced. Example: `100`.
        :param pulumi.Input[_builtins.bool] refresh_groups_enabled: Whether to periodically check for new consumer groups. Defaults to `true`.
        :param pulumi.Input[_builtins.int] refresh_groups_interval_seconds: Frequency of consumer group refresh in seconds. Defaults to 600 seconds (10 minutes).
        :param pulumi.Input[_builtins.bool] refresh_topics_enabled: Whether to periodically check for new topics and partitions. Defaults to `true`.
        :param pulumi.Input[_builtins.int] refresh_topics_interval_seconds: Frequency of topic and partitions refresh in seconds. Defaults to 600 seconds (10 minutes).
        :param pulumi.Input[_builtins.bool] sync_group_offsets_enabled: Whether to periodically write the translated offsets of replicated consumer groups (in the source cluster) to _*consumer*offsets topic in target cluster, as long as no active consumers in that group are connected to the target cluster.
        :param pulumi.Input[_builtins.int] sync_group_offsets_interval_seconds: Frequency at which consumer group offsets are synced (default: 60, every minute). Example: `60`.
        :param pulumi.Input[_builtins.bool] sync_topic_configs_enabled: Whether to periodically configure remote topics to match their corresponding upstream topics.
        :param pulumi.Input[_builtins.int] tasks_max_per_cpu: `tasks.max` is set to this multiplied by the number of CPUs in the service. Default: `1`.
        """
        if admin_timeout_ms is not None:
            pulumi.set(__self__, "admin_timeout_ms", admin_timeout_ms)
        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 groups is not None:
            pulumi.set(__self__, "groups", groups)
        if groups_exclude is not None:
            pulumi.set(__self__, "groups_exclude", groups_exclude)
        if offset_lag_max is not None:
            pulumi.set(__self__, "offset_lag_max", offset_lag_max)
        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)

    @_builtins.property
    @pulumi.getter(name="adminTimeoutMs")
    def admin_timeout_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Timeout for administrative tasks, e.g. detecting new topics, loading of consumer group and offsets. Defaults to 60000 milliseconds (1 minute).
        """
        return pulumi.get(self, "admin_timeout_ms")

    @admin_timeout_ms.setter
    def admin_timeout_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "admin_timeout_ms", value)

    @_builtins.property
    @pulumi.getter(name="emitCheckpointsEnabled")
    def emit_checkpoints_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether to emit consumer group offset checkpoints to target cluster periodically (default: true).
        """
        return pulumi.get(self, "emit_checkpoints_enabled")

    @emit_checkpoints_enabled.setter
    def emit_checkpoints_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "emit_checkpoints_enabled", value)

    @_builtins.property
    @pulumi.getter(name="emitCheckpointsIntervalSeconds")
    def emit_checkpoints_interval_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Frequency at which consumer group offset checkpoints are emitted (default: 60, every minute). Example: `60`.
        """
        return pulumi.get(self, "emit_checkpoints_interval_seconds")

    @emit_checkpoints_interval_seconds.setter
    def emit_checkpoints_interval_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "emit_checkpoints_interval_seconds", value)

    @_builtins.property
    @pulumi.getter
    def groups(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Consumer groups to replicate. Supports comma-separated group IDs and regexes. Example: `.*`.
        """
        return pulumi.get(self, "groups")

    @groups.setter
    def groups(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "groups", value)

    @_builtins.property
    @pulumi.getter(name="groupsExclude")
    def groups_exclude(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Exclude groups. Supports comma-separated group IDs and regexes. Excludes take precedence over includes. Example: `console-consumer-.*,connect-.*,__.*`.
        """
        return pulumi.get(self, "groups_exclude")

    @groups_exclude.setter
    def groups_exclude(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "groups_exclude", value)

    @_builtins.property
    @pulumi.getter(name="offsetLagMax")
    def offset_lag_max(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        How out-of-sync a remote partition can be before it is resynced. Example: `100`.
        """
        return pulumi.get(self, "offset_lag_max")

    @offset_lag_max.setter
    def offset_lag_max(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "offset_lag_max", value)

    @_builtins.property
    @pulumi.getter(name="refreshGroupsEnabled")
    def refresh_groups_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether to periodically check for new consumer groups. Defaults to `true`.
        """
        return pulumi.get(self, "refresh_groups_enabled")

    @refresh_groups_enabled.setter
    def refresh_groups_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "refresh_groups_enabled", value)

    @_builtins.property
    @pulumi.getter(name="refreshGroupsIntervalSeconds")
    def refresh_groups_interval_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Frequency of consumer group refresh in seconds. Defaults to 600 seconds (10 minutes).
        """
        return pulumi.get(self, "refresh_groups_interval_seconds")

    @refresh_groups_interval_seconds.setter
    def refresh_groups_interval_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "refresh_groups_interval_seconds", value)

    @_builtins.property
    @pulumi.getter(name="refreshTopicsEnabled")
    def refresh_topics_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether to periodically check for new topics and partitions. Defaults to `true`.
        """
        return pulumi.get(self, "refresh_topics_enabled")

    @refresh_topics_enabled.setter
    def refresh_topics_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "refresh_topics_enabled", value)

    @_builtins.property
    @pulumi.getter(name="refreshTopicsIntervalSeconds")
    def refresh_topics_interval_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Frequency of topic and partitions refresh in seconds. Defaults to 600 seconds (10 minutes).
        """
        return pulumi.get(self, "refresh_topics_interval_seconds")

    @refresh_topics_interval_seconds.setter
    def refresh_topics_interval_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "refresh_topics_interval_seconds", value)

    @_builtins.property
    @pulumi.getter(name="syncGroupOffsetsEnabled")
    def sync_group_offsets_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether to periodically write the translated offsets of replicated consumer groups (in the source cluster) to _*consumer*offsets topic in target cluster, as long as no active consumers in that group are connected to the target cluster.
        """
        return pulumi.get(self, "sync_group_offsets_enabled")

    @sync_group_offsets_enabled.setter
    def sync_group_offsets_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "sync_group_offsets_enabled", value)

    @_builtins.property
    @pulumi.getter(name="syncGroupOffsetsIntervalSeconds")
    def sync_group_offsets_interval_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Frequency at which consumer group offsets are synced (default: 60, every minute). Example: `60`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "sync_group_offsets_interval_seconds", value)

    @_builtins.property
    @pulumi.getter(name="syncTopicConfigsEnabled")
    def sync_topic_configs_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether to periodically configure remote topics to match their corresponding upstream topics.
        """
        return pulumi.get(self, "sync_topic_configs_enabled")

    @sync_topic_configs_enabled.setter
    def sync_topic_configs_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "sync_topic_configs_enabled", value)

    @_builtins.property
    @pulumi.getter(name="tasksMaxPerCpu")
    def tasks_max_per_cpu(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        `tasks.max` is set to this multiplied by the number of CPUs in the service. Default: `1`.
        """
        return pulumi.get(self, "tasks_max_per_cpu")

    @tasks_max_per_cpu.setter
    def tasks_max_per_cpu(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "tasks_max_per_cpu", value)


if not MYPY:
    class KafkaMirrorMakerServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    KafkaMirrorMakerServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaMirrorMakerServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration
        :param pulumi.Input[_builtins.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)

    @_builtins.property
    @pulumi.getter(name="integrationType")
    def integration_type(self) -> pulumi.Input[_builtins.str]:
        """
        Type of the service integration
        """
        return pulumi.get(self, "integration_type")

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "integration_type", value)

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class KafkaMirrorMakerTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    KafkaMirrorMakerTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaMirrorMakerTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[_builtins.str],
                 value: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] key: Service tag key
        :param pulumi.Input[_builtins.str] value: Service tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def key(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "key", value)

    @_builtins.property
    @pulumi.getter
    def value(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag value
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "value", value)


if not MYPY:
    class KafkaMirrorMakerTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    KafkaMirrorMakerTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaMirrorMakerTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

    @email.setter
    def email(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "email", value)


if not MYPY:
    class KafkaServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    KafkaServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration
        :param pulumi.Input[_builtins.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)

    @_builtins.property
    @pulumi.getter(name="integrationType")
    def integration_type(self) -> pulumi.Input[_builtins.str]:
        """
        Type of the service integration
        """
        return pulumi.get(self, "integration_type")

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "integration_type", value)

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class KafkaTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    KafkaTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[_builtins.str],
                 value: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] key: Service tag key
        :param pulumi.Input[_builtins.str] value: Service tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def key(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "key", value)

    @_builtins.property
    @pulumi.getter
    def value(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag value
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "value", value)


if not MYPY:
    class KafkaTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    KafkaTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

    @email.setter
    def email(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "email", value)


if not MYPY:
    class KafkaTopicConfigArgsDict(TypedDict):
        cleanup_policy: NotRequired[pulumi.Input[_builtins.str]]
        """
        The retention policy to use on old segments. Possible values include 'delete', 'compact', or a comma-separated list of them. The default policy ('delete') will discard old segments when their retention time or size limit has been reached. The 'compact' setting will enable log compaction on the topic. The possible values are `compact`, `compact,delete` and `delete`.
        """
        compression_type: NotRequired[pulumi.Input[_builtins.str]]
        """
        Specify the final compression type for a given topic. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'uncompressed' which is equivalent to no compression; and 'producer' which means retain the original compression codec set by the producer. The possible values are `gzip`, `lz4`, `producer`, `snappy`, `uncompressed` and `zstd`.
        """
        delete_retention_ms: NotRequired[pulumi.Input[_builtins.str]]
        """
        The amount of time to retain delete tombstone markers for log compacted topics. This setting also gives a bound on the time in which a consumer must complete a read if they begin from offset 0 to ensure that they get a valid snapshot of the final stage (otherwise delete tombstones may be collected before they complete their scan).
        """
        diskless_enable: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Creates a [diskless topic](https://aiven.io/docs/products/diskless). You can only do this when you create the topic and you cannot change it later. Diskless topics are only available for bring your own cloud (BYOC) services that have the feature enabled.
        """
        file_delete_delay_ms: NotRequired[pulumi.Input[_builtins.str]]
        """
        The time to wait before deleting a file from the filesystem.
        """
        flush_messages: NotRequired[pulumi.Input[_builtins.str]]
        """
        This setting allows specifying an interval at which we will force an fsync of data written to the log. For example if this was set to 1 we would fsync after every message; if it were 5 we would fsync after every five messages. In general we recommend you not set this and use replication for durability and allow the operating system's background flush capabilities as it is more efficient.
        """
        flush_ms: NotRequired[pulumi.Input[_builtins.str]]
        """
        This setting allows specifying a time interval at which we will force an fsync of data written to the log. For example if this was set to 1000 we would fsync after 1000 ms had passed. In general we recommend you not set this and use replication for durability and allow the operating system's background flush capabilities as it is more efficient.
        """
        index_interval_bytes: NotRequired[pulumi.Input[_builtins.str]]
        """
        This setting controls how frequently Kafka adds an index entry to its offset index. The default setting ensures that we index a message roughly every 4096 bytes. More indexing allows reads to jump closer to the exact position in the log but makes the index larger. You probably don't need to change this.
        """
        local_retention_bytes: NotRequired[pulumi.Input[_builtins.str]]
        """
        This configuration controls the maximum bytes tiered storage will retain segment files locally before it will discard old log segments to free up space. If set to -2, the limit is equal to overall retention time. If set to -1, no limit is applied but it's possible only if overall retention is also -1.
        """
        local_retention_ms: NotRequired[pulumi.Input[_builtins.str]]
        """
        This configuration controls the maximum time tiered storage will retain segment files locally before it will discard old log segments to free up space. If set to -2, the time limit is equal to overall retention time. If set to -1, no time limit is applied but it's possible only if overall retention is also -1.
        """
        max_compaction_lag_ms: NotRequired[pulumi.Input[_builtins.str]]
        """
        The maximum time a message will remain ineligible for compaction in the log. Only applicable for logs that are being compacted.
        """
        max_message_bytes: NotRequired[pulumi.Input[_builtins.str]]
        """
        The largest record batch size allowed by Kafka (after compression if compression is enabled). If this is increased and there are consumers older than 0.10.2, the consumers' fetch size must also be increased so that the they can fetch record batches this large. In the latest message format version, records are always grouped into batches for efficiency. In previous message format versions, uncompressed records are not grouped into batches and this limit only applies to a single record in that case.
        """
        message_downconversion_enable: NotRequired[pulumi.Input[_builtins.bool]]
        """
        This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests. When set to false, broker will not perform down-conversion for consumers expecting an older message format. The broker responds with UNSUPPORTED_VERSION error for consume requests from such older clients. This configuration does not apply to any message format conversion that might be required for replication to followers.
        """
        message_format_version: NotRequired[pulumi.Input[_builtins.str]]
        """
        Specify the message format version the broker will use to append messages to the logs. The value should be a valid ApiVersion. Some examples are: 0.8.2, 0.9.0.0, 0.10.0, check ApiVersion for more details. By setting a particular message format version, the user is certifying that all the existing messages on disk are smaller or equal than the specified version. Setting this value incorrectly will cause consumers with older versions to break as they will receive messages with a format that they don't understand. Deprecated in Kafka 4.0+: this configuration is removed and any supplied value will be ignored; for services upgraded to 4.0+, the returned value may be 'None'. The possible values are `0.10.0`, `0.10.0-IV0`, `0.10.0-IV1`, `0.10.1`, `0.10.1-IV0`, `0.10.1-IV1`, `0.10.1-IV2`, `0.10.2`, `0.10.2-IV0`, `0.11.0`, `0.11.0-IV0`, `0.11.0-IV1`, `0.11.0-IV2`, `0.8.0`, `0.8.1`, `0.8.2`, `0.9.0`, `1.0`, `1.0-IV0`, `1.1`, `1.1-IV0`, `2.0`, `2.0-IV0`, `2.0-IV1`, `2.1`, `2.1-IV0`, `2.1-IV1`, `2.1-IV2`, `2.2`, `2.2-IV0`, `2.2-IV1`, `2.3`, `2.3-IV0`, `2.3-IV1`, `2.4`, `2.4-IV0`, `2.4-IV1`, `2.5`, `2.5-IV0`, `2.6`, `2.6-IV0`, `2.7`, `2.7-IV0`, `2.7-IV1`, `2.7-IV2`, `2.8`, `2.8-IV0`, `2.8-IV1`, `3.0`, `3.0-IV0`, `3.0-IV1`, `3.1`, `3.1-IV0`, `3.2`, `3.2-IV0`, `3.3`, `3.3-IV0`, `3.3-IV1`, `3.3-IV2`, `3.3-IV3`, `3.4`, `3.4-IV0`, `3.5`, `3.5-IV0`, `3.5-IV1`, `3.5-IV2`, `3.6`, `3.6-IV0`, `3.6-IV1`, `3.6-IV2`, `3.7`, `3.7-IV0`, `3.7-IV1`, `3.7-IV2`, `3.7-IV3`, `3.7-IV4`, `3.8`, `3.8-IV0`, `3.9`, `3.9-IV0`, `3.9-IV1`, `4.0`, `4.0-IV0`, `4.1` and `4.1-IV0`.
        """
        message_timestamp_difference_max_ms: NotRequired[pulumi.Input[_builtins.str]]
        """
        The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message. If message.timestamp.type=CreateTime, a message will be rejected if the difference in timestamp exceeds this threshold. This configuration is ignored if message.timestamp.type=LogAppendTime.
        """
        message_timestamp_type: NotRequired[pulumi.Input[_builtins.str]]
        """
        Define whether the timestamp in the message is message create time or log append time. The possible values are `CreateTime` and `LogAppendTime`.
        """
        min_cleanable_dirty_ratio: NotRequired[pulumi.Input[_builtins.float]]
        """
        This configuration controls how frequently the log compactor will attempt to clean the log (assuming log compaction is enabled). By default we will avoid cleaning a log where more than 50% of the log has been compacted. This ratio bounds the maximum space wasted in the log by duplicates (at 50% at most 50% of the log could be duplicates). A higher ratio will mean fewer, more efficient cleanings but will mean more wasted space in the log. If the max.compaction.lag.ms or the min.compaction.lag.ms configurations are also specified, then the log compactor considers the log to be eligible for compaction as soon as either: (i) the dirty ratio threshold has been met and the log has had dirty (uncompacted) records for at least the min.compaction.lag.ms duration, or (ii) if the log has had dirty (uncompacted) records for at most the max.compaction.lag.ms period.
        """
        min_compaction_lag_ms: NotRequired[pulumi.Input[_builtins.str]]
        """
        The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted.
        """
        min_insync_replicas: NotRequired[pulumi.Input[_builtins.str]]
        """
        When a producer sets acks to 'all' (or '-1'), this configuration specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. If this minimum cannot be met, then the producer will raise an exception (either NotEnoughReplicas or NotEnoughReplicasAfterAppend). When used together, min.insync.replicas and acks allow you to enforce greater durability guarantees. A typical scenario would be to create a topic with a replication factor of 3, set min.insync.replicas to 2, and produce with acks of 'all'. This will ensure that the producer raises an exception if a majority of replicas do not receive a write.
        """
        preallocate: NotRequired[pulumi.Input[_builtins.bool]]
        """
        True if we should preallocate the file on disk when creating a new log segment.
        """
        remote_storage_enable: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Indicates whether tiered storage should be enabled.
        """
        retention_bytes: NotRequired[pulumi.Input[_builtins.str]]
        """
        This configuration controls the maximum size a partition (which consists of log segments) can grow to before we will discard old log segments to free up space if we are using the 'delete' retention policy. By default there is no size limit only a time limit. Since this limit is enforced at the partition level, multiply it by the number of partitions to compute the topic retention in bytes.
        """
        retention_ms: NotRequired[pulumi.Input[_builtins.str]]
        """
        This configuration controls the maximum time we will retain a log before we will discard old log segments to free up space if we are using the 'delete' retention policy. This represents an SLA on how soon consumers must read their data. If set to -1, no time limit is applied.
        """
        segment_bytes: NotRequired[pulumi.Input[_builtins.str]]
        """
        This configuration controls the size of the index that maps offsets to file positions. We preallocate this index file and shrink it only after log rolls. You generally should not need to change this setting.
        """
        segment_index_bytes: NotRequired[pulumi.Input[_builtins.str]]
        """
        This configuration controls the size of the index that maps offsets to file positions. We preallocate this index file and shrink it only after log rolls. You generally should not need to change this setting.
        """
        segment_jitter_ms: NotRequired[pulumi.Input[_builtins.str]]
        """
        The maximum random jitter subtracted from the scheduled segment roll time to avoid thundering herds of segment rolling
        """
        segment_ms: NotRequired[pulumi.Input[_builtins.str]]
        """
        This configuration controls the period of time after which Kafka will force the log to roll even if the segment file isn't full to ensure that retention can delete or compact old data. Setting this to a very low value has consequences, and the Aiven management plane ignores values less than 10 seconds.
        """
        unclean_leader_election_enable: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Indicates whether to enable replicas not in the ISR set to be elected as leader as a last resort, even though doing so may result in data loss.
        """
elif False:
    KafkaTopicConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaTopicConfigArgs:
    def __init__(__self__, *,
                 cleanup_policy: Optional[pulumi.Input[_builtins.str]] = None,
                 compression_type: Optional[pulumi.Input[_builtins.str]] = None,
                 delete_retention_ms: Optional[pulumi.Input[_builtins.str]] = None,
                 diskless_enable: Optional[pulumi.Input[_builtins.bool]] = None,
                 file_delete_delay_ms: Optional[pulumi.Input[_builtins.str]] = None,
                 flush_messages: Optional[pulumi.Input[_builtins.str]] = None,
                 flush_ms: Optional[pulumi.Input[_builtins.str]] = None,
                 index_interval_bytes: Optional[pulumi.Input[_builtins.str]] = None,
                 local_retention_bytes: Optional[pulumi.Input[_builtins.str]] = None,
                 local_retention_ms: Optional[pulumi.Input[_builtins.str]] = None,
                 max_compaction_lag_ms: Optional[pulumi.Input[_builtins.str]] = None,
                 max_message_bytes: Optional[pulumi.Input[_builtins.str]] = None,
                 message_downconversion_enable: Optional[pulumi.Input[_builtins.bool]] = None,
                 message_format_version: Optional[pulumi.Input[_builtins.str]] = None,
                 message_timestamp_difference_max_ms: Optional[pulumi.Input[_builtins.str]] = None,
                 message_timestamp_type: Optional[pulumi.Input[_builtins.str]] = None,
                 min_cleanable_dirty_ratio: Optional[pulumi.Input[_builtins.float]] = None,
                 min_compaction_lag_ms: Optional[pulumi.Input[_builtins.str]] = None,
                 min_insync_replicas: Optional[pulumi.Input[_builtins.str]] = None,
                 preallocate: Optional[pulumi.Input[_builtins.bool]] = None,
                 remote_storage_enable: Optional[pulumi.Input[_builtins.bool]] = None,
                 retention_bytes: Optional[pulumi.Input[_builtins.str]] = None,
                 retention_ms: Optional[pulumi.Input[_builtins.str]] = None,
                 segment_bytes: Optional[pulumi.Input[_builtins.str]] = None,
                 segment_index_bytes: Optional[pulumi.Input[_builtins.str]] = None,
                 segment_jitter_ms: Optional[pulumi.Input[_builtins.str]] = None,
                 segment_ms: Optional[pulumi.Input[_builtins.str]] = None,
                 unclean_leader_election_enable: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] cleanup_policy: The retention policy to use on old segments. Possible values include 'delete', 'compact', or a comma-separated list of them. The default policy ('delete') will discard old segments when their retention time or size limit has been reached. The 'compact' setting will enable log compaction on the topic. The possible values are `compact`, `compact,delete` and `delete`.
        :param pulumi.Input[_builtins.str] compression_type: Specify the final compression type for a given topic. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'uncompressed' which is equivalent to no compression; and 'producer' which means retain the original compression codec set by the producer. The possible values are `gzip`, `lz4`, `producer`, `snappy`, `uncompressed` and `zstd`.
        :param pulumi.Input[_builtins.str] delete_retention_ms: The amount of time to retain delete tombstone markers for log compacted topics. This setting also gives a bound on the time in which a consumer must complete a read if they begin from offset 0 to ensure that they get a valid snapshot of the final stage (otherwise delete tombstones may be collected before they complete their scan).
        :param pulumi.Input[_builtins.bool] diskless_enable: Creates a [diskless topic](https://aiven.io/docs/products/diskless). You can only do this when you create the topic and you cannot change it later. Diskless topics are only available for bring your own cloud (BYOC) services that have the feature enabled.
        :param pulumi.Input[_builtins.str] file_delete_delay_ms: The time to wait before deleting a file from the filesystem.
        :param pulumi.Input[_builtins.str] flush_messages: This setting allows specifying an interval at which we will force an fsync of data written to the log. For example if this was set to 1 we would fsync after every message; if it were 5 we would fsync after every five messages. In general we recommend you not set this and use replication for durability and allow the operating system's background flush capabilities as it is more efficient.
        :param pulumi.Input[_builtins.str] flush_ms: This setting allows specifying a time interval at which we will force an fsync of data written to the log. For example if this was set to 1000 we would fsync after 1000 ms had passed. In general we recommend you not set this and use replication for durability and allow the operating system's background flush capabilities as it is more efficient.
        :param pulumi.Input[_builtins.str] index_interval_bytes: This setting controls how frequently Kafka adds an index entry to its offset index. The default setting ensures that we index a message roughly every 4096 bytes. More indexing allows reads to jump closer to the exact position in the log but makes the index larger. You probably don't need to change this.
        :param pulumi.Input[_builtins.str] local_retention_bytes: This configuration controls the maximum bytes tiered storage will retain segment files locally before it will discard old log segments to free up space. If set to -2, the limit is equal to overall retention time. If set to -1, no limit is applied but it's possible only if overall retention is also -1.
        :param pulumi.Input[_builtins.str] local_retention_ms: This configuration controls the maximum time tiered storage will retain segment files locally before it will discard old log segments to free up space. If set to -2, the time limit is equal to overall retention time. If set to -1, no time limit is applied but it's possible only if overall retention is also -1.
        :param pulumi.Input[_builtins.str] max_compaction_lag_ms: The maximum time a message will remain ineligible for compaction in the log. Only applicable for logs that are being compacted.
        :param pulumi.Input[_builtins.str] max_message_bytes: The largest record batch size allowed by Kafka (after compression if compression is enabled). If this is increased and there are consumers older than 0.10.2, the consumers' fetch size must also be increased so that the they can fetch record batches this large. In the latest message format version, records are always grouped into batches for efficiency. In previous message format versions, uncompressed records are not grouped into batches and this limit only applies to a single record in that case.
        :param pulumi.Input[_builtins.bool] message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests. When set to false, broker will not perform down-conversion for consumers expecting an older message format. The broker responds with UNSUPPORTED_VERSION error for consume requests from such older clients. This configuration does not apply to any message format conversion that might be required for replication to followers.
        :param pulumi.Input[_builtins.str] message_format_version: Specify the message format version the broker will use to append messages to the logs. The value should be a valid ApiVersion. Some examples are: 0.8.2, 0.9.0.0, 0.10.0, check ApiVersion for more details. By setting a particular message format version, the user is certifying that all the existing messages on disk are smaller or equal than the specified version. Setting this value incorrectly will cause consumers with older versions to break as they will receive messages with a format that they don't understand. Deprecated in Kafka 4.0+: this configuration is removed and any supplied value will be ignored; for services upgraded to 4.0+, the returned value may be 'None'. The possible values are `0.10.0`, `0.10.0-IV0`, `0.10.0-IV1`, `0.10.1`, `0.10.1-IV0`, `0.10.1-IV1`, `0.10.1-IV2`, `0.10.2`, `0.10.2-IV0`, `0.11.0`, `0.11.0-IV0`, `0.11.0-IV1`, `0.11.0-IV2`, `0.8.0`, `0.8.1`, `0.8.2`, `0.9.0`, `1.0`, `1.0-IV0`, `1.1`, `1.1-IV0`, `2.0`, `2.0-IV0`, `2.0-IV1`, `2.1`, `2.1-IV0`, `2.1-IV1`, `2.1-IV2`, `2.2`, `2.2-IV0`, `2.2-IV1`, `2.3`, `2.3-IV0`, `2.3-IV1`, `2.4`, `2.4-IV0`, `2.4-IV1`, `2.5`, `2.5-IV0`, `2.6`, `2.6-IV0`, `2.7`, `2.7-IV0`, `2.7-IV1`, `2.7-IV2`, `2.8`, `2.8-IV0`, `2.8-IV1`, `3.0`, `3.0-IV0`, `3.0-IV1`, `3.1`, `3.1-IV0`, `3.2`, `3.2-IV0`, `3.3`, `3.3-IV0`, `3.3-IV1`, `3.3-IV2`, `3.3-IV3`, `3.4`, `3.4-IV0`, `3.5`, `3.5-IV0`, `3.5-IV1`, `3.5-IV2`, `3.6`, `3.6-IV0`, `3.6-IV1`, `3.6-IV2`, `3.7`, `3.7-IV0`, `3.7-IV1`, `3.7-IV2`, `3.7-IV3`, `3.7-IV4`, `3.8`, `3.8-IV0`, `3.9`, `3.9-IV0`, `3.9-IV1`, `4.0`, `4.0-IV0`, `4.1` and `4.1-IV0`.
        :param pulumi.Input[_builtins.str] message_timestamp_difference_max_ms: The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message. If message.timestamp.type=CreateTime, a message will be rejected if the difference in timestamp exceeds this threshold. This configuration is ignored if message.timestamp.type=LogAppendTime.
        :param pulumi.Input[_builtins.str] message_timestamp_type: Define whether the timestamp in the message is message create time or log append time. The possible values are `CreateTime` and `LogAppendTime`.
        :param pulumi.Input[_builtins.float] min_cleanable_dirty_ratio: This configuration controls how frequently the log compactor will attempt to clean the log (assuming log compaction is enabled). By default we will avoid cleaning a log where more than 50% of the log has been compacted. This ratio bounds the maximum space wasted in the log by duplicates (at 50% at most 50% of the log could be duplicates). A higher ratio will mean fewer, more efficient cleanings but will mean more wasted space in the log. If the max.compaction.lag.ms or the min.compaction.lag.ms configurations are also specified, then the log compactor considers the log to be eligible for compaction as soon as either: (i) the dirty ratio threshold has been met and the log has had dirty (uncompacted) records for at least the min.compaction.lag.ms duration, or (ii) if the log has had dirty (uncompacted) records for at most the max.compaction.lag.ms period.
        :param pulumi.Input[_builtins.str] min_compaction_lag_ms: The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted.
        :param pulumi.Input[_builtins.str] min_insync_replicas: When a producer sets acks to 'all' (or '-1'), this configuration specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. If this minimum cannot be met, then the producer will raise an exception (either NotEnoughReplicas or NotEnoughReplicasAfterAppend). When used together, min.insync.replicas and acks allow you to enforce greater durability guarantees. A typical scenario would be to create a topic with a replication factor of 3, set min.insync.replicas to 2, and produce with acks of 'all'. This will ensure that the producer raises an exception if a majority of replicas do not receive a write.
        :param pulumi.Input[_builtins.bool] preallocate: True if we should preallocate the file on disk when creating a new log segment.
        :param pulumi.Input[_builtins.bool] remote_storage_enable: Indicates whether tiered storage should be enabled.
        :param pulumi.Input[_builtins.str] retention_bytes: This configuration controls the maximum size a partition (which consists of log segments) can grow to before we will discard old log segments to free up space if we are using the 'delete' retention policy. By default there is no size limit only a time limit. Since this limit is enforced at the partition level, multiply it by the number of partitions to compute the topic retention in bytes.
        :param pulumi.Input[_builtins.str] retention_ms: This configuration controls the maximum time we will retain a log before we will discard old log segments to free up space if we are using the 'delete' retention policy. This represents an SLA on how soon consumers must read their data. If set to -1, no time limit is applied.
        :param pulumi.Input[_builtins.str] segment_bytes: This configuration controls the size of the index that maps offsets to file positions. We preallocate this index file and shrink it only after log rolls. You generally should not need to change this setting.
        :param pulumi.Input[_builtins.str] segment_index_bytes: This configuration controls the size of the index that maps offsets to file positions. We preallocate this index file and shrink it only after log rolls. You generally should not need to change this setting.
        :param pulumi.Input[_builtins.str] segment_jitter_ms: The maximum random jitter subtracted from the scheduled segment roll time to avoid thundering herds of segment rolling
        :param pulumi.Input[_builtins.str] segment_ms: This configuration controls the period of time after which Kafka will force the log to roll even if the segment file isn't full to ensure that retention can delete or compact old data. Setting this to a very low value has consequences, and the Aiven management plane ignores values less than 10 seconds.
        :param pulumi.Input[_builtins.bool] unclean_leader_election_enable: Indicates whether to enable replicas not in the ISR set to be elected as leader as a last resort, even though doing so may result in data loss.
        """
        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 diskless_enable is not None:
            pulumi.set(__self__, "diskless_enable", diskless_enable)
        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 local_retention_bytes is not None:
            pulumi.set(__self__, "local_retention_bytes", local_retention_bytes)
        if local_retention_ms is not None:
            pulumi.set(__self__, "local_retention_ms", local_retention_ms)
        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 remote_storage_enable is not None:
            pulumi.set(__self__, "remote_storage_enable", remote_storage_enable)
        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:
            pulumi.set(__self__, "unclean_leader_election_enable", unclean_leader_election_enable)

    @_builtins.property
    @pulumi.getter(name="cleanupPolicy")
    def cleanup_policy(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The retention policy to use on old segments. Possible values include 'delete', 'compact', or a comma-separated list of them. The default policy ('delete') will discard old segments when their retention time or size limit has been reached. The 'compact' setting will enable log compaction on the topic. The possible values are `compact`, `compact,delete` and `delete`.
        """
        return pulumi.get(self, "cleanup_policy")

    @cleanup_policy.setter
    def cleanup_policy(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "cleanup_policy", value)

    @_builtins.property
    @pulumi.getter(name="compressionType")
    def compression_type(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Specify the final compression type for a given topic. This configuration accepts the standard compression codecs ('gzip', 'snappy', 'lz4', 'zstd'). It additionally accepts 'uncompressed' which is equivalent to no compression; and 'producer' which means retain the original compression codec set by the producer. The possible values are `gzip`, `lz4`, `producer`, `snappy`, `uncompressed` and `zstd`.
        """
        return pulumi.get(self, "compression_type")

    @compression_type.setter
    def compression_type(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "compression_type", value)

    @_builtins.property
    @pulumi.getter(name="deleteRetentionMs")
    def delete_retention_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The amount of time to retain delete tombstone markers for log compacted topics. This setting also gives a bound on the time in which a consumer must complete a read if they begin from offset 0 to ensure that they get a valid snapshot of the final stage (otherwise delete tombstones may be collected before they complete their scan).
        """
        return pulumi.get(self, "delete_retention_ms")

    @delete_retention_ms.setter
    def delete_retention_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "delete_retention_ms", value)

    @_builtins.property
    @pulumi.getter(name="disklessEnable")
    def diskless_enable(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Creates a [diskless topic](https://aiven.io/docs/products/diskless). You can only do this when you create the topic and you cannot change it later. Diskless topics are only available for bring your own cloud (BYOC) services that have the feature enabled.
        """
        return pulumi.get(self, "diskless_enable")

    @diskless_enable.setter
    def diskless_enable(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "diskless_enable", value)

    @_builtins.property
    @pulumi.getter(name="fileDeleteDelayMs")
    def file_delete_delay_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The time to wait before deleting a file from the filesystem.
        """
        return pulumi.get(self, "file_delete_delay_ms")

    @file_delete_delay_ms.setter
    def file_delete_delay_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "file_delete_delay_ms", value)

    @_builtins.property
    @pulumi.getter(name="flushMessages")
    def flush_messages(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        This setting allows specifying an interval at which we will force an fsync of data written to the log. For example if this was set to 1 we would fsync after every message; if it were 5 we would fsync after every five messages. In general we recommend you not set this and use replication for durability and allow the operating system's background flush capabilities as it is more efficient.
        """
        return pulumi.get(self, "flush_messages")

    @flush_messages.setter
    def flush_messages(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "flush_messages", value)

    @_builtins.property
    @pulumi.getter(name="flushMs")
    def flush_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        This setting allows specifying a time interval at which we will force an fsync of data written to the log. For example if this was set to 1000 we would fsync after 1000 ms had passed. In general we recommend you not set this and use replication for durability and allow the operating system's background flush capabilities as it is more efficient.
        """
        return pulumi.get(self, "flush_ms")

    @flush_ms.setter
    def flush_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "flush_ms", value)

    @_builtins.property
    @pulumi.getter(name="indexIntervalBytes")
    def index_interval_bytes(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        This setting controls how frequently Kafka adds an index entry to its offset index. The default setting ensures that we index a message roughly every 4096 bytes. More indexing allows reads to jump closer to the exact position in the log but makes the index larger. You probably don't need to change this.
        """
        return pulumi.get(self, "index_interval_bytes")

    @index_interval_bytes.setter
    def index_interval_bytes(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "index_interval_bytes", value)

    @_builtins.property
    @pulumi.getter(name="localRetentionBytes")
    def local_retention_bytes(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        This configuration controls the maximum bytes tiered storage will retain segment files locally before it will discard old log segments to free up space. If set to -2, the limit is equal to overall retention time. If set to -1, no limit is applied but it's possible only if overall retention is also -1.
        """
        return pulumi.get(self, "local_retention_bytes")

    @local_retention_bytes.setter
    def local_retention_bytes(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "local_retention_bytes", value)

    @_builtins.property
    @pulumi.getter(name="localRetentionMs")
    def local_retention_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        This configuration controls the maximum time tiered storage will retain segment files locally before it will discard old log segments to free up space. If set to -2, the time limit is equal to overall retention time. If set to -1, no time limit is applied but it's possible only if overall retention is also -1.
        """
        return pulumi.get(self, "local_retention_ms")

    @local_retention_ms.setter
    def local_retention_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "local_retention_ms", value)

    @_builtins.property
    @pulumi.getter(name="maxCompactionLagMs")
    def max_compaction_lag_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The maximum time a message will remain ineligible for compaction in the log. Only applicable for logs that are being compacted.
        """
        return pulumi.get(self, "max_compaction_lag_ms")

    @max_compaction_lag_ms.setter
    def max_compaction_lag_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "max_compaction_lag_ms", value)

    @_builtins.property
    @pulumi.getter(name="maxMessageBytes")
    def max_message_bytes(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The largest record batch size allowed by Kafka (after compression if compression is enabled). If this is increased and there are consumers older than 0.10.2, the consumers' fetch size must also be increased so that the they can fetch record batches this large. In the latest message format version, records are always grouped into batches for efficiency. In previous message format versions, uncompressed records are not grouped into batches and this limit only applies to a single record in that case.
        """
        return pulumi.get(self, "max_message_bytes")

    @max_message_bytes.setter
    def max_message_bytes(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "max_message_bytes", value)

    @_builtins.property
    @pulumi.getter(name="messageDownconversionEnable")
    def message_downconversion_enable(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests. When set to false, broker will not perform down-conversion for consumers expecting an older message format. The broker responds with UNSUPPORTED_VERSION error for consume requests from such older clients. This configuration does not apply to any message format conversion that might be required for replication to followers.
        """
        return pulumi.get(self, "message_downconversion_enable")

    @message_downconversion_enable.setter
    def message_downconversion_enable(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "message_downconversion_enable", value)

    @_builtins.property
    @pulumi.getter(name="messageFormatVersion")
    def message_format_version(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Specify the message format version the broker will use to append messages to the logs. The value should be a valid ApiVersion. Some examples are: 0.8.2, 0.9.0.0, 0.10.0, check ApiVersion for more details. By setting a particular message format version, the user is certifying that all the existing messages on disk are smaller or equal than the specified version. Setting this value incorrectly will cause consumers with older versions to break as they will receive messages with a format that they don't understand. Deprecated in Kafka 4.0+: this configuration is removed and any supplied value will be ignored; for services upgraded to 4.0+, the returned value may be 'None'. The possible values are `0.10.0`, `0.10.0-IV0`, `0.10.0-IV1`, `0.10.1`, `0.10.1-IV0`, `0.10.1-IV1`, `0.10.1-IV2`, `0.10.2`, `0.10.2-IV0`, `0.11.0`, `0.11.0-IV0`, `0.11.0-IV1`, `0.11.0-IV2`, `0.8.0`, `0.8.1`, `0.8.2`, `0.9.0`, `1.0`, `1.0-IV0`, `1.1`, `1.1-IV0`, `2.0`, `2.0-IV0`, `2.0-IV1`, `2.1`, `2.1-IV0`, `2.1-IV1`, `2.1-IV2`, `2.2`, `2.2-IV0`, `2.2-IV1`, `2.3`, `2.3-IV0`, `2.3-IV1`, `2.4`, `2.4-IV0`, `2.4-IV1`, `2.5`, `2.5-IV0`, `2.6`, `2.6-IV0`, `2.7`, `2.7-IV0`, `2.7-IV1`, `2.7-IV2`, `2.8`, `2.8-IV0`, `2.8-IV1`, `3.0`, `3.0-IV0`, `3.0-IV1`, `3.1`, `3.1-IV0`, `3.2`, `3.2-IV0`, `3.3`, `3.3-IV0`, `3.3-IV1`, `3.3-IV2`, `3.3-IV3`, `3.4`, `3.4-IV0`, `3.5`, `3.5-IV0`, `3.5-IV1`, `3.5-IV2`, `3.6`, `3.6-IV0`, `3.6-IV1`, `3.6-IV2`, `3.7`, `3.7-IV0`, `3.7-IV1`, `3.7-IV2`, `3.7-IV3`, `3.7-IV4`, `3.8`, `3.8-IV0`, `3.9`, `3.9-IV0`, `3.9-IV1`, `4.0`, `4.0-IV0`, `4.1` and `4.1-IV0`.
        """
        return pulumi.get(self, "message_format_version")

    @message_format_version.setter
    def message_format_version(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "message_format_version", value)

    @_builtins.property
    @pulumi.getter(name="messageTimestampDifferenceMaxMs")
    def message_timestamp_difference_max_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message. If message.timestamp.type=CreateTime, a message will be rejected if the difference in timestamp exceeds this threshold. This configuration is ignored if message.timestamp.type=LogAppendTime.
        """
        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[_builtins.str]]):
        pulumi.set(self, "message_timestamp_difference_max_ms", value)

    @_builtins.property
    @pulumi.getter(name="messageTimestampType")
    def message_timestamp_type(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Define whether the timestamp in the message is message create time or log append time. The possible values are `CreateTime` and `LogAppendTime`.
        """
        return pulumi.get(self, "message_timestamp_type")

    @message_timestamp_type.setter
    def message_timestamp_type(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "message_timestamp_type", value)

    @_builtins.property
    @pulumi.getter(name="minCleanableDirtyRatio")
    def min_cleanable_dirty_ratio(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        This configuration controls how frequently the log compactor will attempt to clean the log (assuming log compaction is enabled). By default we will avoid cleaning a log where more than 50% of the log has been compacted. This ratio bounds the maximum space wasted in the log by duplicates (at 50% at most 50% of the log could be duplicates). A higher ratio will mean fewer, more efficient cleanings but will mean more wasted space in the log. If the max.compaction.lag.ms or the min.compaction.lag.ms configurations are also specified, then the log compactor considers the log to be eligible for compaction as soon as either: (i) the dirty ratio threshold has been met and the log has had dirty (uncompacted) records for at least the min.compaction.lag.ms duration, or (ii) if the log has had dirty (uncompacted) records for at most the max.compaction.lag.ms period.
        """
        return pulumi.get(self, "min_cleanable_dirty_ratio")

    @min_cleanable_dirty_ratio.setter
    def min_cleanable_dirty_ratio(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "min_cleanable_dirty_ratio", value)

    @_builtins.property
    @pulumi.getter(name="minCompactionLagMs")
    def min_compaction_lag_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted.
        """
        return pulumi.get(self, "min_compaction_lag_ms")

    @min_compaction_lag_ms.setter
    def min_compaction_lag_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "min_compaction_lag_ms", value)

    @_builtins.property
    @pulumi.getter(name="minInsyncReplicas")
    def min_insync_replicas(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        When a producer sets acks to 'all' (or '-1'), this configuration specifies the minimum number of replicas that must acknowledge a write for the write to be considered successful. If this minimum cannot be met, then the producer will raise an exception (either NotEnoughReplicas or NotEnoughReplicasAfterAppend). When used together, min.insync.replicas and acks allow you to enforce greater durability guarantees. A typical scenario would be to create a topic with a replication factor of 3, set min.insync.replicas to 2, and produce with acks of 'all'. This will ensure that the producer raises an exception if a majority of replicas do not receive a write.
        """
        return pulumi.get(self, "min_insync_replicas")

    @min_insync_replicas.setter
    def min_insync_replicas(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "min_insync_replicas", value)

    @_builtins.property
    @pulumi.getter
    def preallocate(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        True if we should preallocate the file on disk when creating a new log segment.
        """
        return pulumi.get(self, "preallocate")

    @preallocate.setter
    def preallocate(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "preallocate", value)

    @_builtins.property
    @pulumi.getter(name="remoteStorageEnable")
    def remote_storage_enable(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Indicates whether tiered storage should be enabled.
        """
        return pulumi.get(self, "remote_storage_enable")

    @remote_storage_enable.setter
    def remote_storage_enable(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "remote_storage_enable", value)

    @_builtins.property
    @pulumi.getter(name="retentionBytes")
    def retention_bytes(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        This configuration controls the maximum size a partition (which consists of log segments) can grow to before we will discard old log segments to free up space if we are using the 'delete' retention policy. By default there is no size limit only a time limit. Since this limit is enforced at the partition level, multiply it by the number of partitions to compute the topic retention in bytes.
        """
        return pulumi.get(self, "retention_bytes")

    @retention_bytes.setter
    def retention_bytes(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "retention_bytes", value)

    @_builtins.property
    @pulumi.getter(name="retentionMs")
    def retention_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        This configuration controls the maximum time we will retain a log before we will discard old log segments to free up space if we are using the 'delete' retention policy. This represents an SLA on how soon consumers must read their data. If set to -1, no time limit is applied.
        """
        return pulumi.get(self, "retention_ms")

    @retention_ms.setter
    def retention_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "retention_ms", value)

    @_builtins.property
    @pulumi.getter(name="segmentBytes")
    def segment_bytes(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        This configuration controls the size of the index that maps offsets to file positions. We preallocate this index file and shrink it only after log rolls. You generally should not need to change this setting.
        """
        return pulumi.get(self, "segment_bytes")

    @segment_bytes.setter
    def segment_bytes(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "segment_bytes", value)

    @_builtins.property
    @pulumi.getter(name="segmentIndexBytes")
    def segment_index_bytes(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        This configuration controls the size of the index that maps offsets to file positions. We preallocate this index file and shrink it only after log rolls. You generally should not need to change this setting.
        """
        return pulumi.get(self, "segment_index_bytes")

    @segment_index_bytes.setter
    def segment_index_bytes(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "segment_index_bytes", value)

    @_builtins.property
    @pulumi.getter(name="segmentJitterMs")
    def segment_jitter_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The maximum random jitter subtracted from the scheduled segment roll time to avoid thundering herds of segment rolling
        """
        return pulumi.get(self, "segment_jitter_ms")

    @segment_jitter_ms.setter
    def segment_jitter_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "segment_jitter_ms", value)

    @_builtins.property
    @pulumi.getter(name="segmentMs")
    def segment_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        This configuration controls the period of time after which Kafka will force the log to roll even if the segment file isn't full to ensure that retention can delete or compact old data. Setting this to a very low value has consequences, and the Aiven management plane ignores values less than 10 seconds.
        """
        return pulumi.get(self, "segment_ms")

    @segment_ms.setter
    def segment_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "segment_ms", value)

    @_builtins.property
    @pulumi.getter(name="uncleanLeaderElectionEnable")
    def unclean_leader_election_enable(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Indicates whether to enable replicas not in the ISR set to be elected as leader as a last resort, even though doing so may result in data loss.
        """
        return pulumi.get(self, "unclean_leader_election_enable")

    @unclean_leader_election_enable.setter
    def unclean_leader_election_enable(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "unclean_leader_election_enable", value)


if not MYPY:
    class KafkaTopicTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Tag key. Maximum length: `64`.
        """
        value: NotRequired[pulumi.Input[_builtins.str]]
        """
        Tag value. Maximum length: `256`.
        """
elif False:
    KafkaTopicTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class KafkaTopicTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[_builtins.str],
                 value: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] key: Tag key. Maximum length: `64`.
        :param pulumi.Input[_builtins.str] value: Tag value. Maximum length: `256`.
        """
        pulumi.set(__self__, "key", key)
        if value is not None:
            pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def key(self) -> pulumi.Input[_builtins.str]:
        """
        Tag key. Maximum length: `64`.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "key", value)

    @_builtins.property
    @pulumi.getter
    def value(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Tag value. Maximum length: `256`.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "value", value)


if not MYPY:
    class M3AggregatorComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    M3AggregatorComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3AggregatorComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

    @_builtins.property
    @pulumi.getter
    def component(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Service component name
        """
        return pulumi.get(self, "component")

    @component.setter
    def component(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "component", value)

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

    @connection_uri.setter
    def connection_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "connection_uri", value)

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_authentication_method", value)

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

    @kafka_ssl_ca.setter
    def kafka_ssl_ca(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_ssl_ca", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def route(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Network access route
        """
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "route", value)

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ssl", value)

    @_builtins.property
    @pulumi.getter
    def usage(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        DNS usage name
        """
        return pulumi.get(self, "usage")

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "usage", value)


if not MYPY:
    class M3AggregatorM3aggregatorArgsDict(TypedDict):
        aggregator_http_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        M3 Aggregator HTTP URI.
        """
        uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        M3 Aggregator server URIs.
        """
elif False:
    M3AggregatorM3aggregatorArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3AggregatorM3aggregatorArgs:
    def __init__(__self__, *,
                 aggregator_http_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[_builtins.str] aggregator_http_uri: M3 Aggregator HTTP URI.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uris: M3 Aggregator server URIs.
        """
        if aggregator_http_uri is not None:
            pulumi.set(__self__, "aggregator_http_uri", aggregator_http_uri)
        if uris is not None:
            pulumi.set(__self__, "uris", uris)

    @_builtins.property
    @pulumi.getter(name="aggregatorHttpUri")
    def aggregator_http_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        M3 Aggregator HTTP URI.
        """
        return pulumi.get(self, "aggregator_http_uri")

    @aggregator_http_uri.setter
    def aggregator_http_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "aggregator_http_uri", value)

    @_builtins.property
    @pulumi.getter
    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        M3 Aggregator server URIs.
        """
        return pulumi.get(self, "uris")

    @uris.setter
    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "uris", value)


if not MYPY:
    class M3AggregatorM3aggregatorUserConfigArgsDict(TypedDict):
        custom_domain: NotRequired[pulumi.Input[_builtins.str]]
        """
        Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. Example: `grafana.example.org`.
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['M3AggregatorM3aggregatorUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        m3_version: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `1.1`, `1.2`, `1.5`, and newer. M3 major version (deprecated, use m3aggregator_version).
        """
        m3aggregator_version: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `1.1`, `1.2`, `1.5`, and newer. M3 major version (the minimum compatible version).
        """
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
elif False:
    M3AggregatorM3aggregatorUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3AggregatorM3aggregatorUserConfigArgs:
    def __init__(__self__, *,
                 custom_domain: Optional[pulumi.Input[_builtins.str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['M3AggregatorM3aggregatorUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 m3_version: Optional[pulumi.Input[_builtins.str]] = None,
                 m3aggregator_version: Optional[pulumi.Input[_builtins.str]] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. Example: `grafana.example.org`.
        :param pulumi.Input[Sequence[pulumi.Input['M3AggregatorM3aggregatorUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] m3_version: Enum: `1.1`, `1.2`, `1.5`, and newer. M3 major version (deprecated, use m3aggregator_version).
        :param pulumi.Input[_builtins.str] m3aggregator_version: Enum: `1.1`, `1.2`, `1.5`, and newer. M3 major version (the minimum compatible version).
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input[_builtins.bool] static_ips: Use static public IP addresses.
        """
        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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `ip_filter_string` instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        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 service_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)

    @_builtins.property
    @pulumi.getter(name="customDomain")
    def custom_domain(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. Example: `grafana.example.org`.
        """
        return pulumi.get(self, "custom_domain")

    @custom_domain.setter
    def custom_domain(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "custom_domain", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['M3AggregatorM3aggregatorUserConfigIpFilterObjectArgs']]]]:
        """
        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['M3AggregatorM3aggregatorUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "ip_filters", value)

    @_builtins.property
    @pulumi.getter(name="m3Version")
    def m3_version(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `1.1`, `1.2`, `1.5`, and newer. M3 major version (deprecated, use m3aggregator_version).
        """
        return pulumi.get(self, "m3_version")

    @m3_version.setter
    def m3_version(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "m3_version", value)

    @_builtins.property
    @pulumi.getter(name="m3aggregatorVersion")
    def m3aggregator_version(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `1.1`, `1.2`, `1.5`, and newer. M3 major version (the minimum compatible version).
        """
        return pulumi.get(self, "m3aggregator_version")

    @m3aggregator_version.setter
    def m3aggregator_version(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "m3aggregator_version", value)

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

    @service_log.setter
    def service_log(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "service_log", value)

    @_builtins.property
    @pulumi.getter(name="staticIps")
    def static_ips(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Use static public IP addresses.
        """
        return pulumi.get(self, "static_ips")

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "static_ips", value)


if not MYPY:
    class M3AggregatorM3aggregatorUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    M3AggregatorM3aggregatorUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3AggregatorM3aggregatorUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "network", value)

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "description", value)


if not MYPY:
    class M3AggregatorServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    M3AggregatorServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3AggregatorServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration
        :param pulumi.Input[_builtins.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)

    @_builtins.property
    @pulumi.getter(name="integrationType")
    def integration_type(self) -> pulumi.Input[_builtins.str]:
        """
        Type of the service integration
        """
        return pulumi.get(self, "integration_type")

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "integration_type", value)

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class M3AggregatorTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    M3AggregatorTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3AggregatorTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[_builtins.str],
                 value: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] key: Service tag key
        :param pulumi.Input[_builtins.str] value: Service tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def key(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "key", value)

    @_builtins.property
    @pulumi.getter
    def value(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag value
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "value", value)


if not MYPY:
    class M3AggregatorTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    M3AggregatorTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3AggregatorTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

    @email.setter
    def email(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "email", value)


if not MYPY:
    class M3DbComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    M3DbComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

    @_builtins.property
    @pulumi.getter
    def component(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Service component name
        """
        return pulumi.get(self, "component")

    @component.setter
    def component(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "component", value)

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

    @connection_uri.setter
    def connection_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "connection_uri", value)

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_authentication_method", value)

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

    @kafka_ssl_ca.setter
    def kafka_ssl_ca(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_ssl_ca", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def route(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Network access route
        """
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "route", value)

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ssl", value)

    @_builtins.property
    @pulumi.getter
    def usage(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        DNS usage name
        """
        return pulumi.get(self, "usage")

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "usage", value)


if not MYPY:
    class M3DbM3dbArgsDict(TypedDict):
        http_cluster_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        M3DB cluster URI.
        """
        http_node_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        M3DB node URI.
        """
        influxdb_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        InfluxDB URI.
        """
        prometheus_remote_read_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Prometheus remote read URI.
        """
        prometheus_remote_write_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Prometheus remote write URI.
        """
        uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        M3DB server URIs.
        """
elif False:
    M3DbM3dbArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbM3dbArgs:
    def __init__(__self__, *,
                 http_cluster_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 http_node_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 influxdb_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 prometheus_remote_read_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 prometheus_remote_write_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[_builtins.str] http_cluster_uri: M3DB cluster URI.
        :param pulumi.Input[_builtins.str] http_node_uri: M3DB node URI.
        :param pulumi.Input[_builtins.str] influxdb_uri: InfluxDB URI.
        :param pulumi.Input[_builtins.str] prometheus_remote_read_uri: Prometheus remote read URI.
        :param pulumi.Input[_builtins.str] prometheus_remote_write_uri: Prometheus remote write URI.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uris: M3DB server URIs.
        """
        if http_cluster_uri is not None:
            pulumi.set(__self__, "http_cluster_uri", http_cluster_uri)
        if http_node_uri is not None:
            pulumi.set(__self__, "http_node_uri", http_node_uri)
        if influxdb_uri is not None:
            pulumi.set(__self__, "influxdb_uri", influxdb_uri)
        if prometheus_remote_read_uri is not None:
            pulumi.set(__self__, "prometheus_remote_read_uri", prometheus_remote_read_uri)
        if prometheus_remote_write_uri is not None:
            pulumi.set(__self__, "prometheus_remote_write_uri", prometheus_remote_write_uri)
        if uris is not None:
            pulumi.set(__self__, "uris", uris)

    @_builtins.property
    @pulumi.getter(name="httpClusterUri")
    def http_cluster_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        M3DB cluster URI.
        """
        return pulumi.get(self, "http_cluster_uri")

    @http_cluster_uri.setter
    def http_cluster_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "http_cluster_uri", value)

    @_builtins.property
    @pulumi.getter(name="httpNodeUri")
    def http_node_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        M3DB node URI.
        """
        return pulumi.get(self, "http_node_uri")

    @http_node_uri.setter
    def http_node_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "http_node_uri", value)

    @_builtins.property
    @pulumi.getter(name="influxdbUri")
    def influxdb_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        InfluxDB URI.
        """
        return pulumi.get(self, "influxdb_uri")

    @influxdb_uri.setter
    def influxdb_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "influxdb_uri", value)

    @_builtins.property
    @pulumi.getter(name="prometheusRemoteReadUri")
    def prometheus_remote_read_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Prometheus remote read URI.
        """
        return pulumi.get(self, "prometheus_remote_read_uri")

    @prometheus_remote_read_uri.setter
    def prometheus_remote_read_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "prometheus_remote_read_uri", value)

    @_builtins.property
    @pulumi.getter(name="prometheusRemoteWriteUri")
    def prometheus_remote_write_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Prometheus remote write URI.
        """
        return pulumi.get(self, "prometheus_remote_write_uri")

    @prometheus_remote_write_uri.setter
    def prometheus_remote_write_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "prometheus_remote_write_uri", value)

    @_builtins.property
    @pulumi.getter
    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        M3DB server URIs.
        """
        return pulumi.get(self, "uris")

    @uris.setter
    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "uris", value)


if not MYPY:
    class M3DbM3dbUserConfigArgsDict(TypedDict):
        additional_backup_regions: NotRequired[pulumi.Input[_builtins.str]]
        """
        Additional Cloud Regions for Backup Replication.
        """
        custom_domain: NotRequired[pulumi.Input[_builtins.str]]
        """
        Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. Example: `grafana.example.org`.
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        limits: NotRequired[pulumi.Input['M3DbM3dbUserConfigLimitsArgsDict']]
        """
        M3 limits
        """
        m3: NotRequired[pulumi.Input['M3DbM3dbUserConfigM3ArgsDict']]
        """
        M3 specific configuration options
        """
        m3_version: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `1.1`, `1.2`, `1.5`, and newer. M3 major version (deprecated, use m3db_version).
        """
        m3coordinator_enable_graphite_carbon_ingest: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enables access to Graphite Carbon plaintext metrics ingestion. It can be enabled only for services inside VPCs. The metrics are written to aggregated namespaces only.
        """
        m3db_version: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `1.1`, `1.2`, `1.5`, and newer. M3 major version (the minimum compatible version).
        """
        namespaces: NotRequired[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigNamespaceArgsDict']]]]
        """
        List of M3 namespaces
        """
        private_access: NotRequired[pulumi.Input['M3DbM3dbUserConfigPrivateAccessArgsDict']]
        """
        Allow access to selected service ports from private networks
        """
        project_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        public_access: NotRequired[pulumi.Input['M3DbM3dbUserConfigPublicAccessArgsDict']]
        """
        Allow access to selected service ports from the public Internet
        """
        rules: NotRequired[pulumi.Input['M3DbM3dbUserConfigRulesArgsDict']]
        """
        M3 rules
        """
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        service_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
elif False:
    M3DbM3dbUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbM3dbUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[_builtins.str]] = None,
                 custom_domain: Optional[pulumi.Input[_builtins.str]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 limits: Optional[pulumi.Input['M3DbM3dbUserConfigLimitsArgs']] = None,
                 m3: Optional[pulumi.Input['M3DbM3dbUserConfigM3Args']] = None,
                 m3_version: Optional[pulumi.Input[_builtins.str]] = None,
                 m3coordinator_enable_graphite_carbon_ingest: Optional[pulumi.Input[_builtins.bool]] = None,
                 m3db_version: Optional[pulumi.Input[_builtins.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[_builtins.str]] = None,
                 public_access: Optional[pulumi.Input['M3DbM3dbUserConfigPublicAccessArgs']] = None,
                 rules: Optional[pulumi.Input['M3DbM3dbUserConfigRulesArgs']] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 service_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[_builtins.str] custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. Example: `grafana.example.org`.
        :param pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input['M3DbM3dbUserConfigLimitsArgs'] limits: M3 limits
        :param pulumi.Input['M3DbM3dbUserConfigM3Args'] m3: M3 specific configuration options
        :param pulumi.Input[_builtins.str] m3_version: Enum: `1.1`, `1.2`, `1.5`, and newer. M3 major version (deprecated, use m3db_version).
        :param pulumi.Input[_builtins.bool] m3coordinator_enable_graphite_carbon_ingest: Enables access to Graphite Carbon plaintext metrics ingestion. It can be enabled only for services inside VPCs. The metrics are written to aggregated namespaces only.
        :param pulumi.Input[_builtins.str] m3db_version: Enum: `1.1`, `1.2`, `1.5`, and newer. M3 major version (the minimum compatible version).
        :param pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigNamespaceArgs']]] namespaces: List of M3 namespaces
        :param pulumi.Input['M3DbM3dbUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks
        :param pulumi.Input[_builtins.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. Example: `anotherprojectname`.
        :param pulumi.Input['M3DbM3dbUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
        :param pulumi.Input['M3DbM3dbUserConfigRulesArgs'] rules: M3 rules
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input[_builtins.str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        :param pulumi.Input[_builtins.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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `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:
            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_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        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)

    @_builtins.property
    @pulumi.getter(name="additionalBackupRegions")
    def additional_backup_regions(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @_builtins.property
    @pulumi.getter(name="customDomain")
    def custom_domain(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. Example: `grafana.example.org`.
        """
        return pulumi.get(self, "custom_domain")

    @custom_domain.setter
    def custom_domain(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "custom_domain", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigIpFilterObjectArgs']]]]:
        """
        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['M3DbM3dbUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "ip_filters", value)

    @_builtins.property
    @pulumi.getter
    def limits(self) -> Optional[pulumi.Input['M3DbM3dbUserConfigLimitsArgs']]:
        """
        M3 limits
        """
        return pulumi.get(self, "limits")

    @limits.setter
    def limits(self, value: Optional[pulumi.Input['M3DbM3dbUserConfigLimitsArgs']]):
        pulumi.set(self, "limits", value)

    @_builtins.property
    @pulumi.getter
    def m3(self) -> Optional[pulumi.Input['M3DbM3dbUserConfigM3Args']]:
        """
        M3 specific configuration options
        """
        return pulumi.get(self, "m3")

    @m3.setter
    def m3(self, value: Optional[pulumi.Input['M3DbM3dbUserConfigM3Args']]):
        pulumi.set(self, "m3", value)

    @_builtins.property
    @pulumi.getter(name="m3Version")
    def m3_version(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `1.1`, `1.2`, `1.5`, and newer. M3 major version (deprecated, use m3db_version).
        """
        return pulumi.get(self, "m3_version")

    @m3_version.setter
    def m3_version(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "m3_version", value)

    @_builtins.property
    @pulumi.getter(name="m3coordinatorEnableGraphiteCarbonIngest")
    def m3coordinator_enable_graphite_carbon_ingest(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enables access to Graphite Carbon plaintext metrics ingestion. It can be enabled only for services inside VPCs. The metrics are written to aggregated namespaces only.
        """
        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[_builtins.bool]]):
        pulumi.set(self, "m3coordinator_enable_graphite_carbon_ingest", value)

    @_builtins.property
    @pulumi.getter(name="m3dbVersion")
    def m3db_version(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `1.1`, `1.2`, `1.5`, and newer. M3 major version (the minimum compatible version).
        """
        return pulumi.get(self, "m3db_version")

    @m3db_version.setter
    def m3db_version(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "m3db_version", value)

    @_builtins.property
    @pulumi.getter
    def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigNamespaceArgs']]]]:
        """
        List of M3 namespaces
        """
        return pulumi.get(self, "namespaces")

    @namespaces.setter
    def namespaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigNamespaceArgs']]]]):
        pulumi.set(self, "namespaces", value)

    @_builtins.property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['M3DbM3dbUserConfigPrivateAccessArgs']]:
        """
        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['M3DbM3dbUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @_builtins.property
    @pulumi.getter(name="projectToForkFrom")
    def project_to_fork_from(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        return pulumi.get(self, "project_to_fork_from")

    @project_to_fork_from.setter
    def project_to_fork_from(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "project_to_fork_from", value)

    @_builtins.property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['M3DbM3dbUserConfigPublicAccessArgs']]:
        """
        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['M3DbM3dbUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

    @_builtins.property
    @pulumi.getter
    def rules(self) -> Optional[pulumi.Input['M3DbM3dbUserConfigRulesArgs']]:
        """
        M3 rules
        """
        return pulumi.get(self, "rules")

    @rules.setter
    def rules(self, value: Optional[pulumi.Input['M3DbM3dbUserConfigRulesArgs']]):
        pulumi.set(self, "rules", value)

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

    @service_log.setter
    def service_log(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "service_log", value)

    @_builtins.property
    @pulumi.getter(name="serviceToForkFrom")
    def service_to_fork_from(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        return pulumi.get(self, "service_to_fork_from")

    @service_to_fork_from.setter
    def service_to_fork_from(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "service_to_fork_from", value)

    @_builtins.property
    @pulumi.getter(name="staticIps")
    def static_ips(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Use static public IP addresses.
        """
        return pulumi.get(self, "static_ips")

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "static_ips", value)


if not MYPY:
    class M3DbM3dbUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    M3DbM3dbUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbM3dbUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "network", value)

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "description", value)


if not MYPY:
    class M3DbM3dbUserConfigLimitsArgsDict(TypedDict):
        max_recently_queried_series_blocks: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of blocks that can be read in a given lookback period. Example: `20000`.
        """
        max_recently_queried_series_disk_bytes_read: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of disk bytes that can be read in a given lookback period. Example: `104857600`.
        """
        max_recently_queried_series_lookback: NotRequired[pulumi.Input[_builtins.str]]
        """
        The lookback period for `max_recently_queried_series_blocks` and `max_recently_queried_series_disk_bytes_read`. Example: `15s`.
        """
        query_docs: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of docs fetched in single query. Example: `100000`.
        """
        query_require_exhaustive: NotRequired[pulumi.Input[_builtins.bool]]
        """
        When query limits are exceeded, whether to return error or return partial results.
        """
        query_series: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of series fetched in single query. Example: `100000`.
        """
elif False:
    M3DbM3dbUserConfigLimitsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbM3dbUserConfigLimitsArgs:
    def __init__(__self__, *,
                 max_recently_queried_series_blocks: Optional[pulumi.Input[_builtins.int]] = None,
                 max_recently_queried_series_disk_bytes_read: Optional[pulumi.Input[_builtins.int]] = None,
                 max_recently_queried_series_lookback: Optional[pulumi.Input[_builtins.str]] = None,
                 query_docs: Optional[pulumi.Input[_builtins.int]] = None,
                 query_require_exhaustive: Optional[pulumi.Input[_builtins.bool]] = None,
                 query_series: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.int] max_recently_queried_series_blocks: The maximum number of blocks that can be read in a given lookback period. Example: `20000`.
        :param pulumi.Input[_builtins.int] max_recently_queried_series_disk_bytes_read: The maximum number of disk bytes that can be read in a given lookback period. Example: `104857600`.
        :param pulumi.Input[_builtins.str] max_recently_queried_series_lookback: The lookback period for `max_recently_queried_series_blocks` and `max_recently_queried_series_disk_bytes_read`. Example: `15s`.
        :param pulumi.Input[_builtins.int] query_docs: The maximum number of docs fetched in single query. Example: `100000`.
        :param pulumi.Input[_builtins.bool] query_require_exhaustive: When query limits are exceeded, whether to return error or return partial results.
        :param pulumi.Input[_builtins.int] query_series: The maximum number of series fetched in single query. Example: `100000`.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="maxRecentlyQueriedSeriesBlocks")
    def max_recently_queried_series_blocks(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of blocks that can be read in a given lookback period. Example: `20000`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "max_recently_queried_series_blocks", value)

    @_builtins.property
    @pulumi.getter(name="maxRecentlyQueriedSeriesDiskBytesRead")
    def max_recently_queried_series_disk_bytes_read(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of disk bytes that can be read in a given lookback period. Example: `104857600`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "max_recently_queried_series_disk_bytes_read", value)

    @_builtins.property
    @pulumi.getter(name="maxRecentlyQueriedSeriesLookback")
    def max_recently_queried_series_lookback(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The lookback period for `max_recently_queried_series_blocks` and `max_recently_queried_series_disk_bytes_read`. Example: `15s`.
        """
        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[_builtins.str]]):
        pulumi.set(self, "max_recently_queried_series_lookback", value)

    @_builtins.property
    @pulumi.getter(name="queryDocs")
    def query_docs(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of docs fetched in single query. Example: `100000`.
        """
        return pulumi.get(self, "query_docs")

    @query_docs.setter
    def query_docs(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "query_docs", value)

    @_builtins.property
    @pulumi.getter(name="queryRequireExhaustive")
    def query_require_exhaustive(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        When query limits are exceeded, whether to return error or return partial results.
        """
        return pulumi.get(self, "query_require_exhaustive")

    @query_require_exhaustive.setter
    def query_require_exhaustive(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "query_require_exhaustive", value)

    @_builtins.property
    @pulumi.getter(name="querySeries")
    def query_series(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of series fetched in single query. Example: `100000`.
        """
        return pulumi.get(self, "query_series")

    @query_series.setter
    def query_series(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "query_series", value)


if not MYPY:
    class M3DbM3dbUserConfigM3ArgsDict(TypedDict):
        tag_options: NotRequired[pulumi.Input['M3DbM3dbUserConfigM3TagOptionsArgsDict']]
        """
        M3 Tag Options
        """
elif False:
    M3DbM3dbUserConfigM3ArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbM3dbUserConfigM3Args:
    def __init__(__self__, *,
                 tag_options: Optional[pulumi.Input['M3DbM3dbUserConfigM3TagOptionsArgs']] = None):
        """
        :param pulumi.Input['M3DbM3dbUserConfigM3TagOptionsArgs'] tag_options: M3 Tag Options
        """
        if tag_options is not None:
            pulumi.set(__self__, "tag_options", tag_options)

    @_builtins.property
    @pulumi.getter(name="tagOptions")
    def tag_options(self) -> Optional[pulumi.Input['M3DbM3dbUserConfigM3TagOptionsArgs']]:
        """
        M3 Tag Options
        """
        return pulumi.get(self, "tag_options")

    @tag_options.setter
    def tag_options(self, value: Optional[pulumi.Input['M3DbM3dbUserConfigM3TagOptionsArgs']]):
        pulumi.set(self, "tag_options", value)


if not MYPY:
    class M3DbM3dbUserConfigM3TagOptionsArgsDict(TypedDict):
        allow_tag_name_duplicates: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allows for duplicate tags to appear on series (not allowed by default).
        """
        allow_tag_value_empty: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allows for empty tags to appear on series (not allowed by default).
        """
elif False:
    M3DbM3dbUserConfigM3TagOptionsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbM3dbUserConfigM3TagOptionsArgs:
    def __init__(__self__, *,
                 allow_tag_name_duplicates: Optional[pulumi.Input[_builtins.bool]] = None,
                 allow_tag_value_empty: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] allow_tag_name_duplicates: Allows for duplicate tags to appear on series (not allowed by default).
        :param pulumi.Input[_builtins.bool] allow_tag_value_empty: Allows for empty tags to appear on series (not allowed by default).
        """
        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)

    @_builtins.property
    @pulumi.getter(name="allowTagNameDuplicates")
    def allow_tag_name_duplicates(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allows for duplicate tags to appear on series (not allowed by default).
        """
        return pulumi.get(self, "allow_tag_name_duplicates")

    @allow_tag_name_duplicates.setter
    def allow_tag_name_duplicates(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "allow_tag_name_duplicates", value)

    @_builtins.property
    @pulumi.getter(name="allowTagValueEmpty")
    def allow_tag_value_empty(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allows for empty tags to appear on series (not allowed by default).
        """
        return pulumi.get(self, "allow_tag_value_empty")

    @allow_tag_value_empty.setter
    def allow_tag_value_empty(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "allow_tag_value_empty", value)


if not MYPY:
    class M3DbM3dbUserConfigNamespaceArgsDict(TypedDict):
        name: pulumi.Input[_builtins.str]
        """
        The name of the namespace. Example: `default`.
        """
        type: pulumi.Input[_builtins.str]
        """
        Enum: `aggregated`, `unaggregated`. The type of aggregation (aggregated/unaggregated).
        """
        options: NotRequired[pulumi.Input['M3DbM3dbUserConfigNamespaceOptionsArgsDict']]
        """
        Namespace options
        """
        resolution: NotRequired[pulumi.Input[_builtins.str]]
        """
        The resolution for an aggregated namespace. Example: `30s`.
        """
elif False:
    M3DbM3dbUserConfigNamespaceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbM3dbUserConfigNamespaceArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[_builtins.str],
                 type: pulumi.Input[_builtins.str],
                 options: Optional[pulumi.Input['M3DbM3dbUserConfigNamespaceOptionsArgs']] = None,
                 resolution: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] name: The name of the namespace. Example: `default`.
        :param pulumi.Input[_builtins.str] type: Enum: `aggregated`, `unaggregated`. The type of aggregation (aggregated/unaggregated).
        :param pulumi.Input['M3DbM3dbUserConfigNamespaceOptionsArgs'] options: Namespace options
        :param pulumi.Input[_builtins.str] resolution: The resolution for an aggregated namespace. Example: `30s`.
        """
        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)

    @_builtins.property
    @pulumi.getter
    def name(self) -> pulumi.Input[_builtins.str]:
        """
        The name of the namespace. Example: `default`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "name", value)

    @_builtins.property
    @pulumi.getter
    def type(self) -> pulumi.Input[_builtins.str]:
        """
        Enum: `aggregated`, `unaggregated`. The type of aggregation (aggregated/unaggregated).
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "type", value)

    @_builtins.property
    @pulumi.getter
    def options(self) -> Optional[pulumi.Input['M3DbM3dbUserConfigNamespaceOptionsArgs']]:
        """
        Namespace options
        """
        return pulumi.get(self, "options")

    @options.setter
    def options(self, value: Optional[pulumi.Input['M3DbM3dbUserConfigNamespaceOptionsArgs']]):
        pulumi.set(self, "options", value)

    @_builtins.property
    @pulumi.getter
    def resolution(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The resolution for an aggregated namespace. Example: `30s`.
        """
        return pulumi.get(self, "resolution")

    @resolution.setter
    def resolution(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "resolution", value)


if not MYPY:
    class M3DbM3dbUserConfigNamespaceOptionsArgsDict(TypedDict):
        retention_options: pulumi.Input['M3DbM3dbUserConfigNamespaceOptionsRetentionOptionsArgsDict']
        """
        Retention options
        """
        snapshot_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Controls whether M3DB will create snapshot files for this namespace.
        """
        writes_to_commitlog: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Controls whether M3DB will include writes to this namespace in the commitlog.
        """
elif False:
    M3DbM3dbUserConfigNamespaceOptionsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbM3dbUserConfigNamespaceOptionsArgs:
    def __init__(__self__, *,
                 retention_options: pulumi.Input['M3DbM3dbUserConfigNamespaceOptionsRetentionOptionsArgs'],
                 snapshot_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 writes_to_commitlog: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input['M3DbM3dbUserConfigNamespaceOptionsRetentionOptionsArgs'] retention_options: Retention options
        :param pulumi.Input[_builtins.bool] snapshot_enabled: Controls whether M3DB will create snapshot files for this namespace.
        :param pulumi.Input[_builtins.bool] writes_to_commitlog: Controls whether M3DB will include writes to this namespace in the commitlog.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="retentionOptions")
    def retention_options(self) -> pulumi.Input['M3DbM3dbUserConfigNamespaceOptionsRetentionOptionsArgs']:
        """
        Retention options
        """
        return pulumi.get(self, "retention_options")

    @retention_options.setter
    def retention_options(self, value: pulumi.Input['M3DbM3dbUserConfigNamespaceOptionsRetentionOptionsArgs']):
        pulumi.set(self, "retention_options", value)

    @_builtins.property
    @pulumi.getter(name="snapshotEnabled")
    def snapshot_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Controls whether M3DB will create snapshot files for this namespace.
        """
        return pulumi.get(self, "snapshot_enabled")

    @snapshot_enabled.setter
    def snapshot_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "snapshot_enabled", value)

    @_builtins.property
    @pulumi.getter(name="writesToCommitlog")
    def writes_to_commitlog(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Controls whether M3DB will include writes to this namespace in the commitlog.
        """
        return pulumi.get(self, "writes_to_commitlog")

    @writes_to_commitlog.setter
    def writes_to_commitlog(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "writes_to_commitlog", value)


if not MYPY:
    class M3DbM3dbUserConfigNamespaceOptionsRetentionOptionsArgsDict(TypedDict):
        block_data_expiry_duration: NotRequired[pulumi.Input[_builtins.str]]
        """
        Controls how long we wait before expiring stale data. Example: `5m`.
        """
        blocksize_duration: NotRequired[pulumi.Input[_builtins.str]]
        """
        Controls how long to keep a block in memory before flushing to a fileset on disk. Example: `2h`.
        """
        buffer_future_duration: NotRequired[pulumi.Input[_builtins.str]]
        """
        Controls how far into the future writes to the namespace will be accepted. Example: `10m`.
        """
        buffer_past_duration: NotRequired[pulumi.Input[_builtins.str]]
        """
        Controls how far into the past writes to the namespace will be accepted. Example: `10m`.
        """
        retention_period_duration: NotRequired[pulumi.Input[_builtins.str]]
        """
        Controls the duration of time that M3DB will retain data for the namespace. Example: `48h`.
        """
elif False:
    M3DbM3dbUserConfigNamespaceOptionsRetentionOptionsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbM3dbUserConfigNamespaceOptionsRetentionOptionsArgs:
    def __init__(__self__, *,
                 block_data_expiry_duration: Optional[pulumi.Input[_builtins.str]] = None,
                 blocksize_duration: Optional[pulumi.Input[_builtins.str]] = None,
                 buffer_future_duration: Optional[pulumi.Input[_builtins.str]] = None,
                 buffer_past_duration: Optional[pulumi.Input[_builtins.str]] = None,
                 retention_period_duration: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] block_data_expiry_duration: Controls how long we wait before expiring stale data. Example: `5m`.
        :param pulumi.Input[_builtins.str] blocksize_duration: Controls how long to keep a block in memory before flushing to a fileset on disk. Example: `2h`.
        :param pulumi.Input[_builtins.str] buffer_future_duration: Controls how far into the future writes to the namespace will be accepted. Example: `10m`.
        :param pulumi.Input[_builtins.str] buffer_past_duration: Controls how far into the past writes to the namespace will be accepted. Example: `10m`.
        :param pulumi.Input[_builtins.str] retention_period_duration: Controls the duration of time that M3DB will retain data for the namespace. Example: `48h`.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="blockDataExpiryDuration")
    def block_data_expiry_duration(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Controls how long we wait before expiring stale data. Example: `5m`.
        """
        return pulumi.get(self, "block_data_expiry_duration")

    @block_data_expiry_duration.setter
    def block_data_expiry_duration(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "block_data_expiry_duration", value)

    @_builtins.property
    @pulumi.getter(name="blocksizeDuration")
    def blocksize_duration(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Controls how long to keep a block in memory before flushing to a fileset on disk. Example: `2h`.
        """
        return pulumi.get(self, "blocksize_duration")

    @blocksize_duration.setter
    def blocksize_duration(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "blocksize_duration", value)

    @_builtins.property
    @pulumi.getter(name="bufferFutureDuration")
    def buffer_future_duration(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Controls how far into the future writes to the namespace will be accepted. Example: `10m`.
        """
        return pulumi.get(self, "buffer_future_duration")

    @buffer_future_duration.setter
    def buffer_future_duration(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "buffer_future_duration", value)

    @_builtins.property
    @pulumi.getter(name="bufferPastDuration")
    def buffer_past_duration(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Controls how far into the past writes to the namespace will be accepted. Example: `10m`.
        """
        return pulumi.get(self, "buffer_past_duration")

    @buffer_past_duration.setter
    def buffer_past_duration(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "buffer_past_duration", value)

    @_builtins.property
    @pulumi.getter(name="retentionPeriodDuration")
    def retention_period_duration(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Controls the duration of time that M3DB will retain data for the namespace. Example: `48h`.
        """
        return pulumi.get(self, "retention_period_duration")

    @retention_period_duration.setter
    def retention_period_duration(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "retention_period_duration", value)


if not MYPY:
    class M3DbM3dbUserConfigPrivateAccessArgsDict(TypedDict):
        m3coordinator: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to m3coordinator with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
elif False:
    M3DbM3dbUserConfigPrivateAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbM3dbUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 m3coordinator: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] m3coordinator: Allow clients to connect to m3coordinator with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        if m3coordinator is not None:
            pulumi.set(__self__, "m3coordinator", m3coordinator)

    @_builtins.property
    @pulumi.getter
    def m3coordinator(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to m3coordinator with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "m3coordinator")

    @m3coordinator.setter
    def m3coordinator(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "m3coordinator", value)


if not MYPY:
    class M3DbM3dbUserConfigPublicAccessArgsDict(TypedDict):
        m3coordinator: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to m3coordinator from the public internet for service nodes that are in a project VPC or another type of private network.
        """
elif False:
    M3DbM3dbUserConfigPublicAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbM3dbUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 m3coordinator: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] m3coordinator: Allow clients to connect to m3coordinator from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        if m3coordinator is not None:
            pulumi.set(__self__, "m3coordinator", m3coordinator)

    @_builtins.property
    @pulumi.getter
    def m3coordinator(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to m3coordinator from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "m3coordinator")

    @m3coordinator.setter
    def m3coordinator(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "m3coordinator", value)


if not MYPY:
    class M3DbM3dbUserConfigRulesArgsDict(TypedDict):
        mappings: NotRequired[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingArgsDict']]]]
        """
        List of M3 mapping rules
        """
elif False:
    M3DbM3dbUserConfigRulesArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbM3dbUserConfigRulesArgs:
    def __init__(__self__, *,
                 mappings: Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingArgs']]] mappings: List of M3 mapping rules
        """
        if mappings is not None:
            pulumi.set(__self__, "mappings", mappings)

    @_builtins.property
    @pulumi.getter
    def mappings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingArgs']]]]:
        """
        List of M3 mapping rules
        """
        return pulumi.get(self, "mappings")

    @mappings.setter
    def mappings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingArgs']]]]):
        pulumi.set(self, "mappings", value)


if not MYPY:
    class M3DbM3dbUserConfigRulesMappingArgsDict(TypedDict):
        filter: pulumi.Input[_builtins.str]
        """
        Matching metric names with wildcards (using __name__:wildcard) or matching tags and their (optionally wildcarded) values. For value, ! can be used at start of value for negation, and multiple filters can be supplied using space as separator. Example: `__name__:disk_* host:important-42 mount:!*/sda`.
        """
        aggregations: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        List of aggregations to be applied.
        """
        drop: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Only store the derived metric (as specified in the roll-up rules), if any.
        """
        name: NotRequired[pulumi.Input[_builtins.str]]
        """
        The (optional) name of the rule. Example: `important disk metrics`.
        """
        namespaces: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        This rule will be used to store the metrics in the given namespace(s). If a namespace is target of rules, the global default aggregation will be automatically disabled. Note that specifying filters that match no namespaces whatsoever will be returned as an error. Filter the namespace by glob (=wildcards).
        """
        namespaces_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingNamespacesObjectArgsDict']]]]
        """
        This rule will be used to store the metrics in the given namespace(s). If a namespace is target of rules, the global default aggregation will be automatically disabled. Note that specifying filters that match no namespaces whatsoever will be returned as an error. Filter the namespace by exact match of retention period and resolution
        """
        namespaces_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        This rule will be used to store the metrics in the given namespace(s). If a namespace is target of rules, the global default aggregation will be automatically disabled. Note that specifying filters that match no namespaces whatsoever will be returned as an error. Filter the namespace by glob (=wildcards).
        """
        tags: NotRequired[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingTagArgsDict']]]]
        """
        List of tags to be appended to matching metrics
        """
elif False:
    M3DbM3dbUserConfigRulesMappingArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbM3dbUserConfigRulesMappingArgs:
    def __init__(__self__, *,
                 filter: pulumi.Input[_builtins.str],
                 aggregations: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 drop: Optional[pulumi.Input[_builtins.bool]] = None,
                 name: Optional[pulumi.Input[_builtins.str]] = None,
                 namespaces: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 namespaces_objects: Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingNamespacesObjectArgs']]]] = None,
                 namespaces_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 tags: Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingTagArgs']]]] = None):
        """
        :param pulumi.Input[_builtins.str] filter: Matching metric names with wildcards (using __name__:wildcard) or matching tags and their (optionally wildcarded) values. For value, ! can be used at start of value for negation, and multiple filters can be supplied using space as separator. Example: `__name__:disk_* host:important-42 mount:!*/sda`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] aggregations: List of aggregations to be applied.
        :param pulumi.Input[_builtins.bool] drop: Only store the derived metric (as specified in the roll-up rules), if any.
        :param pulumi.Input[_builtins.str] name: The (optional) name of the rule. Example: `important disk metrics`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] namespaces: This rule will be used to store the metrics in the given namespace(s). If a namespace is target of rules, the global default aggregation will be automatically disabled. Note that specifying filters that match no namespaces whatsoever will be returned as an error. Filter the namespace by glob (=wildcards).
        :param pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingNamespacesObjectArgs']]] namespaces_objects: This rule will be used to store the metrics in the given namespace(s). If a namespace is target of rules, the global default aggregation will be automatically disabled. Note that specifying filters that match no namespaces whatsoever will be returned as an error. Filter the namespace by exact match of retention period and resolution
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] namespaces_strings: This rule will be used to store the metrics in the given namespace(s). If a namespace is target of rules, the global default aggregation will be automatically disabled. Note that specifying filters that match no namespaces whatsoever will be returned as an error. Filter the namespace by glob (=wildcards).
        :param pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingTagArgs']]] tags: List of tags to be appended to matching metrics
        """
        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("""Deprecated. Use `namespaces_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""namespaces is deprecated: Deprecated. Use `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)

    @_builtins.property
    @pulumi.getter
    def filter(self) -> pulumi.Input[_builtins.str]:
        """
        Matching metric names with wildcards (using __name__:wildcard) or matching tags and their (optionally wildcarded) values. For value, ! can be used at start of value for negation, and multiple filters can be supplied using space as separator. Example: `__name__:disk_* host:important-42 mount:!*/sda`.
        """
        return pulumi.get(self, "filter")

    @filter.setter
    def filter(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "filter", value)

    @_builtins.property
    @pulumi.getter
    def aggregations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        List of aggregations to be applied.
        """
        return pulumi.get(self, "aggregations")

    @aggregations.setter
    def aggregations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "aggregations", value)

    @_builtins.property
    @pulumi.getter
    def drop(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Only store the derived metric (as specified in the roll-up rules), if any.
        """
        return pulumi.get(self, "drop")

    @drop.setter
    def drop(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "drop", value)

    @_builtins.property
    @pulumi.getter
    def name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The (optional) name of the rule. Example: `important disk metrics`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "name", value)

    @_builtins.property
    @pulumi.getter
    @_utilities.deprecated("""Deprecated. Use `namespaces_string` instead.""")
    def namespaces(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        This rule will be used to store the metrics in the given namespace(s). If a namespace is target of rules, the global default aggregation will be automatically disabled. Note that specifying filters that match no namespaces whatsoever will be returned as an error. Filter the namespace by glob (=wildcards).
        """
        return pulumi.get(self, "namespaces")

    @namespaces.setter
    def namespaces(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "namespaces", value)

    @_builtins.property
    @pulumi.getter(name="namespacesObjects")
    def namespaces_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingNamespacesObjectArgs']]]]:
        """
        This rule will be used to store the metrics in the given namespace(s). If a namespace is target of rules, the global default aggregation will be automatically disabled. Note that specifying filters that match no namespaces whatsoever will be returned as an error. Filter the namespace by exact match of retention period and resolution
        """
        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)

    @_builtins.property
    @pulumi.getter(name="namespacesStrings")
    def namespaces_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        This rule will be used to store the metrics in the given namespace(s). If a namespace is target of rules, the global default aggregation will be automatically disabled. Note that specifying filters that match no namespaces whatsoever will be returned as an error. Filter the namespace by glob (=wildcards).
        """
        return pulumi.get(self, "namespaces_strings")

    @namespaces_strings.setter
    def namespaces_strings(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "namespaces_strings", value)

    @_builtins.property
    @pulumi.getter
    def tags(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingTagArgs']]]]:
        """
        List of tags to be appended to matching metrics
        """
        return pulumi.get(self, "tags")

    @tags.setter
    def tags(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['M3DbM3dbUserConfigRulesMappingTagArgs']]]]):
        pulumi.set(self, "tags", value)


if not MYPY:
    class M3DbM3dbUserConfigRulesMappingNamespacesObjectArgsDict(TypedDict):
        resolution: pulumi.Input[_builtins.str]
        """
        The resolution for the matching namespace. Example: `30s`.
        """
        retention: NotRequired[pulumi.Input[_builtins.str]]
        """
        The retention period of the matching namespace. Example: `48h`.
        """
elif False:
    M3DbM3dbUserConfigRulesMappingNamespacesObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbM3dbUserConfigRulesMappingNamespacesObjectArgs:
    def __init__(__self__, *,
                 resolution: pulumi.Input[_builtins.str],
                 retention: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] resolution: The resolution for the matching namespace. Example: `30s`.
        :param pulumi.Input[_builtins.str] retention: The retention period of the matching namespace. Example: `48h`.
        """
        pulumi.set(__self__, "resolution", resolution)
        if retention is not None:
            pulumi.set(__self__, "retention", retention)

    @_builtins.property
    @pulumi.getter
    def resolution(self) -> pulumi.Input[_builtins.str]:
        """
        The resolution for the matching namespace. Example: `30s`.
        """
        return pulumi.get(self, "resolution")

    @resolution.setter
    def resolution(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "resolution", value)

    @_builtins.property
    @pulumi.getter
    def retention(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The retention period of the matching namespace. Example: `48h`.
        """
        return pulumi.get(self, "retention")

    @retention.setter
    def retention(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "retention", value)


if not MYPY:
    class M3DbM3dbUserConfigRulesMappingTagArgsDict(TypedDict):
        name: pulumi.Input[_builtins.str]
        """
        Name of the tag. Example: `my_tag`.
        """
        value: pulumi.Input[_builtins.str]
        """
        Value of the tag. Example: `my_value`.
        """
elif False:
    M3DbM3dbUserConfigRulesMappingTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbM3dbUserConfigRulesMappingTagArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[_builtins.str],
                 value: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] name: Name of the tag. Example: `my_tag`.
        :param pulumi.Input[_builtins.str] value: Value of the tag. Example: `my_value`.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def name(self) -> pulumi.Input[_builtins.str]:
        """
        Name of the tag. Example: `my_tag`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "name", value)

    @_builtins.property
    @pulumi.getter
    def value(self) -> pulumi.Input[_builtins.str]:
        """
        Value of the tag. Example: `my_value`.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "value", value)


if not MYPY:
    class M3DbServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    M3DbServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration
        :param pulumi.Input[_builtins.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)

    @_builtins.property
    @pulumi.getter(name="integrationType")
    def integration_type(self) -> pulumi.Input[_builtins.str]:
        """
        Type of the service integration
        """
        return pulumi.get(self, "integration_type")

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "integration_type", value)

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class M3DbTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    M3DbTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[_builtins.str],
                 value: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] key: Service tag key
        :param pulumi.Input[_builtins.str] value: Service tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def key(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "key", value)

    @_builtins.property
    @pulumi.getter
    def value(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag value
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "value", value)


if not MYPY:
    class M3DbTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    M3DbTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class M3DbTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

    @email.setter
    def email(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "email", value)


if not MYPY:
    class MySqlComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    MySqlComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class MySqlComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

    @_builtins.property
    @pulumi.getter
    def component(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Service component name
        """
        return pulumi.get(self, "component")

    @component.setter
    def component(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "component", value)

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

    @connection_uri.setter
    def connection_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "connection_uri", value)

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_authentication_method", value)

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

    @kafka_ssl_ca.setter
    def kafka_ssl_ca(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_ssl_ca", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def route(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Network access route
        """
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "route", value)

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ssl", value)

    @_builtins.property
    @pulumi.getter
    def usage(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        DNS usage name
        """
        return pulumi.get(self, "usage")

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "usage", value)


if not MYPY:
    class MySqlMysqlArgsDict(TypedDict):
        params: NotRequired[pulumi.Input[Sequence[pulumi.Input['MySqlMysqlParamArgsDict']]]]
        """
        MySQL connection parameters.
        """
        replica_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        MySQL replica URI for services with a replica.
        """
        standby_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        MySQL standby connection URIs.
        """
        syncing_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        MySQL syncing connection URIs.
        """
        uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        MySQL connection URIs.
        """
elif False:
    MySqlMysqlArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class MySqlMysqlArgs:
    def __init__(__self__, *,
                 params: Optional[pulumi.Input[Sequence[pulumi.Input['MySqlMysqlParamArgs']]]] = None,
                 replica_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 standby_uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 syncing_uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['MySqlMysqlParamArgs']]] params: MySQL connection parameters.
        :param pulumi.Input[_builtins.str] replica_uri: MySQL replica URI for services with a replica.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] standby_uris: MySQL standby connection URIs.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] syncing_uris: MySQL syncing connection URIs.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uris: MySQL connection URIs.
        """
        if params is not None:
            pulumi.set(__self__, "params", params)
        if replica_uri is not None:
            pulumi.set(__self__, "replica_uri", replica_uri)
        if standby_uris is not None:
            pulumi.set(__self__, "standby_uris", standby_uris)
        if syncing_uris is not None:
            pulumi.set(__self__, "syncing_uris", syncing_uris)
        if uris is not None:
            pulumi.set(__self__, "uris", uris)

    @_builtins.property
    @pulumi.getter
    def params(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MySqlMysqlParamArgs']]]]:
        """
        MySQL connection parameters.
        """
        return pulumi.get(self, "params")

    @params.setter
    def params(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['MySqlMysqlParamArgs']]]]):
        pulumi.set(self, "params", value)

    @_builtins.property
    @pulumi.getter(name="replicaUri")
    def replica_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        MySQL replica URI for services with a replica.
        """
        return pulumi.get(self, "replica_uri")

    @replica_uri.setter
    def replica_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "replica_uri", value)

    @_builtins.property
    @pulumi.getter(name="standbyUris")
    def standby_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        MySQL standby connection URIs.
        """
        return pulumi.get(self, "standby_uris")

    @standby_uris.setter
    def standby_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "standby_uris", value)

    @_builtins.property
    @pulumi.getter(name="syncingUris")
    def syncing_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        MySQL syncing connection URIs.
        """
        return pulumi.get(self, "syncing_uris")

    @syncing_uris.setter
    def syncing_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "syncing_uris", value)

    @_builtins.property
    @pulumi.getter
    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        MySQL connection URIs.
        """
        return pulumi.get(self, "uris")

    @uris.setter
    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "uris", value)


if not MYPY:
    class MySqlMysqlParamArgsDict(TypedDict):
        database_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Thr name of the primary MySQL database.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        MySQL host IP or name.
        """
        password: NotRequired[pulumi.Input[_builtins.str]]
        """
        The password for the admin service user.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        MySQL port.
        """
        sslmode: NotRequired[pulumi.Input[_builtins.str]]
        """
        MySQL SSL mode setting. Always set to "require".
        """
        user: NotRequired[pulumi.Input[_builtins.str]]
        """
        The username for the admin service user.
        """
elif False:
    MySqlMysqlParamArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class MySqlMysqlParamArgs:
    def __init__(__self__, *,
                 database_name: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 password: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 sslmode: Optional[pulumi.Input[_builtins.str]] = None,
                 user: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] database_name: Thr name of the primary MySQL database.
        :param pulumi.Input[_builtins.str] host: MySQL host IP or name.
        :param pulumi.Input[_builtins.str] password: The password for the admin service user.
        :param pulumi.Input[_builtins.int] port: MySQL port.
        :param pulumi.Input[_builtins.str] sslmode: MySQL SSL mode setting. Always set to "require".
        :param pulumi.Input[_builtins.str] user: The username for the admin service user.
        """
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if sslmode is not None:
            pulumi.set(__self__, "sslmode", sslmode)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @_builtins.property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Thr name of the primary MySQL database.
        """
        return pulumi.get(self, "database_name")

    @database_name.setter
    def database_name(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "database_name", value)

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        MySQL host IP or name.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The password for the admin service user.
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "password", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        MySQL port.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def sslmode(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        MySQL SSL mode setting. Always set to "require".
        """
        return pulumi.get(self, "sslmode")

    @sslmode.setter
    def sslmode(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "sslmode", value)

    @_builtins.property
    @pulumi.getter
    def user(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The username for the admin service user.
        """
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "user", value)


if not MYPY:
    class MySqlMysqlUserConfigArgsDict(TypedDict):
        additional_backup_regions: NotRequired[pulumi.Input[_builtins.str]]
        """
        Additional Cloud Regions for Backup Replication.
        """
        admin_password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Custom password for admin user. Defaults to random string. This must be set only when a new service is being created.
        """
        admin_username: NotRequired[pulumi.Input[_builtins.str]]
        """
        Custom username for admin user. This must be set only when a new service is being created. Example: `avnadmin`.
        """
        backup_hour: NotRequired[pulumi.Input[_builtins.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. Default: `0`.
        """
        backup_minute: NotRequired[pulumi.Input[_builtins.int]]
        """
        The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed. Default: `0`.
        """
        binlog_retention_period: NotRequired[pulumi.Input[_builtins.int]]
        """
        The minimum amount of time in seconds to keep binlog entries before deletion. This may be extended for services that require binlog entries for longer than the default for example if using the MySQL Debezium Kafka connector. Example: `600`.
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['MySqlMysqlUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        migration: NotRequired[pulumi.Input['MySqlMysqlUserConfigMigrationArgsDict']]
        """
        Migrate data from existing server
        """
        mysql: NotRequired[pulumi.Input['MySqlMysqlUserConfigMysqlArgsDict']]
        """
        mysql.conf configuration values
        """
        mysql_incremental_backup: NotRequired[pulumi.Input['MySqlMysqlUserConfigMysqlIncrementalBackupArgsDict']]
        """
        MySQL incremental backup configuration
        """
        mysql_version: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `8`, and newer. MySQL major version.
        """
        private_access: NotRequired[pulumi.Input['MySqlMysqlUserConfigPrivateAccessArgsDict']]
        """
        Allow access to selected service ports from private networks
        """
        privatelink_access: NotRequired[pulumi.Input['MySqlMysqlUserConfigPrivatelinkAccessArgsDict']]
        """
        Allow access to selected service components through Privatelink
        """
        project_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        public_access: NotRequired[pulumi.Input['MySqlMysqlUserConfigPublicAccessArgsDict']]
        """
        Allow access to selected service ports from the public Internet
        """
        recovery_target_time: NotRequired[pulumi.Input[_builtins.str]]
        """
        Recovery target time when forking a service. This has effect only when a new service is being created. Example: `2019-01-01 23:34:45`.
        """
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        service_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
elif False:
    MySqlMysqlUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class MySqlMysqlUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[_builtins.str]] = None,
                 admin_password: Optional[pulumi.Input[_builtins.str]] = None,
                 admin_username: Optional[pulumi.Input[_builtins.str]] = None,
                 backup_hour: Optional[pulumi.Input[_builtins.int]] = None,
                 backup_minute: Optional[pulumi.Input[_builtins.int]] = None,
                 binlog_retention_period: Optional[pulumi.Input[_builtins.int]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['MySqlMysqlUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 migration: Optional[pulumi.Input['MySqlMysqlUserConfigMigrationArgs']] = None,
                 mysql: Optional[pulumi.Input['MySqlMysqlUserConfigMysqlArgs']] = None,
                 mysql_incremental_backup: Optional[pulumi.Input['MySqlMysqlUserConfigMysqlIncrementalBackupArgs']] = None,
                 mysql_version: Optional[pulumi.Input[_builtins.str]] = None,
                 private_access: Optional[pulumi.Input['MySqlMysqlUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['MySqlMysqlUserConfigPrivatelinkAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 public_access: Optional[pulumi.Input['MySqlMysqlUserConfigPublicAccessArgs']] = None,
                 recovery_target_time: Optional[pulumi.Input[_builtins.str]] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 service_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[_builtins.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[_builtins.str] admin_username: Custom username for admin user. This must be set only when a new service is being created. Example: `avnadmin`.
        :param pulumi.Input[_builtins.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. Default: `0`.
        :param pulumi.Input[_builtins.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. Default: `0`.
        :param pulumi.Input[_builtins.int] binlog_retention_period: The minimum amount of time in seconds to keep binlog entries before deletion. This may be extended for services that require binlog entries for longer than the default for example if using the MySQL Debezium Kafka connector. Example: `600`.
        :param pulumi.Input[Sequence[pulumi.Input['MySqlMysqlUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input['MySqlMysqlUserConfigMigrationArgs'] migration: Migrate data from existing server
        :param pulumi.Input['MySqlMysqlUserConfigMysqlArgs'] mysql: mysql.conf configuration values
        :param pulumi.Input['MySqlMysqlUserConfigMysqlIncrementalBackupArgs'] mysql_incremental_backup: MySQL incremental backup configuration
        :param pulumi.Input[_builtins.str] mysql_version: Enum: `8`, and newer. MySQL major version.
        :param pulumi.Input['MySqlMysqlUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks
        :param pulumi.Input['MySqlMysqlUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink
        :param pulumi.Input[_builtins.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. Example: `anotherprojectname`.
        :param pulumi.Input['MySqlMysqlUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
        :param pulumi.Input[_builtins.str] recovery_target_time: Recovery target time when forking a service. This has effect only when a new service is being created. Example: `2019-01-01 23:34:45`.
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input[_builtins.str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        :param pulumi.Input[_builtins.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 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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `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_incremental_backup is not None:
            pulumi.set(__self__, "mysql_incremental_backup", mysql_incremental_backup)
        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_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        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)

    @_builtins.property
    @pulumi.getter(name="additionalBackupRegions")
    def additional_backup_regions(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @_builtins.property
    @pulumi.getter(name="adminPassword")
    def admin_password(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "admin_password", value)

    @_builtins.property
    @pulumi.getter(name="adminUsername")
    def admin_username(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Custom username for admin user. This must be set only when a new service is being created. Example: `avnadmin`.
        """
        return pulumi.get(self, "admin_username")

    @admin_username.setter
    def admin_username(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "admin_username", value)

    @_builtins.property
    @pulumi.getter(name="backupHour")
    def backup_hour(self) -> Optional[pulumi.Input[_builtins.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. Default: `0`.
        """
        return pulumi.get(self, "backup_hour")

    @backup_hour.setter
    def backup_hour(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "backup_hour", value)

    @_builtins.property
    @pulumi.getter(name="backupMinute")
    def backup_minute(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed. Default: `0`.
        """
        return pulumi.get(self, "backup_minute")

    @backup_minute.setter
    def backup_minute(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "backup_minute", value)

    @_builtins.property
    @pulumi.getter(name="binlogRetentionPeriod")
    def binlog_retention_period(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The minimum amount of time in seconds to keep binlog entries before deletion. This may be extended for services that require binlog entries for longer than the default for example if using the MySQL Debezium Kafka connector. Example: `600`.
        """
        return pulumi.get(self, "binlog_retention_period")

    @binlog_retention_period.setter
    def binlog_retention_period(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "binlog_retention_period", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['MySqlMysqlUserConfigIpFilterObjectArgs']]]]:
        """
        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['MySqlMysqlUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "ip_filters", value)

    @_builtins.property
    @pulumi.getter
    def migration(self) -> Optional[pulumi.Input['MySqlMysqlUserConfigMigrationArgs']]:
        """
        Migrate data from existing server
        """
        return pulumi.get(self, "migration")

    @migration.setter
    def migration(self, value: Optional[pulumi.Input['MySqlMysqlUserConfigMigrationArgs']]):
        pulumi.set(self, "migration", value)

    @_builtins.property
    @pulumi.getter
    def mysql(self) -> Optional[pulumi.Input['MySqlMysqlUserConfigMysqlArgs']]:
        """
        mysql.conf configuration values
        """
        return pulumi.get(self, "mysql")

    @mysql.setter
    def mysql(self, value: Optional[pulumi.Input['MySqlMysqlUserConfigMysqlArgs']]):
        pulumi.set(self, "mysql", value)

    @_builtins.property
    @pulumi.getter(name="mysqlIncrementalBackup")
    def mysql_incremental_backup(self) -> Optional[pulumi.Input['MySqlMysqlUserConfigMysqlIncrementalBackupArgs']]:
        """
        MySQL incremental backup configuration
        """
        return pulumi.get(self, "mysql_incremental_backup")

    @mysql_incremental_backup.setter
    def mysql_incremental_backup(self, value: Optional[pulumi.Input['MySqlMysqlUserConfigMysqlIncrementalBackupArgs']]):
        pulumi.set(self, "mysql_incremental_backup", value)

    @_builtins.property
    @pulumi.getter(name="mysqlVersion")
    def mysql_version(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `8`, and newer. MySQL major version.
        """
        return pulumi.get(self, "mysql_version")

    @mysql_version.setter
    def mysql_version(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "mysql_version", value)

    @_builtins.property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['MySqlMysqlUserConfigPrivateAccessArgs']]:
        """
        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['MySqlMysqlUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @_builtins.property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['MySqlMysqlUserConfigPrivatelinkAccessArgs']]:
        """
        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['MySqlMysqlUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)

    @_builtins.property
    @pulumi.getter(name="projectToForkFrom")
    def project_to_fork_from(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        return pulumi.get(self, "project_to_fork_from")

    @project_to_fork_from.setter
    def project_to_fork_from(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "project_to_fork_from", value)

    @_builtins.property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['MySqlMysqlUserConfigPublicAccessArgs']]:
        """
        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['MySqlMysqlUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

    @_builtins.property
    @pulumi.getter(name="recoveryTargetTime")
    def recovery_target_time(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Recovery target time when forking a service. This has effect only when a new service is being created. Example: `2019-01-01 23:34:45`.
        """
        return pulumi.get(self, "recovery_target_time")

    @recovery_target_time.setter
    def recovery_target_time(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "recovery_target_time", value)

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

    @service_log.setter
    def service_log(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "service_log", value)

    @_builtins.property
    @pulumi.getter(name="serviceToForkFrom")
    def service_to_fork_from(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        return pulumi.get(self, "service_to_fork_from")

    @service_to_fork_from.setter
    def service_to_fork_from(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "service_to_fork_from", value)

    @_builtins.property
    @pulumi.getter(name="staticIps")
    def static_ips(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Use static public IP addresses.
        """
        return pulumi.get(self, "static_ips")

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "static_ips", value)


if not MYPY:
    class MySqlMysqlUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    MySqlMysqlUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class MySqlMysqlUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "network", value)

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "description", value)


if not MYPY:
    class MySqlMysqlUserConfigMigrationArgsDict(TypedDict):
        host: pulumi.Input[_builtins.str]
        """
        Hostname or IP address of the server where to migrate data from. Example: `my.server.com`.
        """
        port: pulumi.Input[_builtins.int]
        """
        Port number of the server where to migrate data from. Example: `1234`.
        """
        dbname: NotRequired[pulumi.Input[_builtins.str]]
        """
        Database name for bootstrapping the initial connection. Example: `defaultdb`.
        """
        dump_tool: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `mydumper`, `mysqldump`. Experimental! Tool to use for database dump and restore during migration. Default: mysqldump.
        """
        ignore_dbs: NotRequired[pulumi.Input[_builtins.str]]
        """
        Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
        """
        ignore_roles: NotRequired[pulumi.Input[_builtins.str]]
        """
        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
        """
        method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
        """
        password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
        """
        reestablish_replication: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Skip dump-restore part and start replication. Default: `false`.
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        The server where to migrate data from is secured with SSL. Default: `true`.
        """
        username: NotRequired[pulumi.Input[_builtins.str]]
        """
        User name for authentication with the server where to migrate data from. Example: `myname`.
        """
elif False:
    MySqlMysqlUserConfigMigrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class MySqlMysqlUserConfigMigrationArgs:
    def __init__(__self__, *,
                 host: pulumi.Input[_builtins.str],
                 port: pulumi.Input[_builtins.int],
                 dbname: Optional[pulumi.Input[_builtins.str]] = None,
                 dump_tool: Optional[pulumi.Input[_builtins.str]] = None,
                 ignore_dbs: Optional[pulumi.Input[_builtins.str]] = None,
                 ignore_roles: Optional[pulumi.Input[_builtins.str]] = None,
                 method: Optional[pulumi.Input[_builtins.str]] = None,
                 password: Optional[pulumi.Input[_builtins.str]] = None,
                 reestablish_replication: Optional[pulumi.Input[_builtins.bool]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 username: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] host: Hostname or IP address of the server where to migrate data from. Example: `my.server.com`.
        :param pulumi.Input[_builtins.int] port: Port number of the server where to migrate data from. Example: `1234`.
        :param pulumi.Input[_builtins.str] dbname: Database name for bootstrapping the initial connection. Example: `defaultdb`.
        :param pulumi.Input[_builtins.str] dump_tool: Enum: `mydumper`, `mysqldump`. Experimental! Tool to use for database dump and restore during migration. Default: mysqldump.
        :param pulumi.Input[_builtins.str] ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
        :param pulumi.Input[_builtins.str] ignore_roles: Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
        :param pulumi.Input[_builtins.str] method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
        :param pulumi.Input[_builtins.str] password: Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
        :param pulumi.Input[_builtins.bool] reestablish_replication: Skip dump-restore part and start replication. Default: `false`.
        :param pulumi.Input[_builtins.bool] ssl: The server where to migrate data from is secured with SSL. Default: `true`.
        :param pulumi.Input[_builtins.str] username: User name for authentication with the server where to migrate data from. Example: `myname`.
        """
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)
        if dbname is not None:
            pulumi.set(__self__, "dbname", dbname)
        if dump_tool is not None:
            pulumi.set(__self__, "dump_tool", dump_tool)
        if ignore_dbs is not None:
            pulumi.set(__self__, "ignore_dbs", ignore_dbs)
        if ignore_roles is not None:
            pulumi.set(__self__, "ignore_roles", ignore_roles)
        if method is not None:
            pulumi.set(__self__, "method", method)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if reestablish_replication is not None:
            pulumi.set(__self__, "reestablish_replication", reestablish_replication)
        if ssl is not None:
            pulumi.set(__self__, "ssl", ssl)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @_builtins.property
    @pulumi.getter
    def host(self) -> pulumi.Input[_builtins.str]:
        """
        Hostname or IP address of the server where to migrate data from. Example: `my.server.com`.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> pulumi.Input[_builtins.int]:
        """
        Port number of the server where to migrate data from. Example: `1234`.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def dbname(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Database name for bootstrapping the initial connection. Example: `defaultdb`.
        """
        return pulumi.get(self, "dbname")

    @dbname.setter
    def dbname(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "dbname", value)

    @_builtins.property
    @pulumi.getter(name="dumpTool")
    def dump_tool(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `mydumper`, `mysqldump`. Experimental! Tool to use for database dump and restore during migration. Default: mysqldump.
        """
        return pulumi.get(self, "dump_tool")

    @dump_tool.setter
    def dump_tool(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "dump_tool", value)

    @_builtins.property
    @pulumi.getter(name="ignoreDbs")
    def ignore_dbs(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
        """
        return pulumi.get(self, "ignore_dbs")

    @ignore_dbs.setter
    def ignore_dbs(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ignore_dbs", value)

    @_builtins.property
    @pulumi.getter(name="ignoreRoles")
    def ignore_roles(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
        """
        return pulumi.get(self, "ignore_roles")

    @ignore_roles.setter
    def ignore_roles(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ignore_roles", value)

    @_builtins.property
    @pulumi.getter
    def method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
        """
        return pulumi.get(self, "method")

    @method.setter
    def method(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "method", value)

    @_builtins.property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "password", value)

    @_builtins.property
    @pulumi.getter(name="reestablishReplication")
    def reestablish_replication(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Skip dump-restore part and start replication. Default: `false`.
        """
        return pulumi.get(self, "reestablish_replication")

    @reestablish_replication.setter
    def reestablish_replication(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "reestablish_replication", value)

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        The server where to migrate data from is secured with SSL. Default: `true`.
        """
        return pulumi.get(self, "ssl")

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ssl", value)

    @_builtins.property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        User name for authentication with the server where to migrate data from. Example: `myname`.
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "username", value)


if not MYPY:
    class MySqlMysqlUserConfigMysqlArgsDict(TypedDict):
        connect_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of seconds that the mysqld server waits for a connect packet before responding with Bad handshake. Example: `10`.
        """
        default_time_zone: NotRequired[pulumi.Input[_builtins.str]]
        """
        Default server time zone as an offset from UTC (from -12:00 to +12:00), a time zone name, or `SYSTEM` to use the MySQL server default. Example: `+03:00`.
        """
        group_concat_max_len: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum permitted result length in bytes for the GROUP_CONCAT() function. Example: `1024`.
        """
        information_schema_stats_expiry: NotRequired[pulumi.Input[_builtins.int]]
        """
        The time, in seconds, before cached statistics expire. Example: `86400`.
        """
        innodb_change_buffer_max_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum size for the InnoDB change buffer, as a percentage of the total size of the buffer pool. Default is 25. Example: `30`.
        """
        innodb_flush_neighbors: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies whether flushing a page from the InnoDB buffer pool also flushes other dirty pages in the same extent (default is 1): 0 - dirty pages in the same extent are not flushed, 1 - flush contiguous dirty pages in the same extent, 2 - flush dirty pages in the same extent. Example: `0`.
        """
        innodb_ft_min_token_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Minimum length of words that are stored in an InnoDB FULLTEXT index. Changing this parameter will lead to a restart of the MySQL service. Example: `3`.
        """
        innodb_ft_server_stopword_table: NotRequired[pulumi.Input[_builtins.str]]
        """
        This option is used to specify your own InnoDB FULLTEXT index stopword list for all InnoDB tables. Example: `db_name/table_name`.
        """
        innodb_lock_wait_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        The length of time in seconds an InnoDB transaction waits for a row lock before giving up. Default is 120. Example: `50`.
        """
        innodb_log_buffer_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        The size in bytes of the buffer that InnoDB uses to write to the log files on disk.
        """
        innodb_online_alter_log_max_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        The upper limit in bytes on the size of the temporary log files used during online DDL operations for InnoDB tables.
        """
        innodb_print_all_deadlocks: NotRequired[pulumi.Input[_builtins.bool]]
        """
        When enabled, information about all deadlocks in InnoDB user transactions is recorded in the error log. Disabled by default.
        """
        innodb_read_io_threads: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of I/O threads for read operations in InnoDB. Default is 4. Changing this parameter will lead to a restart of the MySQL service. Example: `10`.
        """
        innodb_rollback_on_timeout: NotRequired[pulumi.Input[_builtins.bool]]
        """
        When enabled a transaction timeout causes InnoDB to abort and roll back the entire transaction. Changing this parameter will lead to a restart of the MySQL service.
        """
        innodb_thread_concurrency: NotRequired[pulumi.Input[_builtins.int]]
        """
        Defines the maximum number of threads permitted inside of InnoDB. Default is 0 (infinite concurrency - no limit). Example: `10`.
        """
        innodb_write_io_threads: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of I/O threads for write operations in InnoDB. Default is 4. Changing this parameter will lead to a restart of the MySQL service. Example: `10`.
        """
        interactive_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of seconds the server waits for activity on an interactive connection before closing it. Example: `3600`.
        """
        internal_tmp_mem_storage_engine: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `MEMORY`, `TempTable`. The storage engine for in-memory internal temporary tables.
        """
        log_output: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `INSIGHTS`, `INSIGHTS,TABLE`, `NONE`, `TABLE`. The slow log output destination when slow*query*log is ON. To enable MySQL AI Insights, choose INSIGHTS. To use MySQL AI Insights and the mysql.slow*log table at the same time, choose INSIGHTS,TABLE. To only use the mysql.slow*log table, choose TABLE. To silence slow logs, choose NONE.
        """
        long_query_time: NotRequired[pulumi.Input[_builtins.float]]
        """
        The slow*query*logs work as SQL statements that take more than long*query*time seconds to execute. Example: `10`.
        """
        max_allowed_packet: NotRequired[pulumi.Input[_builtins.int]]
        """
        Size of the largest message in bytes that can be received by the server. Default is 67108864 (64M).
        """
        max_heap_table_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Limits the size of internal in-memory tables. Also set tmp*table*size. Default is 16777216 (16M).
        """
        net_buffer_length: NotRequired[pulumi.Input[_builtins.int]]
        """
        Start sizes of connection buffer and result buffer. Default is 16384 (16K). Changing this parameter will lead to a restart of the MySQL service. Example: `16384`.
        """
        net_read_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of seconds to wait for more data from a connection before aborting the read. Example: `30`.
        """
        net_write_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of seconds to wait for a block to be written to a connection before aborting the write. Example: `30`.
        """
        slow_query_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Slow query log enables capturing of slow queries. Setting slow*query*log to false also truncates the mysql.slow_log table.
        """
        sort_buffer_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Sort buffer size in bytes for ORDER BY optimization. Default is 262144 (256K). Example: `262144`.
        """
        sql_mode: NotRequired[pulumi.Input[_builtins.str]]
        """
        Global SQL mode. Set to empty to use MySQL server defaults. When creating a new service and not setting this field Aiven default SQL mode (strict, SQL standard compliant) will be assigned. Example: `ANSI,TRADITIONAL`.
        """
        sql_require_primary_key: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Require primary key to be defined for new tables or old tables modified with ALTER TABLE and fail if missing. It is recommended to always have primary keys because various functionality may break if any large table is missing them.
        """
        tmp_table_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Limits the size of internal in-memory tables. Also set max*heap*table_size. Default is 16777216 (16M).
        """
        wait_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of seconds the server waits for activity on a noninteractive connection before closing it. Example: `28800`.
        """
elif False:
    MySqlMysqlUserConfigMysqlArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class MySqlMysqlUserConfigMysqlArgs:
    def __init__(__self__, *,
                 connect_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 default_time_zone: Optional[pulumi.Input[_builtins.str]] = None,
                 group_concat_max_len: Optional[pulumi.Input[_builtins.int]] = None,
                 information_schema_stats_expiry: Optional[pulumi.Input[_builtins.int]] = None,
                 innodb_change_buffer_max_size: Optional[pulumi.Input[_builtins.int]] = None,
                 innodb_flush_neighbors: Optional[pulumi.Input[_builtins.int]] = None,
                 innodb_ft_min_token_size: Optional[pulumi.Input[_builtins.int]] = None,
                 innodb_ft_server_stopword_table: Optional[pulumi.Input[_builtins.str]] = None,
                 innodb_lock_wait_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 innodb_log_buffer_size: Optional[pulumi.Input[_builtins.int]] = None,
                 innodb_online_alter_log_max_size: Optional[pulumi.Input[_builtins.int]] = None,
                 innodb_print_all_deadlocks: Optional[pulumi.Input[_builtins.bool]] = None,
                 innodb_read_io_threads: Optional[pulumi.Input[_builtins.int]] = None,
                 innodb_rollback_on_timeout: Optional[pulumi.Input[_builtins.bool]] = None,
                 innodb_thread_concurrency: Optional[pulumi.Input[_builtins.int]] = None,
                 innodb_write_io_threads: Optional[pulumi.Input[_builtins.int]] = None,
                 interactive_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 internal_tmp_mem_storage_engine: Optional[pulumi.Input[_builtins.str]] = None,
                 log_output: Optional[pulumi.Input[_builtins.str]] = None,
                 long_query_time: Optional[pulumi.Input[_builtins.float]] = None,
                 max_allowed_packet: Optional[pulumi.Input[_builtins.int]] = None,
                 max_heap_table_size: Optional[pulumi.Input[_builtins.int]] = None,
                 net_buffer_length: Optional[pulumi.Input[_builtins.int]] = None,
                 net_read_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 net_write_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 slow_query_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 sort_buffer_size: Optional[pulumi.Input[_builtins.int]] = None,
                 sql_mode: Optional[pulumi.Input[_builtins.str]] = None,
                 sql_require_primary_key: Optional[pulumi.Input[_builtins.bool]] = None,
                 tmp_table_size: Optional[pulumi.Input[_builtins.int]] = None,
                 wait_timeout: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.int] connect_timeout: The number of seconds that the mysqld server waits for a connect packet before responding with Bad handshake. Example: `10`.
        :param pulumi.Input[_builtins.str] default_time_zone: Default server time zone as an offset from UTC (from -12:00 to +12:00), a time zone name, or `SYSTEM` to use the MySQL server default. Example: `+03:00`.
        :param pulumi.Input[_builtins.int] group_concat_max_len: The maximum permitted result length in bytes for the GROUP_CONCAT() function. Example: `1024`.
        :param pulumi.Input[_builtins.int] information_schema_stats_expiry: The time, in seconds, before cached statistics expire. Example: `86400`.
        :param pulumi.Input[_builtins.int] innodb_change_buffer_max_size: Maximum size for the InnoDB change buffer, as a percentage of the total size of the buffer pool. Default is 25. Example: `30`.
        :param pulumi.Input[_builtins.int] innodb_flush_neighbors: Specifies whether flushing a page from the InnoDB buffer pool also flushes other dirty pages in the same extent (default is 1): 0 - dirty pages in the same extent are not flushed, 1 - flush contiguous dirty pages in the same extent, 2 - flush dirty pages in the same extent. Example: `0`.
        :param pulumi.Input[_builtins.int] innodb_ft_min_token_size: Minimum length of words that are stored in an InnoDB FULLTEXT index. Changing this parameter will lead to a restart of the MySQL service. Example: `3`.
        :param pulumi.Input[_builtins.str] innodb_ft_server_stopword_table: This option is used to specify your own InnoDB FULLTEXT index stopword list for all InnoDB tables. Example: `db_name/table_name`.
        :param pulumi.Input[_builtins.int] innodb_lock_wait_timeout: The length of time in seconds an InnoDB transaction waits for a row lock before giving up. Default is 120. Example: `50`.
        :param pulumi.Input[_builtins.int] innodb_log_buffer_size: The size in bytes of the buffer that InnoDB uses to write to the log files on disk.
        :param pulumi.Input[_builtins.int] innodb_online_alter_log_max_size: The upper limit in bytes on the size of the temporary log files used during online DDL operations for InnoDB tables.
        :param pulumi.Input[_builtins.bool] innodb_print_all_deadlocks: When enabled, information about all deadlocks in InnoDB user transactions is recorded in the error log. Disabled by default.
        :param pulumi.Input[_builtins.int] innodb_read_io_threads: The number of I/O threads for read operations in InnoDB. Default is 4. Changing this parameter will lead to a restart of the MySQL service. Example: `10`.
        :param pulumi.Input[_builtins.bool] innodb_rollback_on_timeout: When enabled a transaction timeout causes InnoDB to abort and roll back the entire transaction. Changing this parameter will lead to a restart of the MySQL service.
        :param pulumi.Input[_builtins.int] innodb_thread_concurrency: Defines the maximum number of threads permitted inside of InnoDB. Default is 0 (infinite concurrency - no limit). Example: `10`.
        :param pulumi.Input[_builtins.int] innodb_write_io_threads: The number of I/O threads for write operations in InnoDB. Default is 4. Changing this parameter will lead to a restart of the MySQL service. Example: `10`.
        :param pulumi.Input[_builtins.int] interactive_timeout: The number of seconds the server waits for activity on an interactive connection before closing it. Example: `3600`.
        :param pulumi.Input[_builtins.str] internal_tmp_mem_storage_engine: Enum: `MEMORY`, `TempTable`. The storage engine for in-memory internal temporary tables.
        :param pulumi.Input[_builtins.str] log_output: Enum: `INSIGHTS`, `INSIGHTS,TABLE`, `NONE`, `TABLE`. The slow log output destination when slow*query*log is ON. To enable MySQL AI Insights, choose INSIGHTS. To use MySQL AI Insights and the mysql.slow*log table at the same time, choose INSIGHTS,TABLE. To only use the mysql.slow*log table, choose TABLE. To silence slow logs, choose NONE.
        :param pulumi.Input[_builtins.float] long_query_time: The slow*query*logs work as SQL statements that take more than long*query*time seconds to execute. Example: `10`.
        :param pulumi.Input[_builtins.int] max_allowed_packet: Size of the largest message in bytes that can be received by the server. Default is 67108864 (64M).
        :param pulumi.Input[_builtins.int] max_heap_table_size: Limits the size of internal in-memory tables. Also set tmp*table*size. Default is 16777216 (16M).
        :param pulumi.Input[_builtins.int] net_buffer_length: Start sizes of connection buffer and result buffer. Default is 16384 (16K). Changing this parameter will lead to a restart of the MySQL service. Example: `16384`.
        :param pulumi.Input[_builtins.int] net_read_timeout: The number of seconds to wait for more data from a connection before aborting the read. Example: `30`.
        :param pulumi.Input[_builtins.int] net_write_timeout: The number of seconds to wait for a block to be written to a connection before aborting the write. Example: `30`.
        :param pulumi.Input[_builtins.bool] slow_query_log: Slow query log enables capturing of slow queries. Setting slow*query*log to false also truncates the mysql.slow_log table.
        :param pulumi.Input[_builtins.int] sort_buffer_size: Sort buffer size in bytes for ORDER BY optimization. Default is 262144 (256K). Example: `262144`.
        :param pulumi.Input[_builtins.str] sql_mode: Global SQL mode. Set to empty to use MySQL server defaults. When creating a new service and not setting this field Aiven default SQL mode (strict, SQL standard compliant) will be assigned. Example: `ANSI,TRADITIONAL`.
        :param pulumi.Input[_builtins.bool] sql_require_primary_key: Require primary key to be defined for new tables or old tables modified with ALTER TABLE and fail if missing. It is recommended to always have primary keys because various functionality may break if any large table is missing them.
        :param pulumi.Input[_builtins.int] tmp_table_size: Limits the size of internal in-memory tables. Also set max*heap*table_size. Default is 16777216 (16M).
        :param pulumi.Input[_builtins.int] wait_timeout: The number of seconds the server waits for activity on a noninteractive connection before closing it. Example: `28800`.
        """
        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 log_output is not None:
            pulumi.set(__self__, "log_output", log_output)
        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)

    @_builtins.property
    @pulumi.getter(name="connectTimeout")
    def connect_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of seconds that the mysqld server waits for a connect packet before responding with Bad handshake. Example: `10`.
        """
        return pulumi.get(self, "connect_timeout")

    @connect_timeout.setter
    def connect_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "connect_timeout", value)

    @_builtins.property
    @pulumi.getter(name="defaultTimeZone")
    def default_time_zone(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Default server time zone as an offset from UTC (from -12:00 to +12:00), a time zone name, or `SYSTEM` to use the MySQL server default. Example: `+03:00`.
        """
        return pulumi.get(self, "default_time_zone")

    @default_time_zone.setter
    def default_time_zone(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "default_time_zone", value)

    @_builtins.property
    @pulumi.getter(name="groupConcatMaxLen")
    def group_concat_max_len(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum permitted result length in bytes for the GROUP_CONCAT() function. Example: `1024`.
        """
        return pulumi.get(self, "group_concat_max_len")

    @group_concat_max_len.setter
    def group_concat_max_len(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "group_concat_max_len", value)

    @_builtins.property
    @pulumi.getter(name="informationSchemaStatsExpiry")
    def information_schema_stats_expiry(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The time, in seconds, before cached statistics expire. Example: `86400`.
        """
        return pulumi.get(self, "information_schema_stats_expiry")

    @information_schema_stats_expiry.setter
    def information_schema_stats_expiry(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "information_schema_stats_expiry", value)

    @_builtins.property
    @pulumi.getter(name="innodbChangeBufferMaxSize")
    def innodb_change_buffer_max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum size for the InnoDB change buffer, as a percentage of the total size of the buffer pool. Default is 25. Example: `30`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "innodb_change_buffer_max_size", value)

    @_builtins.property
    @pulumi.getter(name="innodbFlushNeighbors")
    def innodb_flush_neighbors(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies whether flushing a page from the InnoDB buffer pool also flushes other dirty pages in the same extent (default is 1): 0 - dirty pages in the same extent are not flushed, 1 - flush contiguous dirty pages in the same extent, 2 - flush dirty pages in the same extent. Example: `0`.
        """
        return pulumi.get(self, "innodb_flush_neighbors")

    @innodb_flush_neighbors.setter
    def innodb_flush_neighbors(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "innodb_flush_neighbors", value)

    @_builtins.property
    @pulumi.getter(name="innodbFtMinTokenSize")
    def innodb_ft_min_token_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Minimum length of words that are stored in an InnoDB FULLTEXT index. Changing this parameter will lead to a restart of the MySQL service. Example: `3`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "innodb_ft_min_token_size", value)

    @_builtins.property
    @pulumi.getter(name="innodbFtServerStopwordTable")
    def innodb_ft_server_stopword_table(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        This option is used to specify your own InnoDB FULLTEXT index stopword list for all InnoDB tables. Example: `db_name/table_name`.
        """
        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[_builtins.str]]):
        pulumi.set(self, "innodb_ft_server_stopword_table", value)

    @_builtins.property
    @pulumi.getter(name="innodbLockWaitTimeout")
    def innodb_lock_wait_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The length of time in seconds an InnoDB transaction waits for a row lock before giving up. Default is 120. Example: `50`.
        """
        return pulumi.get(self, "innodb_lock_wait_timeout")

    @innodb_lock_wait_timeout.setter
    def innodb_lock_wait_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "innodb_lock_wait_timeout", value)

    @_builtins.property
    @pulumi.getter(name="innodbLogBufferSize")
    def innodb_log_buffer_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The size in bytes of the buffer that InnoDB uses to write to the log files on disk.
        """
        return pulumi.get(self, "innodb_log_buffer_size")

    @innodb_log_buffer_size.setter
    def innodb_log_buffer_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "innodb_log_buffer_size", value)

    @_builtins.property
    @pulumi.getter(name="innodbOnlineAlterLogMaxSize")
    def innodb_online_alter_log_max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The upper limit in bytes on the size of the temporary log files used during online DDL operations for InnoDB tables.
        """
        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[_builtins.int]]):
        pulumi.set(self, "innodb_online_alter_log_max_size", value)

    @_builtins.property
    @pulumi.getter(name="innodbPrintAllDeadlocks")
    def innodb_print_all_deadlocks(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        When enabled, information about all deadlocks in InnoDB user transactions is recorded in the error log. Disabled by default.
        """
        return pulumi.get(self, "innodb_print_all_deadlocks")

    @innodb_print_all_deadlocks.setter
    def innodb_print_all_deadlocks(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "innodb_print_all_deadlocks", value)

    @_builtins.property
    @pulumi.getter(name="innodbReadIoThreads")
    def innodb_read_io_threads(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of I/O threads for read operations in InnoDB. Default is 4. Changing this parameter will lead to a restart of the MySQL service. Example: `10`.
        """
        return pulumi.get(self, "innodb_read_io_threads")

    @innodb_read_io_threads.setter
    def innodb_read_io_threads(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "innodb_read_io_threads", value)

    @_builtins.property
    @pulumi.getter(name="innodbRollbackOnTimeout")
    def innodb_rollback_on_timeout(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        When enabled a transaction timeout causes InnoDB to abort and roll back the entire transaction. Changing this parameter will lead to a restart of the MySQL service.
        """
        return pulumi.get(self, "innodb_rollback_on_timeout")

    @innodb_rollback_on_timeout.setter
    def innodb_rollback_on_timeout(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "innodb_rollback_on_timeout", value)

    @_builtins.property
    @pulumi.getter(name="innodbThreadConcurrency")
    def innodb_thread_concurrency(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Defines the maximum number of threads permitted inside of InnoDB. Default is 0 (infinite concurrency - no limit). Example: `10`.
        """
        return pulumi.get(self, "innodb_thread_concurrency")

    @innodb_thread_concurrency.setter
    def innodb_thread_concurrency(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "innodb_thread_concurrency", value)

    @_builtins.property
    @pulumi.getter(name="innodbWriteIoThreads")
    def innodb_write_io_threads(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of I/O threads for write operations in InnoDB. Default is 4. Changing this parameter will lead to a restart of the MySQL service. Example: `10`.
        """
        return pulumi.get(self, "innodb_write_io_threads")

    @innodb_write_io_threads.setter
    def innodb_write_io_threads(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "innodb_write_io_threads", value)

    @_builtins.property
    @pulumi.getter(name="interactiveTimeout")
    def interactive_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of seconds the server waits for activity on an interactive connection before closing it. Example: `3600`.
        """
        return pulumi.get(self, "interactive_timeout")

    @interactive_timeout.setter
    def interactive_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "interactive_timeout", value)

    @_builtins.property
    @pulumi.getter(name="internalTmpMemStorageEngine")
    def internal_tmp_mem_storage_engine(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `MEMORY`, `TempTable`. The storage engine for in-memory internal temporary tables.
        """
        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[_builtins.str]]):
        pulumi.set(self, "internal_tmp_mem_storage_engine", value)

    @_builtins.property
    @pulumi.getter(name="logOutput")
    def log_output(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `INSIGHTS`, `INSIGHTS,TABLE`, `NONE`, `TABLE`. The slow log output destination when slow*query*log is ON. To enable MySQL AI Insights, choose INSIGHTS. To use MySQL AI Insights and the mysql.slow*log table at the same time, choose INSIGHTS,TABLE. To only use the mysql.slow*log table, choose TABLE. To silence slow logs, choose NONE.
        """
        return pulumi.get(self, "log_output")

    @log_output.setter
    def log_output(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "log_output", value)

    @_builtins.property
    @pulumi.getter(name="longQueryTime")
    def long_query_time(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The slow*query*logs work as SQL statements that take more than long*query*time seconds to execute. Example: `10`.
        """
        return pulumi.get(self, "long_query_time")

    @long_query_time.setter
    def long_query_time(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "long_query_time", value)

    @_builtins.property
    @pulumi.getter(name="maxAllowedPacket")
    def max_allowed_packet(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Size of the largest message in bytes that can be received by the server. Default is 67108864 (64M).
        """
        return pulumi.get(self, "max_allowed_packet")

    @max_allowed_packet.setter
    def max_allowed_packet(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_allowed_packet", value)

    @_builtins.property
    @pulumi.getter(name="maxHeapTableSize")
    def max_heap_table_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Limits the size of internal in-memory tables. Also set tmp*table*size. Default is 16777216 (16M).
        """
        return pulumi.get(self, "max_heap_table_size")

    @max_heap_table_size.setter
    def max_heap_table_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_heap_table_size", value)

    @_builtins.property
    @pulumi.getter(name="netBufferLength")
    def net_buffer_length(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Start sizes of connection buffer and result buffer. Default is 16384 (16K). Changing this parameter will lead to a restart of the MySQL service. Example: `16384`.
        """
        return pulumi.get(self, "net_buffer_length")

    @net_buffer_length.setter
    def net_buffer_length(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "net_buffer_length", value)

    @_builtins.property
    @pulumi.getter(name="netReadTimeout")
    def net_read_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of seconds to wait for more data from a connection before aborting the read. Example: `30`.
        """
        return pulumi.get(self, "net_read_timeout")

    @net_read_timeout.setter
    def net_read_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "net_read_timeout", value)

    @_builtins.property
    @pulumi.getter(name="netWriteTimeout")
    def net_write_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of seconds to wait for a block to be written to a connection before aborting the write. Example: `30`.
        """
        return pulumi.get(self, "net_write_timeout")

    @net_write_timeout.setter
    def net_write_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "net_write_timeout", value)

    @_builtins.property
    @pulumi.getter(name="slowQueryLog")
    def slow_query_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Slow query log enables capturing of slow queries. Setting slow*query*log to false also truncates the mysql.slow_log table.
        """
        return pulumi.get(self, "slow_query_log")

    @slow_query_log.setter
    def slow_query_log(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "slow_query_log", value)

    @_builtins.property
    @pulumi.getter(name="sortBufferSize")
    def sort_buffer_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Sort buffer size in bytes for ORDER BY optimization. Default is 262144 (256K). Example: `262144`.
        """
        return pulumi.get(self, "sort_buffer_size")

    @sort_buffer_size.setter
    def sort_buffer_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "sort_buffer_size", value)

    @_builtins.property
    @pulumi.getter(name="sqlMode")
    def sql_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Global SQL mode. Set to empty to use MySQL server defaults. When creating a new service and not setting this field Aiven default SQL mode (strict, SQL standard compliant) will be assigned. Example: `ANSI,TRADITIONAL`.
        """
        return pulumi.get(self, "sql_mode")

    @sql_mode.setter
    def sql_mode(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "sql_mode", value)

    @_builtins.property
    @pulumi.getter(name="sqlRequirePrimaryKey")
    def sql_require_primary_key(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Require primary key to be defined for new tables or old tables modified with ALTER TABLE and fail if missing. It is recommended to always have primary keys because various functionality may break if any large table is missing them.
        """
        return pulumi.get(self, "sql_require_primary_key")

    @sql_require_primary_key.setter
    def sql_require_primary_key(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "sql_require_primary_key", value)

    @_builtins.property
    @pulumi.getter(name="tmpTableSize")
    def tmp_table_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Limits the size of internal in-memory tables. Also set max*heap*table_size. Default is 16777216 (16M).
        """
        return pulumi.get(self, "tmp_table_size")

    @tmp_table_size.setter
    def tmp_table_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "tmp_table_size", value)

    @_builtins.property
    @pulumi.getter(name="waitTimeout")
    def wait_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of seconds the server waits for activity on a noninteractive connection before closing it. Example: `28800`.
        """
        return pulumi.get(self, "wait_timeout")

    @wait_timeout.setter
    def wait_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "wait_timeout", value)


if not MYPY:
    class MySqlMysqlUserConfigMysqlIncrementalBackupArgsDict(TypedDict):
        enabled: pulumi.Input[_builtins.bool]
        """
        Enable periodic incremental backups. When enabled, full*backup*week_schedule must be set. Incremental backups only store changes since the last backup, making them faster and more storage-efficient than full backups. This is particularly useful for large databases where daily full backups would be too time-consuming or expensive.
        """
        full_backup_week_schedule: NotRequired[pulumi.Input[_builtins.str]]
        """
        Comma-separated list of days of the week when full backups should be created. Valid values: mon, tue, wed, thu, fri, sat, sun. Example: `sun,wed`.
        """
elif False:
    MySqlMysqlUserConfigMysqlIncrementalBackupArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class MySqlMysqlUserConfigMysqlIncrementalBackupArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[_builtins.bool],
                 full_backup_week_schedule: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.bool] enabled: Enable periodic incremental backups. When enabled, full*backup*week_schedule must be set. Incremental backups only store changes since the last backup, making them faster and more storage-efficient than full backups. This is particularly useful for large databases where daily full backups would be too time-consuming or expensive.
        :param pulumi.Input[_builtins.str] full_backup_week_schedule: Comma-separated list of days of the week when full backups should be created. Valid values: mon, tue, wed, thu, fri, sat, sun. Example: `sun,wed`.
        """
        pulumi.set(__self__, "enabled", enabled)
        if full_backup_week_schedule is not None:
            pulumi.set(__self__, "full_backup_week_schedule", full_backup_week_schedule)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> pulumi.Input[_builtins.bool]:
        """
        Enable periodic incremental backups. When enabled, full*backup*week_schedule must be set. Incremental backups only store changes since the last backup, making them faster and more storage-efficient than full backups. This is particularly useful for large databases where daily full backups would be too time-consuming or expensive.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: pulumi.Input[_builtins.bool]):
        pulumi.set(self, "enabled", value)

    @_builtins.property
    @pulumi.getter(name="fullBackupWeekSchedule")
    def full_backup_week_schedule(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Comma-separated list of days of the week when full backups should be created. Valid values: mon, tue, wed, thu, fri, sat, sun. Example: `sun,wed`.
        """
        return pulumi.get(self, "full_backup_week_schedule")

    @full_backup_week_schedule.setter
    def full_backup_week_schedule(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "full_backup_week_schedule", value)


if not MYPY:
    class MySqlMysqlUserConfigPrivateAccessArgsDict(TypedDict):
        mysql: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to mysql with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        mysqlx: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to mysqlx with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
elif False:
    MySqlMysqlUserConfigPrivateAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class MySqlMysqlUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 mysql: Optional[pulumi.Input[_builtins.bool]] = None,
                 mysqlx: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] mysql: Allow clients to connect to mysql with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] mysqlx: Allow clients to connect to mysqlx with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        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)

    @_builtins.property
    @pulumi.getter
    def mysql(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to mysql with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "mysql")

    @mysql.setter
    def mysql(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "mysql", value)

    @_builtins.property
    @pulumi.getter
    def mysqlx(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to mysqlx with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "mysqlx")

    @mysqlx.setter
    def mysqlx(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "mysqlx", value)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "prometheus", value)


if not MYPY:
    class MySqlMysqlUserConfigPrivatelinkAccessArgsDict(TypedDict):
        mysql: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable mysql.
        """
        mysqlx: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable mysqlx.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable prometheus.
        """
elif False:
    MySqlMysqlUserConfigPrivatelinkAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class MySqlMysqlUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 mysql: Optional[pulumi.Input[_builtins.bool]] = None,
                 mysqlx: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] mysql: Enable mysql.
        :param pulumi.Input[_builtins.bool] mysqlx: Enable mysqlx.
        :param pulumi.Input[_builtins.bool] prometheus: Enable prometheus.
        """
        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)

    @_builtins.property
    @pulumi.getter
    def mysql(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable mysql.
        """
        return pulumi.get(self, "mysql")

    @mysql.setter
    def mysql(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "mysql", value)

    @_builtins.property
    @pulumi.getter
    def mysqlx(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable mysqlx.
        """
        return pulumi.get(self, "mysqlx")

    @mysqlx.setter
    def mysqlx(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "mysqlx", value)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable prometheus.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "prometheus", value)


if not MYPY:
    class MySqlMysqlUserConfigPublicAccessArgsDict(TypedDict):
        mysql: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to mysql from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        mysqlx: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to mysqlx from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
elif False:
    MySqlMysqlUserConfigPublicAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class MySqlMysqlUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 mysql: Optional[pulumi.Input[_builtins.bool]] = None,
                 mysqlx: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] mysql: Allow clients to connect to mysql from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] mysqlx: Allow clients to connect to mysqlx from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        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)

    @_builtins.property
    @pulumi.getter
    def mysql(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to mysql from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "mysql")

    @mysql.setter
    def mysql(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "mysql", value)

    @_builtins.property
    @pulumi.getter
    def mysqlx(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to mysqlx from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "mysqlx")

    @mysqlx.setter
    def mysqlx(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "mysqlx", value)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "prometheus", value)


if not MYPY:
    class MySqlServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration. The possible value is `read_replica`.
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    MySqlServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class MySqlServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration. The possible value is `read_replica`.
        :param pulumi.Input[_builtins.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)

    @_builtins.property
    @pulumi.getter(name="integrationType")
    def integration_type(self) -> pulumi.Input[_builtins.str]:
        """
        Type of the service integration. The possible value is `read_replica`.
        """
        return pulumi.get(self, "integration_type")

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "integration_type", value)

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class MySqlTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    MySqlTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class MySqlTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[_builtins.str],
                 value: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] key: Service tag key
        :param pulumi.Input[_builtins.str] value: Service tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def key(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "key", value)

    @_builtins.property
    @pulumi.getter
    def value(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag value
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "value", value)


if not MYPY:
    class MySqlTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    MySqlTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class MySqlTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

    @email.setter
    def email(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "email", value)


if not MYPY:
    class MysqlDatabaseTimeoutsArgsDict(TypedDict):
        create: NotRequired[pulumi.Input[_builtins.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).
        """
        default: NotRequired[pulumi.Input[_builtins.str]]
        """
        Timeout for all operations. Deprecated, use operation-specific timeouts instead.
        """
        delete: NotRequired[pulumi.Input[_builtins.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.
        """
        read: NotRequired[pulumi.Input[_builtins.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.
        """
        update: NotRequired[pulumi.Input[_builtins.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).
        """
elif False:
    MysqlDatabaseTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class MysqlDatabaseTimeoutsArgs:
    def __init__(__self__, *,
                 create: Optional[pulumi.Input[_builtins.str]] = None,
                 default: Optional[pulumi.Input[_builtins.str]] = None,
                 delete: Optional[pulumi.Input[_builtins.str]] = None,
                 read: Optional[pulumi.Input[_builtins.str]] = None,
                 update: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.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[_builtins.str] default: Timeout for all operations. Deprecated, use operation-specific timeouts instead.
        :param pulumi.Input[_builtins.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[_builtins.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[_builtins.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 default is not None:
            warnings.warn("""Use operation-specific timeouts instead. This field will be removed in the next major version.""", DeprecationWarning)
            pulumi.log.warn("""default is deprecated: Use operation-specific timeouts instead. This field will be removed in the next major version.""")
        if default is not None:
            pulumi.set(__self__, "default", default)
        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)

    @_builtins.property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "create", value)

    @_builtins.property
    @pulumi.getter
    @_utilities.deprecated("""Use operation-specific timeouts instead. This field will be removed in the next major version.""")
    def default(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Timeout for all operations. Deprecated, use operation-specific timeouts instead.
        """
        return pulumi.get(self, "default")

    @default.setter
    def default(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "default", value)

    @_builtins.property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "delete", value)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "read", value)

    @_builtins.property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "update", value)


if not MYPY:
    class MysqlUserTimeoutsArgsDict(TypedDict):
        create: NotRequired[pulumi.Input[_builtins.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).
        """
        default: NotRequired[pulumi.Input[_builtins.str]]
        """
        Timeout for all operations. Deprecated, use operation-specific timeouts instead.
        """
        delete: NotRequired[pulumi.Input[_builtins.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.
        """
        read: NotRequired[pulumi.Input[_builtins.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.
        """
        update: NotRequired[pulumi.Input[_builtins.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).
        """
elif False:
    MysqlUserTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class MysqlUserTimeoutsArgs:
    def __init__(__self__, *,
                 create: Optional[pulumi.Input[_builtins.str]] = None,
                 default: Optional[pulumi.Input[_builtins.str]] = None,
                 delete: Optional[pulumi.Input[_builtins.str]] = None,
                 read: Optional[pulumi.Input[_builtins.str]] = None,
                 update: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.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[_builtins.str] default: Timeout for all operations. Deprecated, use operation-specific timeouts instead.
        :param pulumi.Input[_builtins.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[_builtins.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[_builtins.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 default is not None:
            warnings.warn("""Use operation-specific timeouts instead. This field will be removed in the next major version.""", DeprecationWarning)
            pulumi.log.warn("""default is deprecated: Use operation-specific timeouts instead. This field will be removed in the next major version.""")
        if default is not None:
            pulumi.set(__self__, "default", default)
        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)

    @_builtins.property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "create", value)

    @_builtins.property
    @pulumi.getter
    @_utilities.deprecated("""Use operation-specific timeouts instead. This field will be removed in the next major version.""")
    def default(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Timeout for all operations. Deprecated, use operation-specific timeouts instead.
        """
        return pulumi.get(self, "default")

    @default.setter
    def default(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "default", value)

    @_builtins.property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "delete", value)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "read", value)

    @_builtins.property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "update", value)


if not MYPY:
    class OpenSearchComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    OpenSearchComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

    @_builtins.property
    @pulumi.getter
    def component(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Service component name
        """
        return pulumi.get(self, "component")

    @component.setter
    def component(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "component", value)

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

    @connection_uri.setter
    def connection_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "connection_uri", value)

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_authentication_method", value)

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

    @kafka_ssl_ca.setter
    def kafka_ssl_ca(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_ssl_ca", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def route(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Network access route
        """
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "route", value)

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ssl", value)

    @_builtins.property
    @pulumi.getter
    def usage(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        DNS usage name
        """
        return pulumi.get(self, "usage")

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "usage", value)


if not MYPY:
    class OpenSearchOpensearchArgsDict(TypedDict):
        kibana_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        URI for Kibana dashboard frontend.
        """
        opensearch_dashboards_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        URI for OpenSearch dashboard frontend.
        """
        password: NotRequired[pulumi.Input[_builtins.str]]
        """
        OpenSearch password.
        """
        uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        OpenSearch server URIs.
        """
        username: NotRequired[pulumi.Input[_builtins.str]]
        """
        OpenSearch username.
        """
elif False:
    OpenSearchOpensearchArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchArgs:
    def __init__(__self__, *,
                 kibana_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 opensearch_dashboards_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 password: Optional[pulumi.Input[_builtins.str]] = None,
                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 username: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] kibana_uri: URI for Kibana dashboard frontend.
        :param pulumi.Input[_builtins.str] opensearch_dashboards_uri: URI for OpenSearch dashboard frontend.
        :param pulumi.Input[_builtins.str] password: OpenSearch password.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uris: OpenSearch server URIs.
        :param pulumi.Input[_builtins.str] username: OpenSearch username.
        """
        if kibana_uri is not None:
            warnings.warn("""This field was added by mistake and has never worked. It will be removed in future versions.""", DeprecationWarning)
            pulumi.log.warn("""kibana_uri is deprecated: This field was added by mistake and has never worked. It will be removed in future versions.""")
        if kibana_uri is not None:
            pulumi.set(__self__, "kibana_uri", kibana_uri)
        if opensearch_dashboards_uri is not None:
            pulumi.set(__self__, "opensearch_dashboards_uri", opensearch_dashboards_uri)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if uris is not None:
            pulumi.set(__self__, "uris", uris)
        if username is not None:
            pulumi.set(__self__, "username", username)

    @_builtins.property
    @pulumi.getter(name="kibanaUri")
    @_utilities.deprecated("""This field was added by mistake and has never worked. It will be removed in future versions.""")
    def kibana_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        URI for Kibana dashboard frontend.
        """
        return pulumi.get(self, "kibana_uri")

    @kibana_uri.setter
    def kibana_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kibana_uri", value)

    @_builtins.property
    @pulumi.getter(name="opensearchDashboardsUri")
    def opensearch_dashboards_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        URI for OpenSearch dashboard frontend.
        """
        return pulumi.get(self, "opensearch_dashboards_uri")

    @opensearch_dashboards_uri.setter
    def opensearch_dashboards_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "opensearch_dashboards_uri", value)

    @_builtins.property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        OpenSearch password.
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "password", value)

    @_builtins.property
    @pulumi.getter
    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        OpenSearch server URIs.
        """
        return pulumi.get(self, "uris")

    @uris.setter
    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "uris", value)

    @_builtins.property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        OpenSearch username.
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "username", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigArgsDict(TypedDict):
        additional_backup_regions: NotRequired[pulumi.Input[_builtins.str]]
        """
        Additional Cloud Regions for Backup Replication.
        """
        azure_migration: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigAzureMigrationArgsDict']]
        """
        Azure migration settings
        """
        custom_domain: NotRequired[pulumi.Input[_builtins.str]]
        """
        Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. When you set a custom domain for a service deployed in a VPC, the service certificate is only created for the public-* hostname and the custom domain. Example: `grafana.example.org`.
        """
        disable_replication_factor_adjustment: NotRequired[pulumi.Input[_builtins.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 not be activated unless specifically allowed for the project.
        """
        gcs_migration: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigGcsMigrationArgsDict']]
        """
        Google Cloud Storage migration settings
        """
        index_patterns: NotRequired[pulumi.Input[Sequence[pulumi.Input['OpenSearchOpensearchUserConfigIndexPatternArgsDict']]]]
        """
        Index patterns
        """
        index_rollup: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigIndexRollupArgsDict']]
        """
        Index rollup settings
        """
        index_template: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigIndexTemplateArgsDict']]
        """
        Template settings for all new indexes
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['OpenSearchOpensearchUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        jwt: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigJwtArgsDict']]
        """
        OpenSearch JWT Configuration
        """
        keep_index_refresh_interval: NotRequired[pulumi.Input[_builtins.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.
        """
        max_index_count: NotRequired[pulumi.Input[_builtins.int]]
        """
        Use index_patterns instead. Default: `0`.
        """
        openid: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpenidArgsDict']]
        """
        OpenSearch OpenID Connect Configuration
        """
        opensearch: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchArgsDict']]
        """
        OpenSearch settings
        """
        opensearch_dashboards: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchDashboardsArgsDict']]
        """
        OpenSearch Dashboards settings
        """
        opensearch_version: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `1`, `2`, `2.19`, and newer. OpenSearch version.
        """
        private_access: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigPrivateAccessArgsDict']]
        """
        Allow access to selected service ports from private networks
        """
        privatelink_access: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigPrivatelinkAccessArgsDict']]
        """
        Allow access to selected service components through Privatelink
        """
        project_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        public_access: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigPublicAccessArgsDict']]
        """
        Allow access to selected service ports from the public Internet
        """
        recovery_basebackup_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of the basebackup to restore in forked service. Example: `backup-20191112t091354293891z`.
        """
        s3_migration: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigS3MigrationArgsDict']]
        """
        AWS S3 / AWS S3 compatible migration settings
        """
        saml: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigSamlArgsDict']]
        """
        OpenSearch SAML configuration
        """
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        service_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
elif False:
    OpenSearchOpensearchUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[_builtins.str]] = None,
                 azure_migration: Optional[pulumi.Input['OpenSearchOpensearchUserConfigAzureMigrationArgs']] = None,
                 custom_domain: Optional[pulumi.Input[_builtins.str]] = None,
                 disable_replication_factor_adjustment: Optional[pulumi.Input[_builtins.bool]] = None,
                 gcs_migration: Optional[pulumi.Input['OpenSearchOpensearchUserConfigGcsMigrationArgs']] = None,
                 index_patterns: Optional[pulumi.Input[Sequence[pulumi.Input['OpenSearchOpensearchUserConfigIndexPatternArgs']]]] = None,
                 index_rollup: Optional[pulumi.Input['OpenSearchOpensearchUserConfigIndexRollupArgs']] = 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[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 jwt: Optional[pulumi.Input['OpenSearchOpensearchUserConfigJwtArgs']] = None,
                 keep_index_refresh_interval: Optional[pulumi.Input[_builtins.bool]] = None,
                 max_index_count: Optional[pulumi.Input[_builtins.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[_builtins.str]] = None,
                 private_access: Optional[pulumi.Input['OpenSearchOpensearchUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['OpenSearchOpensearchUserConfigPrivatelinkAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 public_access: Optional[pulumi.Input['OpenSearchOpensearchUserConfigPublicAccessArgs']] = None,
                 recovery_basebackup_name: Optional[pulumi.Input[_builtins.str]] = None,
                 s3_migration: Optional[pulumi.Input['OpenSearchOpensearchUserConfigS3MigrationArgs']] = None,
                 saml: Optional[pulumi.Input['OpenSearchOpensearchUserConfigSamlArgs']] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 service_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input['OpenSearchOpensearchUserConfigAzureMigrationArgs'] azure_migration: Azure migration settings
        :param pulumi.Input[_builtins.str] custom_domain: Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. When you set a custom domain for a service deployed in a VPC, the service certificate is only created for the public-* hostname and the custom domain. Example: `grafana.example.org`.
        :param pulumi.Input[_builtins.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 not be activated unless specifically allowed for the project.
        :param pulumi.Input['OpenSearchOpensearchUserConfigGcsMigrationArgs'] gcs_migration: Google Cloud Storage migration settings
        :param pulumi.Input[Sequence[pulumi.Input['OpenSearchOpensearchUserConfigIndexPatternArgs']]] index_patterns: Index patterns
        :param pulumi.Input['OpenSearchOpensearchUserConfigIndexRollupArgs'] index_rollup: Index rollup settings
        :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[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input['OpenSearchOpensearchUserConfigJwtArgs'] jwt: OpenSearch JWT Configuration
        :param pulumi.Input[_builtins.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[_builtins.int] max_index_count: Use index_patterns instead. Default: `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[_builtins.str] opensearch_version: Enum: `1`, `2`, `2.19`, and newer. OpenSearch 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[_builtins.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. Example: `anotherprojectname`.
        :param pulumi.Input['OpenSearchOpensearchUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
        :param pulumi.Input[_builtins.str] recovery_basebackup_name: Name of the basebackup to restore in forked service. Example: `backup-20191112t091354293891z`.
        :param pulumi.Input['OpenSearchOpensearchUserConfigS3MigrationArgs'] s3_migration: AWS S3 / AWS S3 compatible migration settings
        :param pulumi.Input['OpenSearchOpensearchUserConfigSamlArgs'] saml: OpenSearch SAML configuration
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input[_builtins.str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        :param pulumi.Input[_builtins.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 azure_migration is not None:
            pulumi.set(__self__, "azure_migration", azure_migration)
        if custom_domain is not None:
            pulumi.set(__self__, "custom_domain", custom_domain)
        if disable_replication_factor_adjustment is not None:
            pulumi.set(__self__, "disable_replication_factor_adjustment", disable_replication_factor_adjustment)
        if gcs_migration is not None:
            pulumi.set(__self__, "gcs_migration", gcs_migration)
        if index_patterns is not None:
            pulumi.set(__self__, "index_patterns", index_patterns)
        if index_rollup is not None:
            pulumi.set(__self__, "index_rollup", index_rollup)
        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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `ip_filter_string` instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        if jwt is not None:
            pulumi.set(__self__, "jwt", jwt)
        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:
            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 s3_migration is not None:
            pulumi.set(__self__, "s3_migration", s3_migration)
        if saml is not None:
            pulumi.set(__self__, "saml", saml)
        if service_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        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)

    @_builtins.property
    @pulumi.getter(name="additionalBackupRegions")
    def additional_backup_regions(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @_builtins.property
    @pulumi.getter(name="azureMigration")
    def azure_migration(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigAzureMigrationArgs']]:
        """
        Azure migration settings
        """
        return pulumi.get(self, "azure_migration")

    @azure_migration.setter
    def azure_migration(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigAzureMigrationArgs']]):
        pulumi.set(self, "azure_migration", value)

    @_builtins.property
    @pulumi.getter(name="customDomain")
    def custom_domain(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Serve the web frontend using a custom CNAME pointing to the Aiven DNS name. When you set a custom domain for a service deployed in a VPC, the service certificate is only created for the public-* hostname and the custom domain. Example: `grafana.example.org`.
        """
        return pulumi.get(self, "custom_domain")

    @custom_domain.setter
    def custom_domain(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "custom_domain", value)

    @_builtins.property
    @pulumi.getter(name="disableReplicationFactorAdjustment")
    def disable_replication_factor_adjustment(self) -> Optional[pulumi.Input[_builtins.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 not be activated unless specifically allowed for the project.
        """
        return pulumi.get(self, "disable_replication_factor_adjustment")

    @disable_replication_factor_adjustment.setter
    def disable_replication_factor_adjustment(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "disable_replication_factor_adjustment", value)

    @_builtins.property
    @pulumi.getter(name="gcsMigration")
    def gcs_migration(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigGcsMigrationArgs']]:
        """
        Google Cloud Storage migration settings
        """
        return pulumi.get(self, "gcs_migration")

    @gcs_migration.setter
    def gcs_migration(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigGcsMigrationArgs']]):
        pulumi.set(self, "gcs_migration", value)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="indexRollup")
    def index_rollup(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigIndexRollupArgs']]:
        """
        Index rollup settings
        """
        return pulumi.get(self, "index_rollup")

    @index_rollup.setter
    def index_rollup(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigIndexRollupArgs']]):
        pulumi.set(self, "index_rollup", value)

    @_builtins.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)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "ip_filters", value)

    @_builtins.property
    @pulumi.getter
    def jwt(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigJwtArgs']]:
        """
        OpenSearch JWT Configuration
        """
        return pulumi.get(self, "jwt")

    @jwt.setter
    def jwt(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigJwtArgs']]):
        pulumi.set(self, "jwt", value)

    @_builtins.property
    @pulumi.getter(name="keepIndexRefreshInterval")
    def keep_index_refresh_interval(self) -> Optional[pulumi.Input[_builtins.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[_builtins.bool]]):
        pulumi.set(self, "keep_index_refresh_interval", value)

    @_builtins.property
    @pulumi.getter(name="maxIndexCount")
    def max_index_count(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Use index_patterns instead. Default: `0`.
        """
        return pulumi.get(self, "max_index_count")

    @max_index_count.setter
    def max_index_count(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_index_count", value)

    @_builtins.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)

    @_builtins.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)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="opensearchVersion")
    def opensearch_version(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `1`, `2`, `2.19`, and newer. OpenSearch version.
        """
        return pulumi.get(self, "opensearch_version")

    @opensearch_version.setter
    def opensearch_version(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "opensearch_version", value)

    @_builtins.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)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="projectToForkFrom")
    def project_to_fork_from(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        return pulumi.get(self, "project_to_fork_from")

    @project_to_fork_from.setter
    def project_to_fork_from(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "project_to_fork_from", value)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="recoveryBasebackupName")
    def recovery_basebackup_name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of the basebackup to restore in forked service. Example: `backup-20191112t091354293891z`.
        """
        return pulumi.get(self, "recovery_basebackup_name")

    @recovery_basebackup_name.setter
    def recovery_basebackup_name(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "recovery_basebackup_name", value)

    @_builtins.property
    @pulumi.getter(name="s3Migration")
    def s3_migration(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigS3MigrationArgs']]:
        """
        AWS S3 / AWS S3 compatible migration settings
        """
        return pulumi.get(self, "s3_migration")

    @s3_migration.setter
    def s3_migration(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigS3MigrationArgs']]):
        pulumi.set(self, "s3_migration", value)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

    @service_log.setter
    def service_log(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "service_log", value)

    @_builtins.property
    @pulumi.getter(name="serviceToForkFrom")
    def service_to_fork_from(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        return pulumi.get(self, "service_to_fork_from")

    @service_to_fork_from.setter
    def service_to_fork_from(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "service_to_fork_from", value)

    @_builtins.property
    @pulumi.getter(name="staticIps")
    def static_ips(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Use static public IP addresses.
        """
        return pulumi.get(self, "static_ips")

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "static_ips", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigAzureMigrationArgsDict(TypedDict):
        account: pulumi.Input[_builtins.str]
        """
        Account name.
        """
        base_path: pulumi.Input[_builtins.str]
        """
        The path to the repository data within its container. The value of this setting should not start or end with a /.
        """
        container: pulumi.Input[_builtins.str]
        """
        Azure container name.
        """
        indices: pulumi.Input[_builtins.str]
        """
        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
        """
        snapshot_name: pulumi.Input[_builtins.str]
        """
        The snapshot name to restore from.
        """
        chunk_size: NotRequired[pulumi.Input[_builtins.str]]
        """
        Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
        """
        compress: NotRequired[pulumi.Input[_builtins.bool]]
        """
        When set to true metadata files are stored in compressed format.
        """
        endpoint_suffix: NotRequired[pulumi.Input[_builtins.str]]
        """
        Defines the DNS suffix for Azure Storage endpoints.
        """
        include_aliases: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether to restore aliases alongside their associated indexes. Default is true.
        """
        key: NotRequired[pulumi.Input[_builtins.str]]
        """
        Azure account secret key. One of key or sas_token should be specified.
        """
        readonly: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the repository is read-only. Default: `true`.
        """
        restore_global_state: NotRequired[pulumi.Input[_builtins.bool]]
        """
        If true, restore the cluster state. Defaults to false.
        """
        sas_token: NotRequired[pulumi.Input[_builtins.str]]
        """
        A shared access signatures (SAS) token. One of key or sas_token should be specified.
        """
elif False:
    OpenSearchOpensearchUserConfigAzureMigrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigAzureMigrationArgs:
    def __init__(__self__, *,
                 account: pulumi.Input[_builtins.str],
                 base_path: pulumi.Input[_builtins.str],
                 container: pulumi.Input[_builtins.str],
                 indices: pulumi.Input[_builtins.str],
                 snapshot_name: pulumi.Input[_builtins.str],
                 chunk_size: Optional[pulumi.Input[_builtins.str]] = None,
                 compress: Optional[pulumi.Input[_builtins.bool]] = None,
                 endpoint_suffix: Optional[pulumi.Input[_builtins.str]] = None,
                 include_aliases: Optional[pulumi.Input[_builtins.bool]] = None,
                 key: Optional[pulumi.Input[_builtins.str]] = None,
                 readonly: Optional[pulumi.Input[_builtins.bool]] = None,
                 restore_global_state: Optional[pulumi.Input[_builtins.bool]] = None,
                 sas_token: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] account: Account name.
        :param pulumi.Input[_builtins.str] base_path: The path to the repository data within its container. The value of this setting should not start or end with a /.
        :param pulumi.Input[_builtins.str] container: Azure container name.
        :param pulumi.Input[_builtins.str] indices: A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
        :param pulumi.Input[_builtins.str] snapshot_name: The snapshot name to restore from.
        :param pulumi.Input[_builtins.str] chunk_size: Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
        :param pulumi.Input[_builtins.bool] compress: When set to true metadata files are stored in compressed format.
        :param pulumi.Input[_builtins.str] endpoint_suffix: Defines the DNS suffix for Azure Storage endpoints.
        :param pulumi.Input[_builtins.bool] include_aliases: Whether to restore aliases alongside their associated indexes. Default is true.
        :param pulumi.Input[_builtins.str] key: Azure account secret key. One of key or sas_token should be specified.
        :param pulumi.Input[_builtins.bool] readonly: Whether the repository is read-only. Default: `true`.
        :param pulumi.Input[_builtins.bool] restore_global_state: If true, restore the cluster state. Defaults to false.
        :param pulumi.Input[_builtins.str] sas_token: A shared access signatures (SAS) token. One of key or sas_token should be specified.
        """
        pulumi.set(__self__, "account", account)
        pulumi.set(__self__, "base_path", base_path)
        pulumi.set(__self__, "container", container)
        pulumi.set(__self__, "indices", indices)
        pulumi.set(__self__, "snapshot_name", snapshot_name)
        if chunk_size is not None:
            pulumi.set(__self__, "chunk_size", chunk_size)
        if compress is not None:
            pulumi.set(__self__, "compress", compress)
        if endpoint_suffix is not None:
            pulumi.set(__self__, "endpoint_suffix", endpoint_suffix)
        if include_aliases is not None:
            pulumi.set(__self__, "include_aliases", include_aliases)
        if key is not None:
            pulumi.set(__self__, "key", key)
        if readonly is not None:
            pulumi.set(__self__, "readonly", readonly)
        if restore_global_state is not None:
            pulumi.set(__self__, "restore_global_state", restore_global_state)
        if sas_token is not None:
            pulumi.set(__self__, "sas_token", sas_token)

    @_builtins.property
    @pulumi.getter
    def account(self) -> pulumi.Input[_builtins.str]:
        """
        Account name.
        """
        return pulumi.get(self, "account")

    @account.setter
    def account(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "account", value)

    @_builtins.property
    @pulumi.getter(name="basePath")
    def base_path(self) -> pulumi.Input[_builtins.str]:
        """
        The path to the repository data within its container. The value of this setting should not start or end with a /.
        """
        return pulumi.get(self, "base_path")

    @base_path.setter
    def base_path(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "base_path", value)

    @_builtins.property
    @pulumi.getter
    def container(self) -> pulumi.Input[_builtins.str]:
        """
        Azure container name.
        """
        return pulumi.get(self, "container")

    @container.setter
    def container(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "container", value)

    @_builtins.property
    @pulumi.getter
    def indices(self) -> pulumi.Input[_builtins.str]:
        """
        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
        """
        return pulumi.get(self, "indices")

    @indices.setter
    def indices(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "indices", value)

    @_builtins.property
    @pulumi.getter(name="snapshotName")
    def snapshot_name(self) -> pulumi.Input[_builtins.str]:
        """
        The snapshot name to restore from.
        """
        return pulumi.get(self, "snapshot_name")

    @snapshot_name.setter
    def snapshot_name(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "snapshot_name", value)

    @_builtins.property
    @pulumi.getter(name="chunkSize")
    def chunk_size(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
        """
        return pulumi.get(self, "chunk_size")

    @chunk_size.setter
    def chunk_size(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "chunk_size", value)

    @_builtins.property
    @pulumi.getter
    def compress(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        When set to true metadata files are stored in compressed format.
        """
        return pulumi.get(self, "compress")

    @compress.setter
    def compress(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "compress", value)

    @_builtins.property
    @pulumi.getter(name="endpointSuffix")
    def endpoint_suffix(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Defines the DNS suffix for Azure Storage endpoints.
        """
        return pulumi.get(self, "endpoint_suffix")

    @endpoint_suffix.setter
    def endpoint_suffix(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "endpoint_suffix", value)

    @_builtins.property
    @pulumi.getter(name="includeAliases")
    def include_aliases(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether to restore aliases alongside their associated indexes. Default is true.
        """
        return pulumi.get(self, "include_aliases")

    @include_aliases.setter
    def include_aliases(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "include_aliases", value)

    @_builtins.property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Azure account secret key. One of key or sas_token should be specified.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "key", value)

    @_builtins.property
    @pulumi.getter
    def readonly(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the repository is read-only. Default: `true`.
        """
        return pulumi.get(self, "readonly")

    @readonly.setter
    def readonly(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "readonly", value)

    @_builtins.property
    @pulumi.getter(name="restoreGlobalState")
    def restore_global_state(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        If true, restore the cluster state. Defaults to false.
        """
        return pulumi.get(self, "restore_global_state")

    @restore_global_state.setter
    def restore_global_state(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "restore_global_state", value)

    @_builtins.property
    @pulumi.getter(name="sasToken")
    def sas_token(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        A shared access signatures (SAS) token. One of key or sas_token should be specified.
        """
        return pulumi.get(self, "sas_token")

    @sas_token.setter
    def sas_token(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "sas_token", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigGcsMigrationArgsDict(TypedDict):
        base_path: pulumi.Input[_builtins.str]
        """
        The path to the repository data within its container. The value of this setting should not start or end with a /.
        """
        bucket: pulumi.Input[_builtins.str]
        """
        The path to the repository data within its container.
        """
        credentials: pulumi.Input[_builtins.str]
        """
        Google Cloud Storage credentials file content.
        """
        indices: pulumi.Input[_builtins.str]
        """
        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
        """
        snapshot_name: pulumi.Input[_builtins.str]
        """
        The snapshot name to restore from.
        """
        chunk_size: NotRequired[pulumi.Input[_builtins.str]]
        """
        Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
        """
        compress: NotRequired[pulumi.Input[_builtins.bool]]
        """
        When set to true metadata files are stored in compressed format.
        """
        include_aliases: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether to restore aliases alongside their associated indexes. Default is true.
        """
        readonly: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the repository is read-only. Default: `true`.
        """
        restore_global_state: NotRequired[pulumi.Input[_builtins.bool]]
        """
        If true, restore the cluster state. Defaults to false.
        """
elif False:
    OpenSearchOpensearchUserConfigGcsMigrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigGcsMigrationArgs:
    def __init__(__self__, *,
                 base_path: pulumi.Input[_builtins.str],
                 bucket: pulumi.Input[_builtins.str],
                 credentials: pulumi.Input[_builtins.str],
                 indices: pulumi.Input[_builtins.str],
                 snapshot_name: pulumi.Input[_builtins.str],
                 chunk_size: Optional[pulumi.Input[_builtins.str]] = None,
                 compress: Optional[pulumi.Input[_builtins.bool]] = None,
                 include_aliases: Optional[pulumi.Input[_builtins.bool]] = None,
                 readonly: Optional[pulumi.Input[_builtins.bool]] = None,
                 restore_global_state: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] base_path: The path to the repository data within its container. The value of this setting should not start or end with a /.
        :param pulumi.Input[_builtins.str] bucket: The path to the repository data within its container.
        :param pulumi.Input[_builtins.str] credentials: Google Cloud Storage credentials file content.
        :param pulumi.Input[_builtins.str] indices: A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
        :param pulumi.Input[_builtins.str] snapshot_name: The snapshot name to restore from.
        :param pulumi.Input[_builtins.str] chunk_size: Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
        :param pulumi.Input[_builtins.bool] compress: When set to true metadata files are stored in compressed format.
        :param pulumi.Input[_builtins.bool] include_aliases: Whether to restore aliases alongside their associated indexes. Default is true.
        :param pulumi.Input[_builtins.bool] readonly: Whether the repository is read-only. Default: `true`.
        :param pulumi.Input[_builtins.bool] restore_global_state: If true, restore the cluster state. Defaults to false.
        """
        pulumi.set(__self__, "base_path", base_path)
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "credentials", credentials)
        pulumi.set(__self__, "indices", indices)
        pulumi.set(__self__, "snapshot_name", snapshot_name)
        if chunk_size is not None:
            pulumi.set(__self__, "chunk_size", chunk_size)
        if compress is not None:
            pulumi.set(__self__, "compress", compress)
        if include_aliases is not None:
            pulumi.set(__self__, "include_aliases", include_aliases)
        if readonly is not None:
            pulumi.set(__self__, "readonly", readonly)
        if restore_global_state is not None:
            pulumi.set(__self__, "restore_global_state", restore_global_state)

    @_builtins.property
    @pulumi.getter(name="basePath")
    def base_path(self) -> pulumi.Input[_builtins.str]:
        """
        The path to the repository data within its container. The value of this setting should not start or end with a /.
        """
        return pulumi.get(self, "base_path")

    @base_path.setter
    def base_path(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "base_path", value)

    @_builtins.property
    @pulumi.getter
    def bucket(self) -> pulumi.Input[_builtins.str]:
        """
        The path to the repository data within its container.
        """
        return pulumi.get(self, "bucket")

    @bucket.setter
    def bucket(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "bucket", value)

    @_builtins.property
    @pulumi.getter
    def credentials(self) -> pulumi.Input[_builtins.str]:
        """
        Google Cloud Storage credentials file content.
        """
        return pulumi.get(self, "credentials")

    @credentials.setter
    def credentials(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "credentials", value)

    @_builtins.property
    @pulumi.getter
    def indices(self) -> pulumi.Input[_builtins.str]:
        """
        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
        """
        return pulumi.get(self, "indices")

    @indices.setter
    def indices(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "indices", value)

    @_builtins.property
    @pulumi.getter(name="snapshotName")
    def snapshot_name(self) -> pulumi.Input[_builtins.str]:
        """
        The snapshot name to restore from.
        """
        return pulumi.get(self, "snapshot_name")

    @snapshot_name.setter
    def snapshot_name(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "snapshot_name", value)

    @_builtins.property
    @pulumi.getter(name="chunkSize")
    def chunk_size(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
        """
        return pulumi.get(self, "chunk_size")

    @chunk_size.setter
    def chunk_size(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "chunk_size", value)

    @_builtins.property
    @pulumi.getter
    def compress(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        When set to true metadata files are stored in compressed format.
        """
        return pulumi.get(self, "compress")

    @compress.setter
    def compress(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "compress", value)

    @_builtins.property
    @pulumi.getter(name="includeAliases")
    def include_aliases(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether to restore aliases alongside their associated indexes. Default is true.
        """
        return pulumi.get(self, "include_aliases")

    @include_aliases.setter
    def include_aliases(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "include_aliases", value)

    @_builtins.property
    @pulumi.getter
    def readonly(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the repository is read-only. Default: `true`.
        """
        return pulumi.get(self, "readonly")

    @readonly.setter
    def readonly(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "readonly", value)

    @_builtins.property
    @pulumi.getter(name="restoreGlobalState")
    def restore_global_state(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        If true, restore the cluster state. Defaults to false.
        """
        return pulumi.get(self, "restore_global_state")

    @restore_global_state.setter
    def restore_global_state(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "restore_global_state", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigIndexPatternArgsDict(TypedDict):
        max_index_count: pulumi.Input[_builtins.int]
        """
        Maximum number of indexes to keep. Example: `3`.
        """
        pattern: pulumi.Input[_builtins.str]
        """
        fnmatch pattern. Example: `logs_*_foo_*`.
        """
        sorting_algorithm: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `alphabetical`, `creation_date`. Deletion sorting algorithm. Default: `creation_date`.
        """
elif False:
    OpenSearchOpensearchUserConfigIndexPatternArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigIndexPatternArgs:
    def __init__(__self__, *,
                 max_index_count: pulumi.Input[_builtins.int],
                 pattern: pulumi.Input[_builtins.str],
                 sorting_algorithm: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.int] max_index_count: Maximum number of indexes to keep. Example: `3`.
        :param pulumi.Input[_builtins.str] pattern: fnmatch pattern. Example: `logs_*_foo_*`.
        :param pulumi.Input[_builtins.str] sorting_algorithm: Enum: `alphabetical`, `creation_date`. Deletion sorting algorithm. Default: `creation_date`.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="maxIndexCount")
    def max_index_count(self) -> pulumi.Input[_builtins.int]:
        """
        Maximum number of indexes to keep. Example: `3`.
        """
        return pulumi.get(self, "max_index_count")

    @max_index_count.setter
    def max_index_count(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "max_index_count", value)

    @_builtins.property
    @pulumi.getter
    def pattern(self) -> pulumi.Input[_builtins.str]:
        """
        fnmatch pattern. Example: `logs_*_foo_*`.
        """
        return pulumi.get(self, "pattern")

    @pattern.setter
    def pattern(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "pattern", value)

    @_builtins.property
    @pulumi.getter(name="sortingAlgorithm")
    def sorting_algorithm(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `alphabetical`, `creation_date`. Deletion sorting algorithm. Default: `creation_date`.
        """
        return pulumi.get(self, "sorting_algorithm")

    @sorting_algorithm.setter
    def sorting_algorithm(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "sorting_algorithm", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigIndexRollupArgsDict(TypedDict):
        rollup_dashboards_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether rollups are enabled in OpenSearch Dashboards. Defaults to true.
        """
        rollup_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the rollup plugin is enabled. Defaults to true.
        """
        rollup_search_backoff_count: NotRequired[pulumi.Input[_builtins.int]]
        """
        How many retries the plugin should attempt for failed rollup jobs. Defaults to 5.
        """
        rollup_search_backoff_millis: NotRequired[pulumi.Input[_builtins.int]]
        """
        The backoff time between retries for failed rollup jobs. Defaults to 1000ms.
        """
        rollup_search_search_all_jobs: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether OpenSearch should return all jobs that match all specified search terms. If disabled, OpenSearch returns just one, as opposed to all, of the jobs that matches the search terms. Defaults to false.
        """
elif False:
    OpenSearchOpensearchUserConfigIndexRollupArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigIndexRollupArgs:
    def __init__(__self__, *,
                 rollup_dashboards_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 rollup_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 rollup_search_backoff_count: Optional[pulumi.Input[_builtins.int]] = None,
                 rollup_search_backoff_millis: Optional[pulumi.Input[_builtins.int]] = None,
                 rollup_search_search_all_jobs: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] rollup_dashboards_enabled: Whether rollups are enabled in OpenSearch Dashboards. Defaults to true.
        :param pulumi.Input[_builtins.bool] rollup_enabled: Whether the rollup plugin is enabled. Defaults to true.
        :param pulumi.Input[_builtins.int] rollup_search_backoff_count: How many retries the plugin should attempt for failed rollup jobs. Defaults to 5.
        :param pulumi.Input[_builtins.int] rollup_search_backoff_millis: The backoff time between retries for failed rollup jobs. Defaults to 1000ms.
        :param pulumi.Input[_builtins.bool] rollup_search_search_all_jobs: Whether OpenSearch should return all jobs that match all specified search terms. If disabled, OpenSearch returns just one, as opposed to all, of the jobs that matches the search terms. Defaults to false.
        """
        if rollup_dashboards_enabled is not None:
            pulumi.set(__self__, "rollup_dashboards_enabled", rollup_dashboards_enabled)
        if rollup_enabled is not None:
            pulumi.set(__self__, "rollup_enabled", rollup_enabled)
        if rollup_search_backoff_count is not None:
            pulumi.set(__self__, "rollup_search_backoff_count", rollup_search_backoff_count)
        if rollup_search_backoff_millis is not None:
            pulumi.set(__self__, "rollup_search_backoff_millis", rollup_search_backoff_millis)
        if rollup_search_search_all_jobs is not None:
            pulumi.set(__self__, "rollup_search_search_all_jobs", rollup_search_search_all_jobs)

    @_builtins.property
    @pulumi.getter(name="rollupDashboardsEnabled")
    def rollup_dashboards_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether rollups are enabled in OpenSearch Dashboards. Defaults to true.
        """
        return pulumi.get(self, "rollup_dashboards_enabled")

    @rollup_dashboards_enabled.setter
    def rollup_dashboards_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "rollup_dashboards_enabled", value)

    @_builtins.property
    @pulumi.getter(name="rollupEnabled")
    def rollup_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the rollup plugin is enabled. Defaults to true.
        """
        return pulumi.get(self, "rollup_enabled")

    @rollup_enabled.setter
    def rollup_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "rollup_enabled", value)

    @_builtins.property
    @pulumi.getter(name="rollupSearchBackoffCount")
    def rollup_search_backoff_count(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        How many retries the plugin should attempt for failed rollup jobs. Defaults to 5.
        """
        return pulumi.get(self, "rollup_search_backoff_count")

    @rollup_search_backoff_count.setter
    def rollup_search_backoff_count(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "rollup_search_backoff_count", value)

    @_builtins.property
    @pulumi.getter(name="rollupSearchBackoffMillis")
    def rollup_search_backoff_millis(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The backoff time between retries for failed rollup jobs. Defaults to 1000ms.
        """
        return pulumi.get(self, "rollup_search_backoff_millis")

    @rollup_search_backoff_millis.setter
    def rollup_search_backoff_millis(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "rollup_search_backoff_millis", value)

    @_builtins.property
    @pulumi.getter(name="rollupSearchSearchAllJobs")
    def rollup_search_search_all_jobs(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether OpenSearch should return all jobs that match all specified search terms. If disabled, OpenSearch returns just one, as opposed to all, of the jobs that matches the search terms. Defaults to false.
        """
        return pulumi.get(self, "rollup_search_search_all_jobs")

    @rollup_search_search_all_jobs.setter
    def rollup_search_search_all_jobs(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "rollup_search_search_all_jobs", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigIndexTemplateArgsDict(TypedDict):
        mapping_nested_objects_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of nested JSON objects that a single document can contain across all nested types. This limit helps to prevent out of memory errors when a document contains too many nested objects. Default is 10000. Deprecated, use an index template instead. Example: `10000`.
        """
        number_of_replicas: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of replicas each primary shard has. Deprecated, use an index template instead. Example: `1`.
        """
        number_of_shards: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of primary shards that an index should have. Deprecated, use an index template instead. Example: `1`.
        """
elif False:
    OpenSearchOpensearchUserConfigIndexTemplateArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigIndexTemplateArgs:
    def __init__(__self__, *,
                 mapping_nested_objects_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 number_of_replicas: Optional[pulumi.Input[_builtins.int]] = None,
                 number_of_shards: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.int] mapping_nested_objects_limit: The maximum number of nested JSON objects that a single document can contain across all nested types. This limit helps to prevent out of memory errors when a document contains too many nested objects. Default is 10000. Deprecated, use an index template instead. Example: `10000`.
        :param pulumi.Input[_builtins.int] number_of_replicas: The number of replicas each primary shard has. Deprecated, use an index template instead. Example: `1`.
        :param pulumi.Input[_builtins.int] number_of_shards: The number of primary shards that an index should have. Deprecated, use an index template instead. Example: `1`.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="mappingNestedObjectsLimit")
    def mapping_nested_objects_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of nested JSON objects that a single document can contain across all nested types. This limit helps to prevent out of memory errors when a document contains too many nested objects. Default is 10000. Deprecated, use an index template instead. Example: `10000`.
        """
        return pulumi.get(self, "mapping_nested_objects_limit")

    @mapping_nested_objects_limit.setter
    def mapping_nested_objects_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "mapping_nested_objects_limit", value)

    @_builtins.property
    @pulumi.getter(name="numberOfReplicas")
    def number_of_replicas(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of replicas each primary shard has. Deprecated, use an index template instead. Example: `1`.
        """
        return pulumi.get(self, "number_of_replicas")

    @number_of_replicas.setter
    def number_of_replicas(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "number_of_replicas", value)

    @_builtins.property
    @pulumi.getter(name="numberOfShards")
    def number_of_shards(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of primary shards that an index should have. Deprecated, use an index template instead. Example: `1`.
        """
        return pulumi.get(self, "number_of_shards")

    @number_of_shards.setter
    def number_of_shards(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "number_of_shards", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    OpenSearchOpensearchUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "network", value)

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "description", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigJwtArgsDict(TypedDict):
        enabled: pulumi.Input[_builtins.bool]
        """
        Enables or disables JWT-based authentication for OpenSearch. When enabled, users can authenticate using JWT tokens. Default: `false`.
        """
        signing_key: pulumi.Input[_builtins.str]
        """
        The secret key used to sign and verify JWT tokens. This should be a secure, randomly generated key HMAC key or public RSA/ECDSA key. Example: `MrJiimVjKgjRKCSk0s6rcEuCz17v5ZyFRqKARfZbuZE= (HMAC) or -----BEGIN PUBLIC KEY-----
        MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA...
        -----END PUBLIC KEY----- (PEM)`.
        """
        jwt_clock_skew_tolerance_seconds: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum allowed time difference in seconds between the JWT issuer's clock and the OpenSearch server's clock. This helps prevent token validation failures due to minor time synchronization issues. Default: `20`.
        """
        jwt_header: NotRequired[pulumi.Input[_builtins.str]]
        """
        The HTTP header name where the JWT token is transmitted. Typically `Authorization` for Bearer tokens. Default: `Authorization`.
        """
        jwt_url_parameter: NotRequired[pulumi.Input[_builtins.str]]
        """
        If the JWT token is transmitted as a URL parameter instead of an HTTP header, specify the parameter name here. Example: `token`.
        """
        required_audience: NotRequired[pulumi.Input[_builtins.str]]
        """
        If specified, the JWT must contain an `aud` claim that matches this value. This provides additional security by ensuring the JWT was issued for the expected audience. Example: `https://myapp.example.com`.
        """
        required_issuer: NotRequired[pulumi.Input[_builtins.str]]
        """
        If specified, the JWT must contain an `iss` claim that matches this value. This provides additional security by ensuring the JWT was issued by the expected issuer. Example: `https://auth.example.com`.
        """
        roles_key: NotRequired[pulumi.Input[_builtins.str]]
        """
        The key in the JWT payload that contains the user's roles. If specified, roles will be extracted from the JWT for authorization. Example: `roles`.
        """
        subject_key: NotRequired[pulumi.Input[_builtins.str]]
        """
        The key in the JWT payload that contains the user's subject identifier. If not specified, the `sub` claim is used by default. Example: `sub`.
        """
elif False:
    OpenSearchOpensearchUserConfigJwtArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigJwtArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[_builtins.bool],
                 signing_key: pulumi.Input[_builtins.str],
                 jwt_clock_skew_tolerance_seconds: Optional[pulumi.Input[_builtins.int]] = None,
                 jwt_header: Optional[pulumi.Input[_builtins.str]] = None,
                 jwt_url_parameter: Optional[pulumi.Input[_builtins.str]] = None,
                 required_audience: Optional[pulumi.Input[_builtins.str]] = None,
                 required_issuer: Optional[pulumi.Input[_builtins.str]] = None,
                 roles_key: Optional[pulumi.Input[_builtins.str]] = None,
                 subject_key: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.bool] enabled: Enables or disables JWT-based authentication for OpenSearch. When enabled, users can authenticate using JWT tokens. Default: `false`.
        :param pulumi.Input[_builtins.str] signing_key: The secret key used to sign and verify JWT tokens. This should be a secure, randomly generated key HMAC key or public RSA/ECDSA key. Example: `MrJiimVjKgjRKCSk0s6rcEuCz17v5ZyFRqKARfZbuZE= (HMAC) or -----BEGIN PUBLIC KEY-----
               MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA...
               -----END PUBLIC KEY----- (PEM)`.
        :param pulumi.Input[_builtins.int] jwt_clock_skew_tolerance_seconds: The maximum allowed time difference in seconds between the JWT issuer's clock and the OpenSearch server's clock. This helps prevent token validation failures due to minor time synchronization issues. Default: `20`.
        :param pulumi.Input[_builtins.str] jwt_header: The HTTP header name where the JWT token is transmitted. Typically `Authorization` for Bearer tokens. Default: `Authorization`.
        :param pulumi.Input[_builtins.str] jwt_url_parameter: If the JWT token is transmitted as a URL parameter instead of an HTTP header, specify the parameter name here. Example: `token`.
        :param pulumi.Input[_builtins.str] required_audience: If specified, the JWT must contain an `aud` claim that matches this value. This provides additional security by ensuring the JWT was issued for the expected audience. Example: `https://myapp.example.com`.
        :param pulumi.Input[_builtins.str] required_issuer: If specified, the JWT must contain an `iss` claim that matches this value. This provides additional security by ensuring the JWT was issued by the expected issuer. Example: `https://auth.example.com`.
        :param pulumi.Input[_builtins.str] roles_key: The key in the JWT payload that contains the user's roles. If specified, roles will be extracted from the JWT for authorization. Example: `roles`.
        :param pulumi.Input[_builtins.str] subject_key: The key in the JWT payload that contains the user's subject identifier. If not specified, the `sub` claim is used by default. Example: `sub`.
        """
        pulumi.set(__self__, "enabled", enabled)
        pulumi.set(__self__, "signing_key", signing_key)
        if jwt_clock_skew_tolerance_seconds is not None:
            pulumi.set(__self__, "jwt_clock_skew_tolerance_seconds", jwt_clock_skew_tolerance_seconds)
        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 required_audience is not None:
            pulumi.set(__self__, "required_audience", required_audience)
        if required_issuer is not None:
            pulumi.set(__self__, "required_issuer", required_issuer)
        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)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> pulumi.Input[_builtins.bool]:
        """
        Enables or disables JWT-based authentication for OpenSearch. When enabled, users can authenticate using JWT tokens. Default: `false`.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: pulumi.Input[_builtins.bool]):
        pulumi.set(self, "enabled", value)

    @_builtins.property
    @pulumi.getter(name="signingKey")
    def signing_key(self) -> pulumi.Input[_builtins.str]:
        """
        The secret key used to sign and verify JWT tokens. This should be a secure, randomly generated key HMAC key or public RSA/ECDSA key. Example: `MrJiimVjKgjRKCSk0s6rcEuCz17v5ZyFRqKARfZbuZE= (HMAC) or -----BEGIN PUBLIC KEY-----
        MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA...
        -----END PUBLIC KEY----- (PEM)`.
        """
        return pulumi.get(self, "signing_key")

    @signing_key.setter
    def signing_key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "signing_key", value)

    @_builtins.property
    @pulumi.getter(name="jwtClockSkewToleranceSeconds")
    def jwt_clock_skew_tolerance_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum allowed time difference in seconds between the JWT issuer's clock and the OpenSearch server's clock. This helps prevent token validation failures due to minor time synchronization issues. Default: `20`.
        """
        return pulumi.get(self, "jwt_clock_skew_tolerance_seconds")

    @jwt_clock_skew_tolerance_seconds.setter
    def jwt_clock_skew_tolerance_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "jwt_clock_skew_tolerance_seconds", value)

    @_builtins.property
    @pulumi.getter(name="jwtHeader")
    def jwt_header(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The HTTP header name where the JWT token is transmitted. Typically `Authorization` for Bearer tokens. Default: `Authorization`.
        """
        return pulumi.get(self, "jwt_header")

    @jwt_header.setter
    def jwt_header(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "jwt_header", value)

    @_builtins.property
    @pulumi.getter(name="jwtUrlParameter")
    def jwt_url_parameter(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        If the JWT token is transmitted as a URL parameter instead of an HTTP header, specify the parameter name here. Example: `token`.
        """
        return pulumi.get(self, "jwt_url_parameter")

    @jwt_url_parameter.setter
    def jwt_url_parameter(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "jwt_url_parameter", value)

    @_builtins.property
    @pulumi.getter(name="requiredAudience")
    def required_audience(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        If specified, the JWT must contain an `aud` claim that matches this value. This provides additional security by ensuring the JWT was issued for the expected audience. Example: `https://myapp.example.com`.
        """
        return pulumi.get(self, "required_audience")

    @required_audience.setter
    def required_audience(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "required_audience", value)

    @_builtins.property
    @pulumi.getter(name="requiredIssuer")
    def required_issuer(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        If specified, the JWT must contain an `iss` claim that matches this value. This provides additional security by ensuring the JWT was issued by the expected issuer. Example: `https://auth.example.com`.
        """
        return pulumi.get(self, "required_issuer")

    @required_issuer.setter
    def required_issuer(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "required_issuer", value)

    @_builtins.property
    @pulumi.getter(name="rolesKey")
    def roles_key(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The key in the JWT payload that contains the user's roles. If specified, roles will be extracted from the JWT for authorization. Example: `roles`.
        """
        return pulumi.get(self, "roles_key")

    @roles_key.setter
    def roles_key(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "roles_key", value)

    @_builtins.property
    @pulumi.getter(name="subjectKey")
    def subject_key(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The key in the JWT payload that contains the user's subject identifier. If not specified, the `sub` claim is used by default. Example: `sub`.
        """
        return pulumi.get(self, "subject_key")

    @subject_key.setter
    def subject_key(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "subject_key", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpenidArgsDict(TypedDict):
        client_id: pulumi.Input[_builtins.str]
        """
        The ID of the OpenID Connect client configured in your IdP. Required.
        """
        client_secret: pulumi.Input[_builtins.str]
        """
        The client secret of the OpenID Connect client configured in your IdP. Required.
        """
        connect_url: pulumi.Input[_builtins.str]
        """
        The URL of your IdP where the Security plugin can find the OpenID Connect metadata/configuration settings. Example: `https://test-account.okta.com/app/exk491jujcVc83LEX697/sso/saml/metadata`.
        """
        enabled: pulumi.Input[_builtins.bool]
        """
        Enables or disables OpenID Connect authentication for OpenSearch. When enabled, users can authenticate using OpenID Connect with an Identity Provider. Default: `true`.
        """
        header: NotRequired[pulumi.Input[_builtins.str]]
        """
        HTTP header name of the JWT token. Optional. Default is Authorization. Default: `Authorization`.
        """
        jwt_header: NotRequired[pulumi.Input[_builtins.str]]
        """
        The HTTP header that stores the token. Typically the Authorization header with the Bearer schema: Authorization: Bearer \\n\\n. Optional. Default is Authorization. Example: `preferred_username`.
        """
        jwt_url_parameter: NotRequired[pulumi.Input[_builtins.str]]
        """
        If the token is not transmitted in the HTTP header, but as an URL parameter, define the name of the parameter here. Optional. Example: `preferred_username`.
        """
        refresh_rate_limit_count: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of unknown key IDs in the time frame. Default is 10. Optional. Default: `10`.
        """
        refresh_rate_limit_time_window_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The time frame to use when checking the maximum number of unknown key IDs, in milliseconds. Optional.Default is 10000 (10 seconds). Default: `10000`.
        """
        roles_key: NotRequired[pulumi.Input[_builtins.str]]
        """
        The key in the JSON payload that stores the user’s roles. The value of this key must be a comma-separated list of roles. Required only if you want to use roles in the JWT. Example: `roles`.
        """
        scope: NotRequired[pulumi.Input[_builtins.str]]
        """
        The scope of the identity token issued by the IdP. Optional. Default is openid profile email address phone.
        """
        subject_key: NotRequired[pulumi.Input[_builtins.str]]
        """
        The key in the JSON payload that stores the user’s name. If not defined, the subject registered claim is used. Most IdP providers use the preferred_username claim. Optional. Example: `preferred_username`.
        """
elif False:
    OpenSearchOpensearchUserConfigOpenidArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpenidArgs:
    def __init__(__self__, *,
                 client_id: pulumi.Input[_builtins.str],
                 client_secret: pulumi.Input[_builtins.str],
                 connect_url: pulumi.Input[_builtins.str],
                 enabled: pulumi.Input[_builtins.bool],
                 header: Optional[pulumi.Input[_builtins.str]] = None,
                 jwt_header: Optional[pulumi.Input[_builtins.str]] = None,
                 jwt_url_parameter: Optional[pulumi.Input[_builtins.str]] = None,
                 refresh_rate_limit_count: Optional[pulumi.Input[_builtins.int]] = None,
                 refresh_rate_limit_time_window_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 roles_key: Optional[pulumi.Input[_builtins.str]] = None,
                 scope: Optional[pulumi.Input[_builtins.str]] = None,
                 subject_key: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] client_id: The ID of the OpenID Connect client configured in your IdP. Required.
        :param pulumi.Input[_builtins.str] client_secret: The client secret of the OpenID Connect client configured in your IdP. Required.
        :param pulumi.Input[_builtins.str] connect_url: The URL of your IdP where the Security plugin can find the OpenID Connect metadata/configuration settings. Example: `https://test-account.okta.com/app/exk491jujcVc83LEX697/sso/saml/metadata`.
        :param pulumi.Input[_builtins.bool] enabled: Enables or disables OpenID Connect authentication for OpenSearch. When enabled, users can authenticate using OpenID Connect with an Identity Provider. Default: `true`.
        :param pulumi.Input[_builtins.str] header: HTTP header name of the JWT token. Optional. Default is Authorization. Default: `Authorization`.
        :param pulumi.Input[_builtins.str] jwt_header: The HTTP header that stores the token. Typically the Authorization header with the Bearer schema: Authorization: Bearer \\n\\n. Optional. Default is Authorization. Example: `preferred_username`.
        :param pulumi.Input[_builtins.str] jwt_url_parameter: If the token is not transmitted in the HTTP header, but as an URL parameter, define the name of the parameter here. Optional. Example: `preferred_username`.
        :param pulumi.Input[_builtins.int] refresh_rate_limit_count: The maximum number of unknown key IDs in the time frame. Default is 10. Optional. Default: `10`.
        :param pulumi.Input[_builtins.int] refresh_rate_limit_time_window_ms: The time frame to use when checking the maximum number of unknown key IDs, in milliseconds. Optional.Default is 10000 (10 seconds). Default: `10000`.
        :param pulumi.Input[_builtins.str] roles_key: The key in the JSON payload that stores the user’s roles. The value of this key must be a comma-separated list of roles. Required only if you want to use roles in the JWT. Example: `roles`.
        :param pulumi.Input[_builtins.str] scope: The scope of the identity token issued by the IdP. Optional. Default is openid profile email address phone.
        :param pulumi.Input[_builtins.str] subject_key: The key in the JSON payload that stores the user’s name. If not defined, the subject registered claim is used. Most IdP providers use the preferred_username claim. Optional. Example: `preferred_username`.
        """
        pulumi.set(__self__, "client_id", client_id)
        pulumi.set(__self__, "client_secret", client_secret)
        pulumi.set(__self__, "connect_url", connect_url)
        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)

    @_builtins.property
    @pulumi.getter(name="clientId")
    def client_id(self) -> pulumi.Input[_builtins.str]:
        """
        The ID of the OpenID Connect client configured in your IdP. Required.
        """
        return pulumi.get(self, "client_id")

    @client_id.setter
    def client_id(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "client_id", value)

    @_builtins.property
    @pulumi.getter(name="clientSecret")
    def client_secret(self) -> pulumi.Input[_builtins.str]:
        """
        The client secret of the OpenID Connect client configured in your IdP. Required.
        """
        return pulumi.get(self, "client_secret")

    @client_secret.setter
    def client_secret(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "client_secret", value)

    @_builtins.property
    @pulumi.getter(name="connectUrl")
    def connect_url(self) -> pulumi.Input[_builtins.str]:
        """
        The URL of your IdP where the Security plugin can find the OpenID Connect metadata/configuration settings. Example: `https://test-account.okta.com/app/exk491jujcVc83LEX697/sso/saml/metadata`.
        """
        return pulumi.get(self, "connect_url")

    @connect_url.setter
    def connect_url(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "connect_url", value)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> pulumi.Input[_builtins.bool]:
        """
        Enables or disables OpenID Connect authentication for OpenSearch. When enabled, users can authenticate using OpenID Connect with an Identity Provider. Default: `true`.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: pulumi.Input[_builtins.bool]):
        pulumi.set(self, "enabled", value)

    @_builtins.property
    @pulumi.getter
    def header(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        HTTP header name of the JWT token. Optional. Default is Authorization. Default: `Authorization`.
        """
        return pulumi.get(self, "header")

    @header.setter
    def header(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "header", value)

    @_builtins.property
    @pulumi.getter(name="jwtHeader")
    def jwt_header(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The HTTP header that stores the token. Typically the Authorization header with the Bearer schema: Authorization: Bearer \\n\\n. Optional. Default is Authorization. Example: `preferred_username`.
        """
        return pulumi.get(self, "jwt_header")

    @jwt_header.setter
    def jwt_header(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "jwt_header", value)

    @_builtins.property
    @pulumi.getter(name="jwtUrlParameter")
    def jwt_url_parameter(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        If the token is not transmitted in the HTTP header, but as an URL parameter, define the name of the parameter here. Optional. Example: `preferred_username`.
        """
        return pulumi.get(self, "jwt_url_parameter")

    @jwt_url_parameter.setter
    def jwt_url_parameter(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "jwt_url_parameter", value)

    @_builtins.property
    @pulumi.getter(name="refreshRateLimitCount")
    def refresh_rate_limit_count(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of unknown key IDs in the time frame. Default is 10. Optional. Default: `10`.
        """
        return pulumi.get(self, "refresh_rate_limit_count")

    @refresh_rate_limit_count.setter
    def refresh_rate_limit_count(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "refresh_rate_limit_count", value)

    @_builtins.property
    @pulumi.getter(name="refreshRateLimitTimeWindowMs")
    def refresh_rate_limit_time_window_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The time frame to use when checking the maximum number of unknown key IDs, in milliseconds. Optional.Default is 10000 (10 seconds). Default: `10000`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "refresh_rate_limit_time_window_ms", value)

    @_builtins.property
    @pulumi.getter(name="rolesKey")
    def roles_key(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The key in the JSON payload that stores the user’s roles. The value of this key must be a comma-separated list of roles. Required only if you want to use roles in the JWT. Example: `roles`.
        """
        return pulumi.get(self, "roles_key")

    @roles_key.setter
    def roles_key(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "roles_key", value)

    @_builtins.property
    @pulumi.getter
    def scope(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The scope of the identity token issued by the IdP. Optional. Default is openid profile email address phone.
        """
        return pulumi.get(self, "scope")

    @scope.setter
    def scope(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "scope", value)

    @_builtins.property
    @pulumi.getter(name="subjectKey")
    def subject_key(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The key in the JSON payload that stores the user’s name. If not defined, the subject registered claim is used. Most IdP providers use the preferred_username claim. Optional. Example: `preferred_username`.
        """
        return pulumi.get(self, "subject_key")

    @subject_key.setter
    def subject_key(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "subject_key", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchArgsDict(TypedDict):
        action_auto_create_index_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Explicitly allow or block automatic creation of indices. Defaults to true.
        """
        action_destructive_requires_name: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Require explicit index names when deleting.
        """
        auth_failure_listeners: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersArgsDict']]
        """
        Opensearch Security Plugin Settings
        """
        cluster_filecache_remote_data_ratio: NotRequired[pulumi.Input[_builtins.float]]
        """
        Defines a limit of how much total remote data can be referenced as a ratio of the size of the disk reserved for the file cache. This is designed to be a safeguard to prevent oversubscribing a cluster. Defaults to 0.
        """
        cluster_max_shards_per_node: NotRequired[pulumi.Input[_builtins.int]]
        """
        Controls the number of shards allowed in the cluster per data node. Example: `1000`.
        """
        cluster_remote_store: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchClusterRemoteStoreArgsDict']]
        cluster_routing_allocation_balance_prefer_primary: NotRequired[pulumi.Input[_builtins.bool]]
        """
        When set to true, OpenSearch attempts to evenly distribute the primary shards between the cluster nodes. Enabling this setting does not always guarantee an equal number of primary shards on each node, especially in the event of a failover. Changing this setting to false after it was set to true does not invoke redistribution of primary shards. Default is false.
        """
        cluster_routing_allocation_node_concurrent_recoveries: NotRequired[pulumi.Input[_builtins.int]]
        """
        How many concurrent incoming/outgoing shard recoveries (normally replicas) are allowed to happen on a node. Defaults to node cpu count * 2.
        """
        cluster_search_request_slowlog: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogArgsDict']]
        disk_watermarks: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchDiskWatermarksArgsDict']]
        """
        Watermark settings
        """
        email_sender_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Sender name placeholder to be used in Opensearch Dashboards and Opensearch keystore. Example: `alert-sender`.
        """
        email_sender_password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Sender password for Opensearch alerts to authenticate with SMTP server. Example: `very-secure-mail-password`.
        """
        email_sender_username: NotRequired[pulumi.Input[_builtins.str]]
        """
        Sender username for Opensearch alerts. Example: `jane@example.com`.
        """
        enable_remote_backed_storage: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable remote-backed storage.
        """
        enable_searchable_snapshots: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable searchable snapshots.
        """
        enable_security_audit: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable/Disable security audit.
        """
        enable_snapshot_api: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable/Disable snapshot API for custom repositories, this requires security management to be enabled.
        """
        http_max_content_length: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum content length for HTTP requests to the OpenSearch HTTP API, in bytes.
        """
        http_max_header_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        The max size of allowed headers, in bytes. Example: `8192`.
        """
        http_max_initial_line_length: NotRequired[pulumi.Input[_builtins.int]]
        """
        The max length of an HTTP URL, in bytes. Example: `4096`.
        """
        indices_fielddata_cache_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Relative amount. Maximum amount of heap memory used for field data cache. This is an expert setting; decreasing the value too much will increase overhead of loading field data; too much memory used for field data cache will decrease amount of heap available for other operations.
        """
        indices_memory_index_buffer_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Percentage value. Default is 10%. Total amount of heap used for indexing buffer, before writing segments to disk. This is an expert setting. Too low value will slow down indexing; too high value will increase indexing performance but causes performance issues for query performance.
        """
        indices_memory_max_index_buffer_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Absolute value. Default is unbound. Doesn't work without indices.memory.index*buffer*size. Maximum amount of heap used for query cache, an absolute indices.memory.index*buffer*size maximum hard limit.
        """
        indices_memory_min_index_buffer_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Absolute value. Default is 48mb. Doesn't work without indices.memory.index*buffer*size. Minimum amount of heap used for query cache, an absolute indices.memory.index*buffer*size minimal hard limit.
        """
        indices_queries_cache_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Percentage value. Default is 10%. Maximum amount of heap used for query cache. This is an expert setting. Too low value will decrease query performance and increase performance for other operations; too high value will cause issues with other OpenSearch functionality.
        """
        indices_query_bool_max_clause_count: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum number of clauses Lucene BooleanQuery can have. The default value (1024) is relatively high, and increasing it may cause performance issues. Investigate other approaches first before increasing this value.
        """
        indices_recovery_max_bytes_per_sec: NotRequired[pulumi.Input[_builtins.int]]
        """
        Limits total inbound and outbound recovery traffic for each node. Applies to both peer recoveries as well as snapshot recoveries (i.e., restores from a snapshot). Defaults to 40mb.
        """
        indices_recovery_max_concurrent_file_chunks: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of file chunks sent in parallel for each recovery. Defaults to 2.
        """
        ism_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Specifies whether ISM is enabled or not.
        """
        ism_history_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document.
        """
        ism_history_max_age: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum age before rolling over the audit history index in hours. Example: `24`.
        """
        ism_history_max_docs: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of documents before rolling over the audit history index.
        """
        ism_history_rollover_check_period: NotRequired[pulumi.Input[_builtins.int]]
        """
        The time between rollover checks for the audit history index in hours. Example: `8`.
        """
        ism_history_rollover_retention_period: NotRequired[pulumi.Input[_builtins.int]]
        """
        How long audit history indices are kept in days. Example: `30`.
        """
        knn_memory_circuit_breaker_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable or disable KNN memory circuit breaker. Defaults to true.
        """
        knn_memory_circuit_breaker_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum amount of memory in percentage that can be used for the KNN index. Defaults to 50% of the JVM heap size. 0 is used to set it to null which can be used to invalidate caches.
        """
        ml_commons_model_access_control_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable or disable model access control for ML Commons. When enabled, access to ML models is controlled by security permissions. Defaults to false.
        """
        ml_commons_native_memory_threshold: NotRequired[pulumi.Input[_builtins.int]]
        """
        Native memory threshold percentage for ML Commons. Controls the maximum percentage of native memory that can be used by ML Commons operations. Defaults to 90%.
        """
        ml_commons_only_run_on_ml_node: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable or disable running ML Commons tasks only on ML nodes. When enabled, ML tasks will only execute on nodes designated as ML nodes. Defaults to true.
        """
        node_search_cache_size: NotRequired[pulumi.Input[_builtins.str]]
        """
        Defines a limit of how much total remote data can be referenced as a ratio of the size of the disk reserved for the file cache. This is designed to be a safeguard to prevent oversubscribing a cluster. Defaults to 5gb. Requires restarting all OpenSearch nodes.
        """
        override_main_response_version: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Compatibility mode sets OpenSearch to report its version as 7.10 so clients continue to work. Default is false.
        """
        plugins_alerting_filter_by_backend_roles: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable or disable filtering of alerting by backend roles. Requires Security plugin. Defaults to false.
        """
        reindex_remote_whitelists: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Whitelisted addresses for reindexing. Changing this value will cause all OpenSearch instances to restart.
        """
        remote_store: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchRemoteStoreArgsDict']]
        script_max_compilations_rate: NotRequired[pulumi.Input[_builtins.str]]
        """
        Script compilation circuit breaker limits the number of inline script compilations within a period of time. Default is use-context. Example: `75/5m`.
        """
        search_backpressure: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureArgsDict']]
        """
        Search Backpressure Settings
        """
        search_insights_top_queries: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesArgsDict']]
        search_max_buckets: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum number of aggregation buckets allowed in a single response. OpenSearch default value is used when this is not defined. Example: `10000`.
        """
        segrep: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSegrepArgsDict']]
        """
        Segment Replication Backpressure Settings
        """
        shard_indexing_pressure: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureArgsDict']]
        """
        Shard indexing back pressure settings
        """
        thread_pool_analyze_queue_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Size for the thread pool queue. See documentation for exact details.
        """
        thread_pool_analyze_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        """
        thread_pool_force_merge_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        """
        thread_pool_get_queue_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Size for the thread pool queue. See documentation for exact details.
        """
        thread_pool_get_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        """
        thread_pool_search_queue_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Size for the thread pool queue. See documentation for exact details.
        """
        thread_pool_search_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        """
        thread_pool_search_throttled_queue_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Size for the thread pool queue. See documentation for exact details.
        """
        thread_pool_search_throttled_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        """
        thread_pool_write_queue_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Size for the thread pool queue. See documentation for exact details.
        """
        thread_pool_write_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchArgs:
    def __init__(__self__, *,
                 action_auto_create_index_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 action_destructive_requires_name: Optional[pulumi.Input[_builtins.bool]] = None,
                 auth_failure_listeners: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersArgs']] = None,
                 cluster_filecache_remote_data_ratio: Optional[pulumi.Input[_builtins.float]] = None,
                 cluster_max_shards_per_node: Optional[pulumi.Input[_builtins.int]] = None,
                 cluster_remote_store: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchClusterRemoteStoreArgs']] = None,
                 cluster_routing_allocation_balance_prefer_primary: Optional[pulumi.Input[_builtins.bool]] = None,
                 cluster_routing_allocation_node_concurrent_recoveries: Optional[pulumi.Input[_builtins.int]] = None,
                 cluster_search_request_slowlog: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogArgs']] = None,
                 disk_watermarks: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchDiskWatermarksArgs']] = None,
                 email_sender_name: Optional[pulumi.Input[_builtins.str]] = None,
                 email_sender_password: Optional[pulumi.Input[_builtins.str]] = None,
                 email_sender_username: Optional[pulumi.Input[_builtins.str]] = None,
                 enable_remote_backed_storage: Optional[pulumi.Input[_builtins.bool]] = None,
                 enable_searchable_snapshots: Optional[pulumi.Input[_builtins.bool]] = None,
                 enable_security_audit: Optional[pulumi.Input[_builtins.bool]] = None,
                 enable_snapshot_api: Optional[pulumi.Input[_builtins.bool]] = None,
                 http_max_content_length: Optional[pulumi.Input[_builtins.int]] = None,
                 http_max_header_size: Optional[pulumi.Input[_builtins.int]] = None,
                 http_max_initial_line_length: Optional[pulumi.Input[_builtins.int]] = None,
                 indices_fielddata_cache_size: Optional[pulumi.Input[_builtins.int]] = None,
                 indices_memory_index_buffer_size: Optional[pulumi.Input[_builtins.int]] = None,
                 indices_memory_max_index_buffer_size: Optional[pulumi.Input[_builtins.int]] = None,
                 indices_memory_min_index_buffer_size: Optional[pulumi.Input[_builtins.int]] = None,
                 indices_queries_cache_size: Optional[pulumi.Input[_builtins.int]] = None,
                 indices_query_bool_max_clause_count: Optional[pulumi.Input[_builtins.int]] = None,
                 indices_recovery_max_bytes_per_sec: Optional[pulumi.Input[_builtins.int]] = None,
                 indices_recovery_max_concurrent_file_chunks: Optional[pulumi.Input[_builtins.int]] = None,
                 ism_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 ism_history_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 ism_history_max_age: Optional[pulumi.Input[_builtins.int]] = None,
                 ism_history_max_docs: Optional[pulumi.Input[_builtins.int]] = None,
                 ism_history_rollover_check_period: Optional[pulumi.Input[_builtins.int]] = None,
                 ism_history_rollover_retention_period: Optional[pulumi.Input[_builtins.int]] = None,
                 knn_memory_circuit_breaker_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 knn_memory_circuit_breaker_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 ml_commons_model_access_control_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 ml_commons_native_memory_threshold: Optional[pulumi.Input[_builtins.int]] = None,
                 ml_commons_only_run_on_ml_node: Optional[pulumi.Input[_builtins.bool]] = None,
                 node_search_cache_size: Optional[pulumi.Input[_builtins.str]] = None,
                 override_main_response_version: Optional[pulumi.Input[_builtins.bool]] = None,
                 plugins_alerting_filter_by_backend_roles: Optional[pulumi.Input[_builtins.bool]] = None,
                 reindex_remote_whitelists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 remote_store: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchRemoteStoreArgs']] = None,
                 script_max_compilations_rate: Optional[pulumi.Input[_builtins.str]] = None,
                 search_backpressure: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureArgs']] = None,
                 search_insights_top_queries: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesArgs']] = None,
                 search_max_buckets: Optional[pulumi.Input[_builtins.int]] = None,
                 segrep: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSegrepArgs']] = None,
                 shard_indexing_pressure: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureArgs']] = None,
                 thread_pool_analyze_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
                 thread_pool_analyze_size: Optional[pulumi.Input[_builtins.int]] = None,
                 thread_pool_force_merge_size: Optional[pulumi.Input[_builtins.int]] = None,
                 thread_pool_get_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
                 thread_pool_get_size: Optional[pulumi.Input[_builtins.int]] = None,
                 thread_pool_search_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
                 thread_pool_search_size: Optional[pulumi.Input[_builtins.int]] = None,
                 thread_pool_search_throttled_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
                 thread_pool_search_throttled_size: Optional[pulumi.Input[_builtins.int]] = None,
                 thread_pool_write_queue_size: Optional[pulumi.Input[_builtins.int]] = None,
                 thread_pool_write_size: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.bool] action_auto_create_index_enabled: Explicitly allow or block automatic creation of indices. Defaults to true.
        :param pulumi.Input[_builtins.bool] action_destructive_requires_name: Require explicit index names when deleting.
        :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersArgs'] auth_failure_listeners: Opensearch Security Plugin Settings
        :param pulumi.Input[_builtins.float] cluster_filecache_remote_data_ratio: Defines a limit of how much total remote data can be referenced as a ratio of the size of the disk reserved for the file cache. This is designed to be a safeguard to prevent oversubscribing a cluster. Defaults to 0.
        :param pulumi.Input[_builtins.int] cluster_max_shards_per_node: Controls the number of shards allowed in the cluster per data node. Example: `1000`.
        :param pulumi.Input[_builtins.bool] cluster_routing_allocation_balance_prefer_primary: When set to true, OpenSearch attempts to evenly distribute the primary shards between the cluster nodes. Enabling this setting does not always guarantee an equal number of primary shards on each node, especially in the event of a failover. Changing this setting to false after it was set to true does not invoke redistribution of primary shards. Default is false.
        :param pulumi.Input[_builtins.int] cluster_routing_allocation_node_concurrent_recoveries: How many concurrent incoming/outgoing shard recoveries (normally replicas) are allowed to happen on a node. Defaults to node cpu count * 2.
        :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchDiskWatermarksArgs'] disk_watermarks: Watermark settings
        :param pulumi.Input[_builtins.str] email_sender_name: Sender name placeholder to be used in Opensearch Dashboards and Opensearch keystore. Example: `alert-sender`.
        :param pulumi.Input[_builtins.str] email_sender_password: Sender password for Opensearch alerts to authenticate with SMTP server. Example: `very-secure-mail-password`.
        :param pulumi.Input[_builtins.str] email_sender_username: Sender username for Opensearch alerts. Example: `jane@example.com`.
        :param pulumi.Input[_builtins.bool] enable_remote_backed_storage: Enable remote-backed storage.
        :param pulumi.Input[_builtins.bool] enable_searchable_snapshots: Enable searchable snapshots.
        :param pulumi.Input[_builtins.bool] enable_security_audit: Enable/Disable security audit.
        :param pulumi.Input[_builtins.bool] enable_snapshot_api: Enable/Disable snapshot API for custom repositories, this requires security management to be enabled.
        :param pulumi.Input[_builtins.int] http_max_content_length: Maximum content length for HTTP requests to the OpenSearch HTTP API, in bytes.
        :param pulumi.Input[_builtins.int] http_max_header_size: The max size of allowed headers, in bytes. Example: `8192`.
        :param pulumi.Input[_builtins.int] http_max_initial_line_length: The max length of an HTTP URL, in bytes. Example: `4096`.
        :param pulumi.Input[_builtins.int] indices_fielddata_cache_size: Relative amount. Maximum amount of heap memory used for field data cache. This is an expert setting; decreasing the value too much will increase overhead of loading field data; too much memory used for field data cache will decrease amount of heap available for other operations.
        :param pulumi.Input[_builtins.int] indices_memory_index_buffer_size: Percentage value. Default is 10%. Total amount of heap used for indexing buffer, before writing segments to disk. This is an expert setting. Too low value will slow down indexing; too high value will increase indexing performance but causes performance issues for query performance.
        :param pulumi.Input[_builtins.int] indices_memory_max_index_buffer_size: Absolute value. Default is unbound. Doesn't work without indices.memory.index*buffer*size. Maximum amount of heap used for query cache, an absolute indices.memory.index*buffer*size maximum hard limit.
        :param pulumi.Input[_builtins.int] indices_memory_min_index_buffer_size: Absolute value. Default is 48mb. Doesn't work without indices.memory.index*buffer*size. Minimum amount of heap used for query cache, an absolute indices.memory.index*buffer*size minimal hard limit.
        :param pulumi.Input[_builtins.int] indices_queries_cache_size: Percentage value. Default is 10%. Maximum amount of heap used for query cache. This is an expert setting. Too low value will decrease query performance and increase performance for other operations; too high value will cause issues with other OpenSearch functionality.
        :param pulumi.Input[_builtins.int] indices_query_bool_max_clause_count: Maximum number of clauses Lucene BooleanQuery can have. The default value (1024) is relatively high, and increasing it may cause performance issues. Investigate other approaches first before increasing this value.
        :param pulumi.Input[_builtins.int] indices_recovery_max_bytes_per_sec: Limits total inbound and outbound recovery traffic for each node. Applies to both peer recoveries as well as snapshot recoveries (i.e., restores from a snapshot). Defaults to 40mb.
        :param pulumi.Input[_builtins.int] indices_recovery_max_concurrent_file_chunks: Number of file chunks sent in parallel for each recovery. Defaults to 2.
        :param pulumi.Input[_builtins.bool] ism_enabled: Specifies whether ISM is enabled or not.
        :param pulumi.Input[_builtins.bool] ism_history_enabled: Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document.
        :param pulumi.Input[_builtins.int] ism_history_max_age: The maximum age before rolling over the audit history index in hours. Example: `24`.
        :param pulumi.Input[_builtins.int] ism_history_max_docs: The maximum number of documents before rolling over the audit history index.
        :param pulumi.Input[_builtins.int] ism_history_rollover_check_period: The time between rollover checks for the audit history index in hours. Example: `8`.
        :param pulumi.Input[_builtins.int] ism_history_rollover_retention_period: How long audit history indices are kept in days. Example: `30`.
        :param pulumi.Input[_builtins.bool] knn_memory_circuit_breaker_enabled: Enable or disable KNN memory circuit breaker. Defaults to true.
        :param pulumi.Input[_builtins.int] knn_memory_circuit_breaker_limit: Maximum amount of memory in percentage that can be used for the KNN index. Defaults to 50% of the JVM heap size. 0 is used to set it to null which can be used to invalidate caches.
        :param pulumi.Input[_builtins.bool] ml_commons_model_access_control_enabled: Enable or disable model access control for ML Commons. When enabled, access to ML models is controlled by security permissions. Defaults to false.
        :param pulumi.Input[_builtins.int] ml_commons_native_memory_threshold: Native memory threshold percentage for ML Commons. Controls the maximum percentage of native memory that can be used by ML Commons operations. Defaults to 90%.
        :param pulumi.Input[_builtins.bool] ml_commons_only_run_on_ml_node: Enable or disable running ML Commons tasks only on ML nodes. When enabled, ML tasks will only execute on nodes designated as ML nodes. Defaults to true.
        :param pulumi.Input[_builtins.str] node_search_cache_size: Defines a limit of how much total remote data can be referenced as a ratio of the size of the disk reserved for the file cache. This is designed to be a safeguard to prevent oversubscribing a cluster. Defaults to 5gb. Requires restarting all OpenSearch nodes.
        :param pulumi.Input[_builtins.bool] override_main_response_version: Compatibility mode sets OpenSearch to report its version as 7.10 so clients continue to work. Default is false.
        :param pulumi.Input[_builtins.bool] plugins_alerting_filter_by_backend_roles: Enable or disable filtering of alerting by backend roles. Requires Security plugin. Defaults to false.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] reindex_remote_whitelists: Whitelisted addresses for reindexing. Changing this value will cause all OpenSearch instances to restart.
        :param pulumi.Input[_builtins.str] script_max_compilations_rate: Script compilation circuit breaker limits the number of inline script compilations within a period of time. Default is use-context. Example: `75/5m`.
        :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureArgs'] search_backpressure: Search Backpressure Settings
        :param pulumi.Input[_builtins.int] search_max_buckets: Maximum number of aggregation buckets allowed in a single response. OpenSearch default value is used when this is not defined. Example: `10000`.
        :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSegrepArgs'] segrep: Segment Replication Backpressure Settings
        :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureArgs'] shard_indexing_pressure: Shard indexing back pressure settings
        :param pulumi.Input[_builtins.int] thread_pool_analyze_queue_size: Size for the thread pool queue. See documentation for exact details.
        :param pulumi.Input[_builtins.int] thread_pool_analyze_size: Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        :param pulumi.Input[_builtins.int] thread_pool_force_merge_size: Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        :param pulumi.Input[_builtins.int] thread_pool_get_queue_size: Size for the thread pool queue. See documentation for exact details.
        :param pulumi.Input[_builtins.int] thread_pool_get_size: Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        :param pulumi.Input[_builtins.int] thread_pool_search_queue_size: Size for the thread pool queue. See documentation for exact details.
        :param pulumi.Input[_builtins.int] thread_pool_search_size: Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        :param pulumi.Input[_builtins.int] thread_pool_search_throttled_queue_size: Size for the thread pool queue. See documentation for exact details.
        :param pulumi.Input[_builtins.int] thread_pool_search_throttled_size: Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        :param pulumi.Input[_builtins.int] thread_pool_write_queue_size: Size for the thread pool queue. See documentation for exact details.
        :param pulumi.Input[_builtins.int] thread_pool_write_size: Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        """
        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 auth_failure_listeners is not None:
            pulumi.set(__self__, "auth_failure_listeners", auth_failure_listeners)
        if cluster_filecache_remote_data_ratio is not None:
            pulumi.set(__self__, "cluster_filecache_remote_data_ratio", cluster_filecache_remote_data_ratio)
        if cluster_max_shards_per_node is not None:
            pulumi.set(__self__, "cluster_max_shards_per_node", cluster_max_shards_per_node)
        if cluster_remote_store is not None:
            pulumi.set(__self__, "cluster_remote_store", cluster_remote_store)
        if cluster_routing_allocation_balance_prefer_primary is not None:
            pulumi.set(__self__, "cluster_routing_allocation_balance_prefer_primary", cluster_routing_allocation_balance_prefer_primary)
        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 cluster_search_request_slowlog is not None:
            pulumi.set(__self__, "cluster_search_request_slowlog", cluster_search_request_slowlog)
        if disk_watermarks is not None:
            pulumi.set(__self__, "disk_watermarks", disk_watermarks)
        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 enable_remote_backed_storage is not None:
            pulumi.set(__self__, "enable_remote_backed_storage", enable_remote_backed_storage)
        if enable_searchable_snapshots is not None:
            pulumi.set(__self__, "enable_searchable_snapshots", enable_searchable_snapshots)
        if enable_security_audit is not None:
            pulumi.set(__self__, "enable_security_audit", enable_security_audit)
        if enable_snapshot_api is not None:
            pulumi.set(__self__, "enable_snapshot_api", enable_snapshot_api)
        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_memory_max_index_buffer_size is not None:
            pulumi.set(__self__, "indices_memory_max_index_buffer_size", indices_memory_max_index_buffer_size)
        if indices_memory_min_index_buffer_size is not None:
            pulumi.set(__self__, "indices_memory_min_index_buffer_size", indices_memory_min_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 ism_enabled is not None:
            pulumi.set(__self__, "ism_enabled", ism_enabled)
        if ism_history_enabled is not None:
            pulumi.set(__self__, "ism_history_enabled", ism_history_enabled)
        if ism_history_max_age is not None:
            pulumi.set(__self__, "ism_history_max_age", ism_history_max_age)
        if ism_history_max_docs is not None:
            pulumi.set(__self__, "ism_history_max_docs", ism_history_max_docs)
        if ism_history_rollover_check_period is not None:
            pulumi.set(__self__, "ism_history_rollover_check_period", ism_history_rollover_check_period)
        if ism_history_rollover_retention_period is not None:
            pulumi.set(__self__, "ism_history_rollover_retention_period", ism_history_rollover_retention_period)
        if knn_memory_circuit_breaker_enabled is not None:
            pulumi.set(__self__, "knn_memory_circuit_breaker_enabled", knn_memory_circuit_breaker_enabled)
        if knn_memory_circuit_breaker_limit is not None:
            pulumi.set(__self__, "knn_memory_circuit_breaker_limit", knn_memory_circuit_breaker_limit)
        if ml_commons_model_access_control_enabled is not None:
            pulumi.set(__self__, "ml_commons_model_access_control_enabled", ml_commons_model_access_control_enabled)
        if ml_commons_native_memory_threshold is not None:
            pulumi.set(__self__, "ml_commons_native_memory_threshold", ml_commons_native_memory_threshold)
        if ml_commons_only_run_on_ml_node is not None:
            pulumi.set(__self__, "ml_commons_only_run_on_ml_node", ml_commons_only_run_on_ml_node)
        if node_search_cache_size is not None:
            pulumi.set(__self__, "node_search_cache_size", node_search_cache_size)
        if override_main_response_version is not None:
            pulumi.set(__self__, "override_main_response_version", override_main_response_version)
        if plugins_alerting_filter_by_backend_roles is not None:
            pulumi.set(__self__, "plugins_alerting_filter_by_backend_roles", plugins_alerting_filter_by_backend_roles)
        if reindex_remote_whitelists is not None:
            pulumi.set(__self__, "reindex_remote_whitelists", reindex_remote_whitelists)
        if remote_store is not None:
            pulumi.set(__self__, "remote_store", remote_store)
        if script_max_compilations_rate is not None:
            pulumi.set(__self__, "script_max_compilations_rate", script_max_compilations_rate)
        if search_backpressure is not None:
            pulumi.set(__self__, "search_backpressure", search_backpressure)
        if search_insights_top_queries is not None:
            pulumi.set(__self__, "search_insights_top_queries", search_insights_top_queries)
        if search_max_buckets is not None:
            pulumi.set(__self__, "search_max_buckets", search_max_buckets)
        if segrep is not None:
            pulumi.set(__self__, "segrep", segrep)
        if shard_indexing_pressure is not None:
            pulumi.set(__self__, "shard_indexing_pressure", shard_indexing_pressure)
        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)

    @_builtins.property
    @pulumi.getter(name="actionAutoCreateIndexEnabled")
    def action_auto_create_index_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Explicitly allow or block automatic creation of indices. Defaults to true.
        """
        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[_builtins.bool]]):
        pulumi.set(self, "action_auto_create_index_enabled", value)

    @_builtins.property
    @pulumi.getter(name="actionDestructiveRequiresName")
    def action_destructive_requires_name(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Require explicit index names when deleting.
        """
        return pulumi.get(self, "action_destructive_requires_name")

    @action_destructive_requires_name.setter
    def action_destructive_requires_name(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "action_destructive_requires_name", value)

    @_builtins.property
    @pulumi.getter(name="authFailureListeners")
    def auth_failure_listeners(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersArgs']]:
        """
        Opensearch Security Plugin Settings
        """
        return pulumi.get(self, "auth_failure_listeners")

    @auth_failure_listeners.setter
    def auth_failure_listeners(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersArgs']]):
        pulumi.set(self, "auth_failure_listeners", value)

    @_builtins.property
    @pulumi.getter(name="clusterFilecacheRemoteDataRatio")
    def cluster_filecache_remote_data_ratio(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        Defines a limit of how much total remote data can be referenced as a ratio of the size of the disk reserved for the file cache. This is designed to be a safeguard to prevent oversubscribing a cluster. Defaults to 0.
        """
        return pulumi.get(self, "cluster_filecache_remote_data_ratio")

    @cluster_filecache_remote_data_ratio.setter
    def cluster_filecache_remote_data_ratio(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "cluster_filecache_remote_data_ratio", value)

    @_builtins.property
    @pulumi.getter(name="clusterMaxShardsPerNode")
    def cluster_max_shards_per_node(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Controls the number of shards allowed in the cluster per data node. Example: `1000`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "cluster_max_shards_per_node", value)

    @_builtins.property
    @pulumi.getter(name="clusterRemoteStore")
    def cluster_remote_store(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchClusterRemoteStoreArgs']]:
        return pulumi.get(self, "cluster_remote_store")

    @cluster_remote_store.setter
    def cluster_remote_store(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchClusterRemoteStoreArgs']]):
        pulumi.set(self, "cluster_remote_store", value)

    @_builtins.property
    @pulumi.getter(name="clusterRoutingAllocationBalancePreferPrimary")
    def cluster_routing_allocation_balance_prefer_primary(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        When set to true, OpenSearch attempts to evenly distribute the primary shards between the cluster nodes. Enabling this setting does not always guarantee an equal number of primary shards on each node, especially in the event of a failover. Changing this setting to false after it was set to true does not invoke redistribution of primary shards. Default is false.
        """
        return pulumi.get(self, "cluster_routing_allocation_balance_prefer_primary")

    @cluster_routing_allocation_balance_prefer_primary.setter
    def cluster_routing_allocation_balance_prefer_primary(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "cluster_routing_allocation_balance_prefer_primary", value)

    @_builtins.property
    @pulumi.getter(name="clusterRoutingAllocationNodeConcurrentRecoveries")
    def cluster_routing_allocation_node_concurrent_recoveries(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        How many concurrent incoming/outgoing shard recoveries (normally replicas) are allowed to happen on a node. Defaults to node cpu count * 2.
        """
        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[_builtins.int]]):
        pulumi.set(self, "cluster_routing_allocation_node_concurrent_recoveries", value)

    @_builtins.property
    @pulumi.getter(name="clusterSearchRequestSlowlog")
    def cluster_search_request_slowlog(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogArgs']]:
        return pulumi.get(self, "cluster_search_request_slowlog")

    @cluster_search_request_slowlog.setter
    def cluster_search_request_slowlog(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogArgs']]):
        pulumi.set(self, "cluster_search_request_slowlog", value)

    @_builtins.property
    @pulumi.getter(name="diskWatermarks")
    def disk_watermarks(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchDiskWatermarksArgs']]:
        """
        Watermark settings
        """
        return pulumi.get(self, "disk_watermarks")

    @disk_watermarks.setter
    def disk_watermarks(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchDiskWatermarksArgs']]):
        pulumi.set(self, "disk_watermarks", value)

    @_builtins.property
    @pulumi.getter(name="emailSenderName")
    def email_sender_name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Sender name placeholder to be used in Opensearch Dashboards and Opensearch keystore. Example: `alert-sender`.
        """
        return pulumi.get(self, "email_sender_name")

    @email_sender_name.setter
    def email_sender_name(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "email_sender_name", value)

    @_builtins.property
    @pulumi.getter(name="emailSenderPassword")
    def email_sender_password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Sender password for Opensearch alerts to authenticate with SMTP server. Example: `very-secure-mail-password`.
        """
        return pulumi.get(self, "email_sender_password")

    @email_sender_password.setter
    def email_sender_password(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "email_sender_password", value)

    @_builtins.property
    @pulumi.getter(name="emailSenderUsername")
    def email_sender_username(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Sender username for Opensearch alerts. Example: `jane@example.com`.
        """
        return pulumi.get(self, "email_sender_username")

    @email_sender_username.setter
    def email_sender_username(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "email_sender_username", value)

    @_builtins.property
    @pulumi.getter(name="enableRemoteBackedStorage")
    def enable_remote_backed_storage(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable remote-backed storage.
        """
        return pulumi.get(self, "enable_remote_backed_storage")

    @enable_remote_backed_storage.setter
    def enable_remote_backed_storage(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "enable_remote_backed_storage", value)

    @_builtins.property
    @pulumi.getter(name="enableSearchableSnapshots")
    def enable_searchable_snapshots(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable searchable snapshots.
        """
        return pulumi.get(self, "enable_searchable_snapshots")

    @enable_searchable_snapshots.setter
    def enable_searchable_snapshots(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "enable_searchable_snapshots", value)

    @_builtins.property
    @pulumi.getter(name="enableSecurityAudit")
    def enable_security_audit(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable/Disable security audit.
        """
        return pulumi.get(self, "enable_security_audit")

    @enable_security_audit.setter
    def enable_security_audit(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "enable_security_audit", value)

    @_builtins.property
    @pulumi.getter(name="enableSnapshotApi")
    def enable_snapshot_api(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable/Disable snapshot API for custom repositories, this requires security management to be enabled.
        """
        return pulumi.get(self, "enable_snapshot_api")

    @enable_snapshot_api.setter
    def enable_snapshot_api(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "enable_snapshot_api", value)

    @_builtins.property
    @pulumi.getter(name="httpMaxContentLength")
    def http_max_content_length(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum content length for HTTP requests to the OpenSearch HTTP API, in bytes.
        """
        return pulumi.get(self, "http_max_content_length")

    @http_max_content_length.setter
    def http_max_content_length(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "http_max_content_length", value)

    @_builtins.property
    @pulumi.getter(name="httpMaxHeaderSize")
    def http_max_header_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The max size of allowed headers, in bytes. Example: `8192`.
        """
        return pulumi.get(self, "http_max_header_size")

    @http_max_header_size.setter
    def http_max_header_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "http_max_header_size", value)

    @_builtins.property
    @pulumi.getter(name="httpMaxInitialLineLength")
    def http_max_initial_line_length(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The max length of an HTTP URL, in bytes. Example: `4096`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "http_max_initial_line_length", value)

    @_builtins.property
    @pulumi.getter(name="indicesFielddataCacheSize")
    def indices_fielddata_cache_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Relative amount. Maximum amount of heap memory used for field data cache. This is an expert setting; decreasing the value too much will increase overhead of loading field data; too much memory used for field data cache will decrease amount of heap available for other operations.
        """
        return pulumi.get(self, "indices_fielddata_cache_size")

    @indices_fielddata_cache_size.setter
    def indices_fielddata_cache_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "indices_fielddata_cache_size", value)

    @_builtins.property
    @pulumi.getter(name="indicesMemoryIndexBufferSize")
    def indices_memory_index_buffer_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Percentage value. Default is 10%. Total amount of heap used for indexing buffer, before writing segments to disk. This is an expert setting. Too low value will slow down indexing; too high value will increase indexing performance but causes performance issues for query performance.
        """
        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[_builtins.int]]):
        pulumi.set(self, "indices_memory_index_buffer_size", value)

    @_builtins.property
    @pulumi.getter(name="indicesMemoryMaxIndexBufferSize")
    def indices_memory_max_index_buffer_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Absolute value. Default is unbound. Doesn't work without indices.memory.index*buffer*size. Maximum amount of heap used for query cache, an absolute indices.memory.index*buffer*size maximum hard limit.
        """
        return pulumi.get(self, "indices_memory_max_index_buffer_size")

    @indices_memory_max_index_buffer_size.setter
    def indices_memory_max_index_buffer_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "indices_memory_max_index_buffer_size", value)

    @_builtins.property
    @pulumi.getter(name="indicesMemoryMinIndexBufferSize")
    def indices_memory_min_index_buffer_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Absolute value. Default is 48mb. Doesn't work without indices.memory.index*buffer*size. Minimum amount of heap used for query cache, an absolute indices.memory.index*buffer*size minimal hard limit.
        """
        return pulumi.get(self, "indices_memory_min_index_buffer_size")

    @indices_memory_min_index_buffer_size.setter
    def indices_memory_min_index_buffer_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "indices_memory_min_index_buffer_size", value)

    @_builtins.property
    @pulumi.getter(name="indicesQueriesCacheSize")
    def indices_queries_cache_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Percentage value. Default is 10%. Maximum amount of heap used for query cache. This is an expert setting. Too low value will decrease query performance and increase performance for other operations; too high value will cause issues with other OpenSearch functionality.
        """
        return pulumi.get(self, "indices_queries_cache_size")

    @indices_queries_cache_size.setter
    def indices_queries_cache_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "indices_queries_cache_size", value)

    @_builtins.property
    @pulumi.getter(name="indicesQueryBoolMaxClauseCount")
    def indices_query_bool_max_clause_count(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum number of clauses Lucene BooleanQuery can have. The default value (1024) is relatively high, and increasing it may cause performance issues. Investigate other approaches first before increasing this value.
        """
        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[_builtins.int]]):
        pulumi.set(self, "indices_query_bool_max_clause_count", value)

    @_builtins.property
    @pulumi.getter(name="indicesRecoveryMaxBytesPerSec")
    def indices_recovery_max_bytes_per_sec(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Limits total inbound and outbound recovery traffic for each node. Applies to both peer recoveries as well as snapshot recoveries (i.e., restores from a snapshot). Defaults to 40mb.
        """
        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[_builtins.int]]):
        pulumi.set(self, "indices_recovery_max_bytes_per_sec", value)

    @_builtins.property
    @pulumi.getter(name="indicesRecoveryMaxConcurrentFileChunks")
    def indices_recovery_max_concurrent_file_chunks(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of file chunks sent in parallel for each recovery. Defaults to 2.
        """
        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[_builtins.int]]):
        pulumi.set(self, "indices_recovery_max_concurrent_file_chunks", value)

    @_builtins.property
    @pulumi.getter(name="ismEnabled")
    def ism_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Specifies whether ISM is enabled or not.
        """
        return pulumi.get(self, "ism_enabled")

    @ism_enabled.setter
    def ism_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ism_enabled", value)

    @_builtins.property
    @pulumi.getter(name="ismHistoryEnabled")
    def ism_history_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Specifies whether audit history is enabled or not. The logs from ISM are automatically indexed to a logs document.
        """
        return pulumi.get(self, "ism_history_enabled")

    @ism_history_enabled.setter
    def ism_history_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ism_history_enabled", value)

    @_builtins.property
    @pulumi.getter(name="ismHistoryMaxAge")
    def ism_history_max_age(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum age before rolling over the audit history index in hours. Example: `24`.
        """
        return pulumi.get(self, "ism_history_max_age")

    @ism_history_max_age.setter
    def ism_history_max_age(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "ism_history_max_age", value)

    @_builtins.property
    @pulumi.getter(name="ismHistoryMaxDocs")
    def ism_history_max_docs(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of documents before rolling over the audit history index.
        """
        return pulumi.get(self, "ism_history_max_docs")

    @ism_history_max_docs.setter
    def ism_history_max_docs(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "ism_history_max_docs", value)

    @_builtins.property
    @pulumi.getter(name="ismHistoryRolloverCheckPeriod")
    def ism_history_rollover_check_period(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The time between rollover checks for the audit history index in hours. Example: `8`.
        """
        return pulumi.get(self, "ism_history_rollover_check_period")

    @ism_history_rollover_check_period.setter
    def ism_history_rollover_check_period(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "ism_history_rollover_check_period", value)

    @_builtins.property
    @pulumi.getter(name="ismHistoryRolloverRetentionPeriod")
    def ism_history_rollover_retention_period(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        How long audit history indices are kept in days. Example: `30`.
        """
        return pulumi.get(self, "ism_history_rollover_retention_period")

    @ism_history_rollover_retention_period.setter
    def ism_history_rollover_retention_period(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "ism_history_rollover_retention_period", value)

    @_builtins.property
    @pulumi.getter(name="knnMemoryCircuitBreakerEnabled")
    def knn_memory_circuit_breaker_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable or disable KNN memory circuit breaker. Defaults to true.
        """
        return pulumi.get(self, "knn_memory_circuit_breaker_enabled")

    @knn_memory_circuit_breaker_enabled.setter
    def knn_memory_circuit_breaker_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "knn_memory_circuit_breaker_enabled", value)

    @_builtins.property
    @pulumi.getter(name="knnMemoryCircuitBreakerLimit")
    def knn_memory_circuit_breaker_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum amount of memory in percentage that can be used for the KNN index. Defaults to 50% of the JVM heap size. 0 is used to set it to null which can be used to invalidate caches.
        """
        return pulumi.get(self, "knn_memory_circuit_breaker_limit")

    @knn_memory_circuit_breaker_limit.setter
    def knn_memory_circuit_breaker_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "knn_memory_circuit_breaker_limit", value)

    @_builtins.property
    @pulumi.getter(name="mlCommonsModelAccessControlEnabled")
    def ml_commons_model_access_control_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable or disable model access control for ML Commons. When enabled, access to ML models is controlled by security permissions. Defaults to false.
        """
        return pulumi.get(self, "ml_commons_model_access_control_enabled")

    @ml_commons_model_access_control_enabled.setter
    def ml_commons_model_access_control_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ml_commons_model_access_control_enabled", value)

    @_builtins.property
    @pulumi.getter(name="mlCommonsNativeMemoryThreshold")
    def ml_commons_native_memory_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Native memory threshold percentage for ML Commons. Controls the maximum percentage of native memory that can be used by ML Commons operations. Defaults to 90%.
        """
        return pulumi.get(self, "ml_commons_native_memory_threshold")

    @ml_commons_native_memory_threshold.setter
    def ml_commons_native_memory_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "ml_commons_native_memory_threshold", value)

    @_builtins.property
    @pulumi.getter(name="mlCommonsOnlyRunOnMlNode")
    def ml_commons_only_run_on_ml_node(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable or disable running ML Commons tasks only on ML nodes. When enabled, ML tasks will only execute on nodes designated as ML nodes. Defaults to true.
        """
        return pulumi.get(self, "ml_commons_only_run_on_ml_node")

    @ml_commons_only_run_on_ml_node.setter
    def ml_commons_only_run_on_ml_node(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ml_commons_only_run_on_ml_node", value)

    @_builtins.property
    @pulumi.getter(name="nodeSearchCacheSize")
    def node_search_cache_size(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Defines a limit of how much total remote data can be referenced as a ratio of the size of the disk reserved for the file cache. This is designed to be a safeguard to prevent oversubscribing a cluster. Defaults to 5gb. Requires restarting all OpenSearch nodes.
        """
        return pulumi.get(self, "node_search_cache_size")

    @node_search_cache_size.setter
    def node_search_cache_size(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "node_search_cache_size", value)

    @_builtins.property
    @pulumi.getter(name="overrideMainResponseVersion")
    def override_main_response_version(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Compatibility mode sets OpenSearch to report its version as 7.10 so clients continue to work. Default is false.
        """
        return pulumi.get(self, "override_main_response_version")

    @override_main_response_version.setter
    def override_main_response_version(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "override_main_response_version", value)

    @_builtins.property
    @pulumi.getter(name="pluginsAlertingFilterByBackendRoles")
    def plugins_alerting_filter_by_backend_roles(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable or disable filtering of alerting by backend roles. Requires Security plugin. Defaults to false.
        """
        return pulumi.get(self, "plugins_alerting_filter_by_backend_roles")

    @plugins_alerting_filter_by_backend_roles.setter
    def plugins_alerting_filter_by_backend_roles(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "plugins_alerting_filter_by_backend_roles", value)

    @_builtins.property
    @pulumi.getter(name="reindexRemoteWhitelists")
    def reindex_remote_whitelists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Whitelisted addresses for reindexing. Changing this value will cause all OpenSearch instances to restart.
        """
        return pulumi.get(self, "reindex_remote_whitelists")

    @reindex_remote_whitelists.setter
    def reindex_remote_whitelists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "reindex_remote_whitelists", value)

    @_builtins.property
    @pulumi.getter(name="remoteStore")
    def remote_store(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchRemoteStoreArgs']]:
        return pulumi.get(self, "remote_store")

    @remote_store.setter
    def remote_store(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchRemoteStoreArgs']]):
        pulumi.set(self, "remote_store", value)

    @_builtins.property
    @pulumi.getter(name="scriptMaxCompilationsRate")
    def script_max_compilations_rate(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Script compilation circuit breaker limits the number of inline script compilations within a period of time. Default is use-context. Example: `75/5m`.
        """
        return pulumi.get(self, "script_max_compilations_rate")

    @script_max_compilations_rate.setter
    def script_max_compilations_rate(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "script_max_compilations_rate", value)

    @_builtins.property
    @pulumi.getter(name="searchBackpressure")
    def search_backpressure(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureArgs']]:
        """
        Search Backpressure Settings
        """
        return pulumi.get(self, "search_backpressure")

    @search_backpressure.setter
    def search_backpressure(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureArgs']]):
        pulumi.set(self, "search_backpressure", value)

    @_builtins.property
    @pulumi.getter(name="searchInsightsTopQueries")
    def search_insights_top_queries(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesArgs']]:
        return pulumi.get(self, "search_insights_top_queries")

    @search_insights_top_queries.setter
    def search_insights_top_queries(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesArgs']]):
        pulumi.set(self, "search_insights_top_queries", value)

    @_builtins.property
    @pulumi.getter(name="searchMaxBuckets")
    def search_max_buckets(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum number of aggregation buckets allowed in a single response. OpenSearch default value is used when this is not defined. Example: `10000`.
        """
        return pulumi.get(self, "search_max_buckets")

    @search_max_buckets.setter
    def search_max_buckets(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "search_max_buckets", value)

    @_builtins.property
    @pulumi.getter
    def segrep(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSegrepArgs']]:
        """
        Segment Replication Backpressure Settings
        """
        return pulumi.get(self, "segrep")

    @segrep.setter
    def segrep(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSegrepArgs']]):
        pulumi.set(self, "segrep", value)

    @_builtins.property
    @pulumi.getter(name="shardIndexingPressure")
    def shard_indexing_pressure(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureArgs']]:
        """
        Shard indexing back pressure settings
        """
        return pulumi.get(self, "shard_indexing_pressure")

    @shard_indexing_pressure.setter
    def shard_indexing_pressure(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureArgs']]):
        pulumi.set(self, "shard_indexing_pressure", value)

    @_builtins.property
    @pulumi.getter(name="threadPoolAnalyzeQueueSize")
    def thread_pool_analyze_queue_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Size for the thread pool queue. See documentation for exact details.
        """
        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[_builtins.int]]):
        pulumi.set(self, "thread_pool_analyze_queue_size", value)

    @_builtins.property
    @pulumi.getter(name="threadPoolAnalyzeSize")
    def thread_pool_analyze_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        """
        return pulumi.get(self, "thread_pool_analyze_size")

    @thread_pool_analyze_size.setter
    def thread_pool_analyze_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "thread_pool_analyze_size", value)

    @_builtins.property
    @pulumi.getter(name="threadPoolForceMergeSize")
    def thread_pool_force_merge_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        """
        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[_builtins.int]]):
        pulumi.set(self, "thread_pool_force_merge_size", value)

    @_builtins.property
    @pulumi.getter(name="threadPoolGetQueueSize")
    def thread_pool_get_queue_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Size for the thread pool queue. See documentation for exact details.
        """
        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[_builtins.int]]):
        pulumi.set(self, "thread_pool_get_queue_size", value)

    @_builtins.property
    @pulumi.getter(name="threadPoolGetSize")
    def thread_pool_get_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        """
        return pulumi.get(self, "thread_pool_get_size")

    @thread_pool_get_size.setter
    def thread_pool_get_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "thread_pool_get_size", value)

    @_builtins.property
    @pulumi.getter(name="threadPoolSearchQueueSize")
    def thread_pool_search_queue_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Size for the thread pool queue. See documentation for exact details.
        """
        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[_builtins.int]]):
        pulumi.set(self, "thread_pool_search_queue_size", value)

    @_builtins.property
    @pulumi.getter(name="threadPoolSearchSize")
    def thread_pool_search_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        """
        return pulumi.get(self, "thread_pool_search_size")

    @thread_pool_search_size.setter
    def thread_pool_search_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "thread_pool_search_size", value)

    @_builtins.property
    @pulumi.getter(name="threadPoolSearchThrottledQueueSize")
    def thread_pool_search_throttled_queue_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Size for the thread pool queue. See documentation for exact details.
        """
        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[_builtins.int]]):
        pulumi.set(self, "thread_pool_search_throttled_queue_size", value)

    @_builtins.property
    @pulumi.getter(name="threadPoolSearchThrottledSize")
    def thread_pool_search_throttled_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        """
        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[_builtins.int]]):
        pulumi.set(self, "thread_pool_search_throttled_size", value)

    @_builtins.property
    @pulumi.getter(name="threadPoolWriteQueueSize")
    def thread_pool_write_queue_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Size for the thread pool queue. See documentation for exact details.
        """
        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[_builtins.int]]):
        pulumi.set(self, "thread_pool_write_queue_size", value)

    @_builtins.property
    @pulumi.getter(name="threadPoolWriteSize")
    def thread_pool_write_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Size for the thread pool. See documentation for exact details. Do note this may have maximum value depending on CPU count - value is automatically lowered if set to higher than maximum value.
        """
        return pulumi.get(self, "thread_pool_write_size")

    @thread_pool_write_size.setter
    def thread_pool_write_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "thread_pool_write_size", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersArgsDict(TypedDict):
        internal_authentication_backend_limiting: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersInternalAuthenticationBackendLimitingArgsDict']]
        ip_rate_limiting: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersIpRateLimitingArgsDict']]
        """
        IP address rate limiting settings
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersArgs:
    def __init__(__self__, *,
                 internal_authentication_backend_limiting: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersInternalAuthenticationBackendLimitingArgs']] = None,
                 ip_rate_limiting: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersIpRateLimitingArgs']] = None):
        """
        :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersIpRateLimitingArgs'] ip_rate_limiting: IP address rate limiting settings
        """
        if internal_authentication_backend_limiting is not None:
            pulumi.set(__self__, "internal_authentication_backend_limiting", internal_authentication_backend_limiting)
        if ip_rate_limiting is not None:
            warnings.warn("""This property is deprecated.""", DeprecationWarning)
            pulumi.log.warn("""ip_rate_limiting is deprecated: This property is deprecated.""")
        if ip_rate_limiting is not None:
            pulumi.set(__self__, "ip_rate_limiting", ip_rate_limiting)

    @_builtins.property
    @pulumi.getter(name="internalAuthenticationBackendLimiting")
    def internal_authentication_backend_limiting(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersInternalAuthenticationBackendLimitingArgs']]:
        return pulumi.get(self, "internal_authentication_backend_limiting")

    @internal_authentication_backend_limiting.setter
    def internal_authentication_backend_limiting(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersInternalAuthenticationBackendLimitingArgs']]):
        pulumi.set(self, "internal_authentication_backend_limiting", value)

    @_builtins.property
    @pulumi.getter(name="ipRateLimiting")
    @_utilities.deprecated("""This property is deprecated.""")
    def ip_rate_limiting(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersIpRateLimitingArgs']]:
        """
        IP address rate limiting settings
        """
        return pulumi.get(self, "ip_rate_limiting")

    @ip_rate_limiting.setter
    def ip_rate_limiting(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersIpRateLimitingArgs']]):
        pulumi.set(self, "ip_rate_limiting", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersInternalAuthenticationBackendLimitingArgsDict(TypedDict):
        allowed_tries: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of login attempts allowed before login is blocked. Example: `10`.
        """
        authentication_backend: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `internal`. internal*authentication*backend*limiting.authentication*backend.
        """
        block_expiry_seconds: NotRequired[pulumi.Input[_builtins.int]]
        """
        The duration of time that login remains blocked after a failed login. Example: `600`.
        """
        max_blocked_clients: NotRequired[pulumi.Input[_builtins.int]]
        """
        internal*authentication*backend*limiting.max*blocked_clients. Example: `100000`.
        """
        max_tracked_clients: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of tracked IP addresses that have failed login. Example: `100000`.
        """
        time_window_seconds: NotRequired[pulumi.Input[_builtins.int]]
        """
        The window of time in which the value for `allowed_tries` is enforced. Example: `3600`.
        """
        type: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `username`. internal*authentication*backend_limiting.type.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersInternalAuthenticationBackendLimitingArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersInternalAuthenticationBackendLimitingArgs:
    def __init__(__self__, *,
                 allowed_tries: Optional[pulumi.Input[_builtins.int]] = None,
                 authentication_backend: Optional[pulumi.Input[_builtins.str]] = None,
                 block_expiry_seconds: Optional[pulumi.Input[_builtins.int]] = None,
                 max_blocked_clients: Optional[pulumi.Input[_builtins.int]] = None,
                 max_tracked_clients: Optional[pulumi.Input[_builtins.int]] = None,
                 time_window_seconds: Optional[pulumi.Input[_builtins.int]] = None,
                 type: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.int] allowed_tries: The number of login attempts allowed before login is blocked. Example: `10`.
        :param pulumi.Input[_builtins.str] authentication_backend: Enum: `internal`. internal*authentication*backend*limiting.authentication*backend.
        :param pulumi.Input[_builtins.int] block_expiry_seconds: The duration of time that login remains blocked after a failed login. Example: `600`.
        :param pulumi.Input[_builtins.int] max_blocked_clients: internal*authentication*backend*limiting.max*blocked_clients. Example: `100000`.
        :param pulumi.Input[_builtins.int] max_tracked_clients: The maximum number of tracked IP addresses that have failed login. Example: `100000`.
        :param pulumi.Input[_builtins.int] time_window_seconds: The window of time in which the value for `allowed_tries` is enforced. Example: `3600`.
        :param pulumi.Input[_builtins.str] type: Enum: `username`. internal*authentication*backend_limiting.type.
        """
        if allowed_tries is not None:
            pulumi.set(__self__, "allowed_tries", allowed_tries)
        if authentication_backend is not None:
            pulumi.set(__self__, "authentication_backend", authentication_backend)
        if block_expiry_seconds is not None:
            pulumi.set(__self__, "block_expiry_seconds", block_expiry_seconds)
        if max_blocked_clients is not None:
            pulumi.set(__self__, "max_blocked_clients", max_blocked_clients)
        if max_tracked_clients is not None:
            pulumi.set(__self__, "max_tracked_clients", max_tracked_clients)
        if time_window_seconds is not None:
            pulumi.set(__self__, "time_window_seconds", time_window_seconds)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @_builtins.property
    @pulumi.getter(name="allowedTries")
    def allowed_tries(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of login attempts allowed before login is blocked. Example: `10`.
        """
        return pulumi.get(self, "allowed_tries")

    @allowed_tries.setter
    def allowed_tries(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "allowed_tries", value)

    @_builtins.property
    @pulumi.getter(name="authenticationBackend")
    def authentication_backend(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `internal`. internal*authentication*backend*limiting.authentication*backend.
        """
        return pulumi.get(self, "authentication_backend")

    @authentication_backend.setter
    def authentication_backend(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "authentication_backend", value)

    @_builtins.property
    @pulumi.getter(name="blockExpirySeconds")
    def block_expiry_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The duration of time that login remains blocked after a failed login. Example: `600`.
        """
        return pulumi.get(self, "block_expiry_seconds")

    @block_expiry_seconds.setter
    def block_expiry_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "block_expiry_seconds", value)

    @_builtins.property
    @pulumi.getter(name="maxBlockedClients")
    def max_blocked_clients(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        internal*authentication*backend*limiting.max*blocked_clients. Example: `100000`.
        """
        return pulumi.get(self, "max_blocked_clients")

    @max_blocked_clients.setter
    def max_blocked_clients(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_blocked_clients", value)

    @_builtins.property
    @pulumi.getter(name="maxTrackedClients")
    def max_tracked_clients(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of tracked IP addresses that have failed login. Example: `100000`.
        """
        return pulumi.get(self, "max_tracked_clients")

    @max_tracked_clients.setter
    def max_tracked_clients(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_tracked_clients", value)

    @_builtins.property
    @pulumi.getter(name="timeWindowSeconds")
    def time_window_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The window of time in which the value for `allowed_tries` is enforced. Example: `3600`.
        """
        return pulumi.get(self, "time_window_seconds")

    @time_window_seconds.setter
    def time_window_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "time_window_seconds", value)

    @_builtins.property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `username`. internal*authentication*backend_limiting.type.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "type", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersIpRateLimitingArgsDict(TypedDict):
        allowed_tries: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of login attempts allowed before login is blocked. Example: `10`.
        """
        block_expiry_seconds: NotRequired[pulumi.Input[_builtins.int]]
        """
        The duration of time that login remains blocked after a failed login. Example: `600`.
        """
        max_blocked_clients: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of blocked IP addresses. Example: `100000`.
        """
        max_tracked_clients: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of tracked IP addresses that have failed login. Example: `100000`.
        """
        time_window_seconds: NotRequired[pulumi.Input[_builtins.int]]
        """
        The window of time in which the value for `allowed_tries` is enforced. Example: `3600`.
        """
        type: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `ip`. The type of rate limiting.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersIpRateLimitingArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchAuthFailureListenersIpRateLimitingArgs:
    def __init__(__self__, *,
                 allowed_tries: Optional[pulumi.Input[_builtins.int]] = None,
                 block_expiry_seconds: Optional[pulumi.Input[_builtins.int]] = None,
                 max_blocked_clients: Optional[pulumi.Input[_builtins.int]] = None,
                 max_tracked_clients: Optional[pulumi.Input[_builtins.int]] = None,
                 time_window_seconds: Optional[pulumi.Input[_builtins.int]] = None,
                 type: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.int] allowed_tries: The number of login attempts allowed before login is blocked. Example: `10`.
        :param pulumi.Input[_builtins.int] block_expiry_seconds: The duration of time that login remains blocked after a failed login. Example: `600`.
        :param pulumi.Input[_builtins.int] max_blocked_clients: The maximum number of blocked IP addresses. Example: `100000`.
        :param pulumi.Input[_builtins.int] max_tracked_clients: The maximum number of tracked IP addresses that have failed login. Example: `100000`.
        :param pulumi.Input[_builtins.int] time_window_seconds: The window of time in which the value for `allowed_tries` is enforced. Example: `3600`.
        :param pulumi.Input[_builtins.str] type: Enum: `ip`. The type of rate limiting.
        """
        if allowed_tries is not None:
            pulumi.set(__self__, "allowed_tries", allowed_tries)
        if block_expiry_seconds is not None:
            pulumi.set(__self__, "block_expiry_seconds", block_expiry_seconds)
        if max_blocked_clients is not None:
            pulumi.set(__self__, "max_blocked_clients", max_blocked_clients)
        if max_tracked_clients is not None:
            pulumi.set(__self__, "max_tracked_clients", max_tracked_clients)
        if time_window_seconds is not None:
            pulumi.set(__self__, "time_window_seconds", time_window_seconds)
        if type is not None:
            pulumi.set(__self__, "type", type)

    @_builtins.property
    @pulumi.getter(name="allowedTries")
    def allowed_tries(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of login attempts allowed before login is blocked. Example: `10`.
        """
        return pulumi.get(self, "allowed_tries")

    @allowed_tries.setter
    def allowed_tries(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "allowed_tries", value)

    @_builtins.property
    @pulumi.getter(name="blockExpirySeconds")
    def block_expiry_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The duration of time that login remains blocked after a failed login. Example: `600`.
        """
        return pulumi.get(self, "block_expiry_seconds")

    @block_expiry_seconds.setter
    def block_expiry_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "block_expiry_seconds", value)

    @_builtins.property
    @pulumi.getter(name="maxBlockedClients")
    def max_blocked_clients(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of blocked IP addresses. Example: `100000`.
        """
        return pulumi.get(self, "max_blocked_clients")

    @max_blocked_clients.setter
    def max_blocked_clients(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_blocked_clients", value)

    @_builtins.property
    @pulumi.getter(name="maxTrackedClients")
    def max_tracked_clients(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of tracked IP addresses that have failed login. Example: `100000`.
        """
        return pulumi.get(self, "max_tracked_clients")

    @max_tracked_clients.setter
    def max_tracked_clients(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_tracked_clients", value)

    @_builtins.property
    @pulumi.getter(name="timeWindowSeconds")
    def time_window_seconds(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The window of time in which the value for `allowed_tries` is enforced. Example: `3600`.
        """
        return pulumi.get(self, "time_window_seconds")

    @time_window_seconds.setter
    def time_window_seconds(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "time_window_seconds", value)

    @_builtins.property
    @pulumi.getter
    def type(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `ip`. The type of rate limiting.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "type", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchClusterRemoteStoreArgsDict(TypedDict):
        state_global_metadata_upload_timeout: NotRequired[pulumi.Input[_builtins.str]]
        """
        The amount of time to wait for the cluster state upload to complete. Defaults to 20s.
        """
        state_metadata_manifest_upload_timeout: NotRequired[pulumi.Input[_builtins.str]]
        """
        The amount of time to wait for the manifest file upload to complete. The manifest file contains the details of each of the files uploaded for a single cluster state, both index metadata files and global metadata files. Defaults to 20s.
        """
        translog_buffer_interval: NotRequired[pulumi.Input[_builtins.str]]
        """
        The default value of the translog buffer interval used when performing periodic translog updates. This setting is only effective when the index setting `index.remote_store.translog.buffer_interval` is not present. Defaults to 650ms.
        """
        translog_max_readers: NotRequired[pulumi.Input[_builtins.int]]
        """
        Sets the maximum number of open translog files for remote-backed indexes. This limits the total number of translog files per shard. After reaching this limit, the remote store flushes the translog files. Default is 1000. The minimum required is 100. Example: `1000`.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchClusterRemoteStoreArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchClusterRemoteStoreArgs:
    def __init__(__self__, *,
                 state_global_metadata_upload_timeout: Optional[pulumi.Input[_builtins.str]] = None,
                 state_metadata_manifest_upload_timeout: Optional[pulumi.Input[_builtins.str]] = None,
                 translog_buffer_interval: Optional[pulumi.Input[_builtins.str]] = None,
                 translog_max_readers: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.str] state_global_metadata_upload_timeout: The amount of time to wait for the cluster state upload to complete. Defaults to 20s.
        :param pulumi.Input[_builtins.str] state_metadata_manifest_upload_timeout: The amount of time to wait for the manifest file upload to complete. The manifest file contains the details of each of the files uploaded for a single cluster state, both index metadata files and global metadata files. Defaults to 20s.
        :param pulumi.Input[_builtins.str] translog_buffer_interval: The default value of the translog buffer interval used when performing periodic translog updates. This setting is only effective when the index setting `index.remote_store.translog.buffer_interval` is not present. Defaults to 650ms.
        :param pulumi.Input[_builtins.int] translog_max_readers: Sets the maximum number of open translog files for remote-backed indexes. This limits the total number of translog files per shard. After reaching this limit, the remote store flushes the translog files. Default is 1000. The minimum required is 100. Example: `1000`.
        """
        if state_global_metadata_upload_timeout is not None:
            pulumi.set(__self__, "state_global_metadata_upload_timeout", state_global_metadata_upload_timeout)
        if state_metadata_manifest_upload_timeout is not None:
            pulumi.set(__self__, "state_metadata_manifest_upload_timeout", state_metadata_manifest_upload_timeout)
        if translog_buffer_interval is not None:
            pulumi.set(__self__, "translog_buffer_interval", translog_buffer_interval)
        if translog_max_readers is not None:
            pulumi.set(__self__, "translog_max_readers", translog_max_readers)

    @_builtins.property
    @pulumi.getter(name="stateGlobalMetadataUploadTimeout")
    def state_global_metadata_upload_timeout(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The amount of time to wait for the cluster state upload to complete. Defaults to 20s.
        """
        return pulumi.get(self, "state_global_metadata_upload_timeout")

    @state_global_metadata_upload_timeout.setter
    def state_global_metadata_upload_timeout(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "state_global_metadata_upload_timeout", value)

    @_builtins.property
    @pulumi.getter(name="stateMetadataManifestUploadTimeout")
    def state_metadata_manifest_upload_timeout(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The amount of time to wait for the manifest file upload to complete. The manifest file contains the details of each of the files uploaded for a single cluster state, both index metadata files and global metadata files. Defaults to 20s.
        """
        return pulumi.get(self, "state_metadata_manifest_upload_timeout")

    @state_metadata_manifest_upload_timeout.setter
    def state_metadata_manifest_upload_timeout(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "state_metadata_manifest_upload_timeout", value)

    @_builtins.property
    @pulumi.getter(name="translogBufferInterval")
    def translog_buffer_interval(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The default value of the translog buffer interval used when performing periodic translog updates. This setting is only effective when the index setting `index.remote_store.translog.buffer_interval` is not present. Defaults to 650ms.
        """
        return pulumi.get(self, "translog_buffer_interval")

    @translog_buffer_interval.setter
    def translog_buffer_interval(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "translog_buffer_interval", value)

    @_builtins.property
    @pulumi.getter(name="translogMaxReaders")
    def translog_max_readers(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Sets the maximum number of open translog files for remote-backed indexes. This limits the total number of translog files per shard. After reaching this limit, the remote store flushes the translog files. Default is 1000. The minimum required is 100. Example: `1000`.
        """
        return pulumi.get(self, "translog_max_readers")

    @translog_max_readers.setter
    def translog_max_readers(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "translog_max_readers", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogArgsDict(TypedDict):
        level: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `debug`, `info`, `trace`, `warn`. Log level. Default: `trace`.
        """
        threshold: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogThresholdArgsDict']]
elif False:
    OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogArgs:
    def __init__(__self__, *,
                 level: Optional[pulumi.Input[_builtins.str]] = None,
                 threshold: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogThresholdArgs']] = None):
        """
        :param pulumi.Input[_builtins.str] level: Enum: `debug`, `info`, `trace`, `warn`. Log level. Default: `trace`.
        """
        if level is not None:
            pulumi.set(__self__, "level", level)
        if threshold is not None:
            pulumi.set(__self__, "threshold", threshold)

    @_builtins.property
    @pulumi.getter
    def level(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `debug`, `info`, `trace`, `warn`. Log level. Default: `trace`.
        """
        return pulumi.get(self, "level")

    @level.setter
    def level(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "level", value)

    @_builtins.property
    @pulumi.getter
    def threshold(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogThresholdArgs']]:
        return pulumi.get(self, "threshold")

    @threshold.setter
    def threshold(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogThresholdArgs']]):
        pulumi.set(self, "threshold", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogThresholdArgsDict(TypedDict):
        debug: NotRequired[pulumi.Input[_builtins.str]]
        """
        Debug threshold for total request took time. The value should be in the form count and unit, where unit one of (s,m,h,d,nanos,ms,micros) or -1. Default is -1.
        """
        info: NotRequired[pulumi.Input[_builtins.str]]
        """
        Info threshold for total request took time. The value should be in the form count and unit, where unit one of (s,m,h,d,nanos,ms,micros) or -1. Default is -1.
        """
        trace: NotRequired[pulumi.Input[_builtins.str]]
        """
        Trace threshold for total request took time. The value should be in the form count and unit, where unit one of (s,m,h,d,nanos,ms,micros) or -1. Default is -1.
        """
        warn: NotRequired[pulumi.Input[_builtins.str]]
        """
        Warning threshold for total request took time. The value should be in the form count and unit, where unit one of (s,m,h,d,nanos,ms,micros) or -1. Default is -1.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogThresholdArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchClusterSearchRequestSlowlogThresholdArgs:
    def __init__(__self__, *,
                 debug: Optional[pulumi.Input[_builtins.str]] = None,
                 info: Optional[pulumi.Input[_builtins.str]] = None,
                 trace: Optional[pulumi.Input[_builtins.str]] = None,
                 warn: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] debug: Debug threshold for total request took time. The value should be in the form count and unit, where unit one of (s,m,h,d,nanos,ms,micros) or -1. Default is -1.
        :param pulumi.Input[_builtins.str] info: Info threshold for total request took time. The value should be in the form count and unit, where unit one of (s,m,h,d,nanos,ms,micros) or -1. Default is -1.
        :param pulumi.Input[_builtins.str] trace: Trace threshold for total request took time. The value should be in the form count and unit, where unit one of (s,m,h,d,nanos,ms,micros) or -1. Default is -1.
        :param pulumi.Input[_builtins.str] warn: Warning threshold for total request took time. The value should be in the form count and unit, where unit one of (s,m,h,d,nanos,ms,micros) or -1. Default is -1.
        """
        if debug is not None:
            pulumi.set(__self__, "debug", debug)
        if info is not None:
            pulumi.set(__self__, "info", info)
        if trace is not None:
            pulumi.set(__self__, "trace", trace)
        if warn is not None:
            pulumi.set(__self__, "warn", warn)

    @_builtins.property
    @pulumi.getter
    def debug(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Debug threshold for total request took time. The value should be in the form count and unit, where unit one of (s,m,h,d,nanos,ms,micros) or -1. Default is -1.
        """
        return pulumi.get(self, "debug")

    @debug.setter
    def debug(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "debug", value)

    @_builtins.property
    @pulumi.getter
    def info(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Info threshold for total request took time. The value should be in the form count and unit, where unit one of (s,m,h,d,nanos,ms,micros) or -1. Default is -1.
        """
        return pulumi.get(self, "info")

    @info.setter
    def info(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "info", value)

    @_builtins.property
    @pulumi.getter
    def trace(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Trace threshold for total request took time. The value should be in the form count and unit, where unit one of (s,m,h,d,nanos,ms,micros) or -1. Default is -1.
        """
        return pulumi.get(self, "trace")

    @trace.setter
    def trace(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "trace", value)

    @_builtins.property
    @pulumi.getter
    def warn(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Warning threshold for total request took time. The value should be in the form count and unit, where unit one of (s,m,h,d,nanos,ms,micros) or -1. Default is -1.
        """
        return pulumi.get(self, "warn")

    @warn.setter
    def warn(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "warn", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchDashboardsArgsDict(TypedDict):
        enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable or disable OpenSearch Dashboards. Default: `true`.
        """
        max_old_space_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Limits the maximum amount of memory (in MiB) the OpenSearch Dashboards process can use. This sets the max*old*space_size option of the nodejs running the OpenSearch Dashboards. Note: the memory reserved by OpenSearch Dashboards is not available for OpenSearch. Default: `128`.
        """
        multiple_data_source_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable or disable multiple data sources in OpenSearch Dashboards. Default: `true`.
        """
        opensearch_request_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        Timeout in milliseconds for requests made by OpenSearch Dashboards towards OpenSearch. Default: `30000`.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchDashboardsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchDashboardsArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 max_old_space_size: Optional[pulumi.Input[_builtins.int]] = None,
                 multiple_data_source_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 opensearch_request_timeout: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.bool] enabled: Enable or disable OpenSearch Dashboards. Default: `true`.
        :param pulumi.Input[_builtins.int] max_old_space_size: Limits the maximum amount of memory (in MiB) the OpenSearch Dashboards process can use. This sets the max*old*space_size option of the nodejs running the OpenSearch Dashboards. Note: the memory reserved by OpenSearch Dashboards is not available for OpenSearch. Default: `128`.
        :param pulumi.Input[_builtins.bool] multiple_data_source_enabled: Enable or disable multiple data sources in OpenSearch Dashboards. Default: `true`.
        :param pulumi.Input[_builtins.int] opensearch_request_timeout: Timeout in milliseconds for requests made by OpenSearch Dashboards towards OpenSearch. Default: `30000`.
        """
        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 multiple_data_source_enabled is not None:
            pulumi.set(__self__, "multiple_data_source_enabled", multiple_data_source_enabled)
        if opensearch_request_timeout is not None:
            pulumi.set(__self__, "opensearch_request_timeout", opensearch_request_timeout)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable or disable OpenSearch Dashboards. Default: `true`.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "enabled", value)

    @_builtins.property
    @pulumi.getter(name="maxOldSpaceSize")
    def max_old_space_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Limits the maximum amount of memory (in MiB) the OpenSearch Dashboards process can use. This sets the max*old*space_size option of the nodejs running the OpenSearch Dashboards. Note: the memory reserved by OpenSearch Dashboards is not available for OpenSearch. Default: `128`.
        """
        return pulumi.get(self, "max_old_space_size")

    @max_old_space_size.setter
    def max_old_space_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_old_space_size", value)

    @_builtins.property
    @pulumi.getter(name="multipleDataSourceEnabled")
    def multiple_data_source_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable or disable multiple data sources in OpenSearch Dashboards. Default: `true`.
        """
        return pulumi.get(self, "multiple_data_source_enabled")

    @multiple_data_source_enabled.setter
    def multiple_data_source_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "multiple_data_source_enabled", value)

    @_builtins.property
    @pulumi.getter(name="opensearchRequestTimeout")
    def opensearch_request_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Timeout in milliseconds for requests made by OpenSearch Dashboards towards OpenSearch. Default: `30000`.
        """
        return pulumi.get(self, "opensearch_request_timeout")

    @opensearch_request_timeout.setter
    def opensearch_request_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "opensearch_request_timeout", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchDiskWatermarksArgsDict(TypedDict):
        flood_stage: pulumi.Input[_builtins.int]
        """
        The flood stage watermark for disk usage. Example: `95`.
        """
        high: pulumi.Input[_builtins.int]
        """
        The high watermark for disk usage. Example: `90`.
        """
        low: pulumi.Input[_builtins.int]
        """
        The low watermark for disk usage. Example: `85`.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchDiskWatermarksArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchDiskWatermarksArgs:
    def __init__(__self__, *,
                 flood_stage: pulumi.Input[_builtins.int],
                 high: pulumi.Input[_builtins.int],
                 low: pulumi.Input[_builtins.int]):
        """
        :param pulumi.Input[_builtins.int] flood_stage: The flood stage watermark for disk usage. Example: `95`.
        :param pulumi.Input[_builtins.int] high: The high watermark for disk usage. Example: `90`.
        :param pulumi.Input[_builtins.int] low: The low watermark for disk usage. Example: `85`.
        """
        pulumi.set(__self__, "flood_stage", flood_stage)
        pulumi.set(__self__, "high", high)
        pulumi.set(__self__, "low", low)

    @_builtins.property
    @pulumi.getter(name="floodStage")
    def flood_stage(self) -> pulumi.Input[_builtins.int]:
        """
        The flood stage watermark for disk usage. Example: `95`.
        """
        return pulumi.get(self, "flood_stage")

    @flood_stage.setter
    def flood_stage(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "flood_stage", value)

    @_builtins.property
    @pulumi.getter
    def high(self) -> pulumi.Input[_builtins.int]:
        """
        The high watermark for disk usage. Example: `90`.
        """
        return pulumi.get(self, "high")

    @high.setter
    def high(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "high", value)

    @_builtins.property
    @pulumi.getter
    def low(self) -> pulumi.Input[_builtins.int]:
        """
        The low watermark for disk usage. Example: `85`.
        """
        return pulumi.get(self, "low")

    @low.setter
    def low(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "low", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchRemoteStoreArgsDict(TypedDict):
        segment_pressure_bytes_lag_variance_factor: NotRequired[pulumi.Input[_builtins.float]]
        """
        The variance factor that is used together with the moving average to calculate the dynamic bytes lag threshold for activating remote segment backpressure. Defaults to 10.
        """
        segment_pressure_consecutive_failures_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        The minimum consecutive failure count for activating remote segment backpressure. Defaults to 5.
        """
        segment_pressure_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enables remote segment backpressure. Default is `true`.
        """
        segment_pressure_time_lag_variance_factor: NotRequired[pulumi.Input[_builtins.float]]
        """
        The variance factor that is used together with the moving average to calculate the dynamic time lag threshold for activating remote segment backpressure. Defaults to 10.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchRemoteStoreArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchRemoteStoreArgs:
    def __init__(__self__, *,
                 segment_pressure_bytes_lag_variance_factor: Optional[pulumi.Input[_builtins.float]] = None,
                 segment_pressure_consecutive_failures_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 segment_pressure_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 segment_pressure_time_lag_variance_factor: Optional[pulumi.Input[_builtins.float]] = None):
        """
        :param pulumi.Input[_builtins.float] segment_pressure_bytes_lag_variance_factor: The variance factor that is used together with the moving average to calculate the dynamic bytes lag threshold for activating remote segment backpressure. Defaults to 10.
        :param pulumi.Input[_builtins.int] segment_pressure_consecutive_failures_limit: The minimum consecutive failure count for activating remote segment backpressure. Defaults to 5.
        :param pulumi.Input[_builtins.bool] segment_pressure_enabled: Enables remote segment backpressure. Default is `true`.
        :param pulumi.Input[_builtins.float] segment_pressure_time_lag_variance_factor: The variance factor that is used together with the moving average to calculate the dynamic time lag threshold for activating remote segment backpressure. Defaults to 10.
        """
        if segment_pressure_bytes_lag_variance_factor is not None:
            pulumi.set(__self__, "segment_pressure_bytes_lag_variance_factor", segment_pressure_bytes_lag_variance_factor)
        if segment_pressure_consecutive_failures_limit is not None:
            pulumi.set(__self__, "segment_pressure_consecutive_failures_limit", segment_pressure_consecutive_failures_limit)
        if segment_pressure_enabled is not None:
            pulumi.set(__self__, "segment_pressure_enabled", segment_pressure_enabled)
        if segment_pressure_time_lag_variance_factor is not None:
            pulumi.set(__self__, "segment_pressure_time_lag_variance_factor", segment_pressure_time_lag_variance_factor)

    @_builtins.property
    @pulumi.getter(name="segmentPressureBytesLagVarianceFactor")
    def segment_pressure_bytes_lag_variance_factor(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The variance factor that is used together with the moving average to calculate the dynamic bytes lag threshold for activating remote segment backpressure. Defaults to 10.
        """
        return pulumi.get(self, "segment_pressure_bytes_lag_variance_factor")

    @segment_pressure_bytes_lag_variance_factor.setter
    def segment_pressure_bytes_lag_variance_factor(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "segment_pressure_bytes_lag_variance_factor", value)

    @_builtins.property
    @pulumi.getter(name="segmentPressureConsecutiveFailuresLimit")
    def segment_pressure_consecutive_failures_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The minimum consecutive failure count for activating remote segment backpressure. Defaults to 5.
        """
        return pulumi.get(self, "segment_pressure_consecutive_failures_limit")

    @segment_pressure_consecutive_failures_limit.setter
    def segment_pressure_consecutive_failures_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "segment_pressure_consecutive_failures_limit", value)

    @_builtins.property
    @pulumi.getter(name="segmentPressureEnabled")
    def segment_pressure_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enables remote segment backpressure. Default is `true`.
        """
        return pulumi.get(self, "segment_pressure_enabled")

    @segment_pressure_enabled.setter
    def segment_pressure_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "segment_pressure_enabled", value)

    @_builtins.property
    @pulumi.getter(name="segmentPressureTimeLagVarianceFactor")
    def segment_pressure_time_lag_variance_factor(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The variance factor that is used together with the moving average to calculate the dynamic time lag threshold for activating remote segment backpressure. Defaults to 10.
        """
        return pulumi.get(self, "segment_pressure_time_lag_variance_factor")

    @segment_pressure_time_lag_variance_factor.setter
    def segment_pressure_time_lag_variance_factor(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "segment_pressure_time_lag_variance_factor", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchSearchBackpressureArgsDict(TypedDict):
        mode: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `disabled`, `enforced`, `monitor_only`. The search backpressure mode. Valid values are monitor*only, enforced, or disabled. Default is monitor*only.
        """
        node_duress: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureNodeDuressArgsDict']]
        """
        Node duress settings
        """
        search_shard_task: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchShardTaskArgsDict']]
        """
        Search shard settings
        """
        search_task: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTaskArgsDict']]
        """
        Search task settings
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchSearchBackpressureArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchSearchBackpressureArgs:
    def __init__(__self__, *,
                 mode: Optional[pulumi.Input[_builtins.str]] = None,
                 node_duress: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureNodeDuressArgs']] = None,
                 search_shard_task: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchShardTaskArgs']] = None,
                 search_task: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTaskArgs']] = None):
        """
        :param pulumi.Input[_builtins.str] mode: Enum: `disabled`, `enforced`, `monitor_only`. The search backpressure mode. Valid values are monitor*only, enforced, or disabled. Default is monitor*only.
        :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureNodeDuressArgs'] node_duress: Node duress settings
        :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchShardTaskArgs'] search_shard_task: Search shard settings
        :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTaskArgs'] search_task: Search task settings
        """
        if mode is not None:
            pulumi.set(__self__, "mode", mode)
        if node_duress is not None:
            pulumi.set(__self__, "node_duress", node_duress)
        if search_shard_task is not None:
            pulumi.set(__self__, "search_shard_task", search_shard_task)
        if search_task is not None:
            pulumi.set(__self__, "search_task", search_task)

    @_builtins.property
    @pulumi.getter
    def mode(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `disabled`, `enforced`, `monitor_only`. The search backpressure mode. Valid values are monitor*only, enforced, or disabled. Default is monitor*only.
        """
        return pulumi.get(self, "mode")

    @mode.setter
    def mode(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "mode", value)

    @_builtins.property
    @pulumi.getter(name="nodeDuress")
    def node_duress(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureNodeDuressArgs']]:
        """
        Node duress settings
        """
        return pulumi.get(self, "node_duress")

    @node_duress.setter
    def node_duress(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureNodeDuressArgs']]):
        pulumi.set(self, "node_duress", value)

    @_builtins.property
    @pulumi.getter(name="searchShardTask")
    def search_shard_task(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchShardTaskArgs']]:
        """
        Search shard settings
        """
        return pulumi.get(self, "search_shard_task")

    @search_shard_task.setter
    def search_shard_task(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchShardTaskArgs']]):
        pulumi.set(self, "search_shard_task", value)

    @_builtins.property
    @pulumi.getter(name="searchTask")
    def search_task(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTaskArgs']]:
        """
        Search task settings
        """
        return pulumi.get(self, "search_task")

    @search_task.setter
    def search_task(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTaskArgs']]):
        pulumi.set(self, "search_task", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchSearchBackpressureNodeDuressArgsDict(TypedDict):
        cpu_threshold: NotRequired[pulumi.Input[_builtins.float]]
        """
        The CPU usage threshold (as a percentage) required for a node to be considered to be under duress. Default is 0.9.
        """
        heap_threshold: NotRequired[pulumi.Input[_builtins.float]]
        """
        The heap usage threshold (as a percentage) required for a node to be considered to be under duress. Default is 0.7.
        """
        num_successive_breaches: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of successive limit breaches after which the node is considered to be under duress. Default is 3.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchSearchBackpressureNodeDuressArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchSearchBackpressureNodeDuressArgs:
    def __init__(__self__, *,
                 cpu_threshold: Optional[pulumi.Input[_builtins.float]] = None,
                 heap_threshold: Optional[pulumi.Input[_builtins.float]] = None,
                 num_successive_breaches: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.float] cpu_threshold: The CPU usage threshold (as a percentage) required for a node to be considered to be under duress. Default is 0.9.
        :param pulumi.Input[_builtins.float] heap_threshold: The heap usage threshold (as a percentage) required for a node to be considered to be under duress. Default is 0.7.
        :param pulumi.Input[_builtins.int] num_successive_breaches: The number of successive limit breaches after which the node is considered to be under duress. Default is 3.
        """
        if cpu_threshold is not None:
            pulumi.set(__self__, "cpu_threshold", cpu_threshold)
        if heap_threshold is not None:
            pulumi.set(__self__, "heap_threshold", heap_threshold)
        if num_successive_breaches is not None:
            pulumi.set(__self__, "num_successive_breaches", num_successive_breaches)

    @_builtins.property
    @pulumi.getter(name="cpuThreshold")
    def cpu_threshold(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The CPU usage threshold (as a percentage) required for a node to be considered to be under duress. Default is 0.9.
        """
        return pulumi.get(self, "cpu_threshold")

    @cpu_threshold.setter
    def cpu_threshold(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "cpu_threshold", value)

    @_builtins.property
    @pulumi.getter(name="heapThreshold")
    def heap_threshold(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The heap usage threshold (as a percentage) required for a node to be considered to be under duress. Default is 0.7.
        """
        return pulumi.get(self, "heap_threshold")

    @heap_threshold.setter
    def heap_threshold(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "heap_threshold", value)

    @_builtins.property
    @pulumi.getter(name="numSuccessiveBreaches")
    def num_successive_breaches(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of successive limit breaches after which the node is considered to be under duress. Default is 3.
        """
        return pulumi.get(self, "num_successive_breaches")

    @num_successive_breaches.setter
    def num_successive_breaches(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "num_successive_breaches", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchShardTaskArgsDict(TypedDict):
        cancellation_burst: NotRequired[pulumi.Input[_builtins.float]]
        """
        The maximum number of search tasks to cancel in a single iteration of the observer thread. Default is 10.0.
        """
        cancellation_rate: NotRequired[pulumi.Input[_builtins.float]]
        """
        The maximum number of tasks to cancel per millisecond of elapsed time. Default is 0.003.
        """
        cancellation_ratio: NotRequired[pulumi.Input[_builtins.float]]
        """
        The maximum number of tasks to cancel, as a percentage of successful task completions. Default is 0.1.
        """
        cpu_time_millis_threshold: NotRequired[pulumi.Input[_builtins.int]]
        """
        The CPU usage threshold (in milliseconds) required for a single search shard task before it is considered for cancellation. Default is 15000.
        """
        elapsed_time_millis_threshold: NotRequired[pulumi.Input[_builtins.int]]
        """
        The elapsed time threshold (in milliseconds) required for a single search shard task before it is considered for cancellation. Default is 30000.
        """
        heap_moving_average_window_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of previously completed search shard tasks to consider when calculating the rolling average of heap usage. Default is 100.
        """
        heap_percent_threshold: NotRequired[pulumi.Input[_builtins.float]]
        """
        The heap usage threshold (as a percentage) required for a single search shard task before it is considered for cancellation. Default is 0.5.
        """
        heap_variance: NotRequired[pulumi.Input[_builtins.float]]
        """
        The minimum variance required for a single search shard task’s heap usage compared to the rolling average of previously completed tasks before it is considered for cancellation. Default is 2.0.
        """
        total_heap_percent_threshold: NotRequired[pulumi.Input[_builtins.float]]
        """
        The heap usage threshold (as a percentage) required for the sum of heap usages of all search shard tasks before cancellation is applied. Default is 0.5.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchShardTaskArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchShardTaskArgs:
    def __init__(__self__, *,
                 cancellation_burst: Optional[pulumi.Input[_builtins.float]] = None,
                 cancellation_rate: Optional[pulumi.Input[_builtins.float]] = None,
                 cancellation_ratio: Optional[pulumi.Input[_builtins.float]] = None,
                 cpu_time_millis_threshold: Optional[pulumi.Input[_builtins.int]] = None,
                 elapsed_time_millis_threshold: Optional[pulumi.Input[_builtins.int]] = None,
                 heap_moving_average_window_size: Optional[pulumi.Input[_builtins.int]] = None,
                 heap_percent_threshold: Optional[pulumi.Input[_builtins.float]] = None,
                 heap_variance: Optional[pulumi.Input[_builtins.float]] = None,
                 total_heap_percent_threshold: Optional[pulumi.Input[_builtins.float]] = None):
        """
        :param pulumi.Input[_builtins.float] cancellation_burst: The maximum number of search tasks to cancel in a single iteration of the observer thread. Default is 10.0.
        :param pulumi.Input[_builtins.float] cancellation_rate: The maximum number of tasks to cancel per millisecond of elapsed time. Default is 0.003.
        :param pulumi.Input[_builtins.float] cancellation_ratio: The maximum number of tasks to cancel, as a percentage of successful task completions. Default is 0.1.
        :param pulumi.Input[_builtins.int] cpu_time_millis_threshold: The CPU usage threshold (in milliseconds) required for a single search shard task before it is considered for cancellation. Default is 15000.
        :param pulumi.Input[_builtins.int] elapsed_time_millis_threshold: The elapsed time threshold (in milliseconds) required for a single search shard task before it is considered for cancellation. Default is 30000.
        :param pulumi.Input[_builtins.int] heap_moving_average_window_size: The number of previously completed search shard tasks to consider when calculating the rolling average of heap usage. Default is 100.
        :param pulumi.Input[_builtins.float] heap_percent_threshold: The heap usage threshold (as a percentage) required for a single search shard task before it is considered for cancellation. Default is 0.5.
        :param pulumi.Input[_builtins.float] heap_variance: The minimum variance required for a single search shard task’s heap usage compared to the rolling average of previously completed tasks before it is considered for cancellation. Default is 2.0.
        :param pulumi.Input[_builtins.float] total_heap_percent_threshold: The heap usage threshold (as a percentage) required for the sum of heap usages of all search shard tasks before cancellation is applied. Default is 0.5.
        """
        if cancellation_burst is not None:
            pulumi.set(__self__, "cancellation_burst", cancellation_burst)
        if cancellation_rate is not None:
            pulumi.set(__self__, "cancellation_rate", cancellation_rate)
        if cancellation_ratio is not None:
            pulumi.set(__self__, "cancellation_ratio", cancellation_ratio)
        if cpu_time_millis_threshold is not None:
            pulumi.set(__self__, "cpu_time_millis_threshold", cpu_time_millis_threshold)
        if elapsed_time_millis_threshold is not None:
            pulumi.set(__self__, "elapsed_time_millis_threshold", elapsed_time_millis_threshold)
        if heap_moving_average_window_size is not None:
            pulumi.set(__self__, "heap_moving_average_window_size", heap_moving_average_window_size)
        if heap_percent_threshold is not None:
            pulumi.set(__self__, "heap_percent_threshold", heap_percent_threshold)
        if heap_variance is not None:
            pulumi.set(__self__, "heap_variance", heap_variance)
        if total_heap_percent_threshold is not None:
            pulumi.set(__self__, "total_heap_percent_threshold", total_heap_percent_threshold)

    @_builtins.property
    @pulumi.getter(name="cancellationBurst")
    def cancellation_burst(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The maximum number of search tasks to cancel in a single iteration of the observer thread. Default is 10.0.
        """
        return pulumi.get(self, "cancellation_burst")

    @cancellation_burst.setter
    def cancellation_burst(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "cancellation_burst", value)

    @_builtins.property
    @pulumi.getter(name="cancellationRate")
    def cancellation_rate(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The maximum number of tasks to cancel per millisecond of elapsed time. Default is 0.003.
        """
        return pulumi.get(self, "cancellation_rate")

    @cancellation_rate.setter
    def cancellation_rate(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "cancellation_rate", value)

    @_builtins.property
    @pulumi.getter(name="cancellationRatio")
    def cancellation_ratio(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The maximum number of tasks to cancel, as a percentage of successful task completions. Default is 0.1.
        """
        return pulumi.get(self, "cancellation_ratio")

    @cancellation_ratio.setter
    def cancellation_ratio(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "cancellation_ratio", value)

    @_builtins.property
    @pulumi.getter(name="cpuTimeMillisThreshold")
    def cpu_time_millis_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The CPU usage threshold (in milliseconds) required for a single search shard task before it is considered for cancellation. Default is 15000.
        """
        return pulumi.get(self, "cpu_time_millis_threshold")

    @cpu_time_millis_threshold.setter
    def cpu_time_millis_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "cpu_time_millis_threshold", value)

    @_builtins.property
    @pulumi.getter(name="elapsedTimeMillisThreshold")
    def elapsed_time_millis_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The elapsed time threshold (in milliseconds) required for a single search shard task before it is considered for cancellation. Default is 30000.
        """
        return pulumi.get(self, "elapsed_time_millis_threshold")

    @elapsed_time_millis_threshold.setter
    def elapsed_time_millis_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "elapsed_time_millis_threshold", value)

    @_builtins.property
    @pulumi.getter(name="heapMovingAverageWindowSize")
    def heap_moving_average_window_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of previously completed search shard tasks to consider when calculating the rolling average of heap usage. Default is 100.
        """
        return pulumi.get(self, "heap_moving_average_window_size")

    @heap_moving_average_window_size.setter
    def heap_moving_average_window_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "heap_moving_average_window_size", value)

    @_builtins.property
    @pulumi.getter(name="heapPercentThreshold")
    def heap_percent_threshold(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The heap usage threshold (as a percentage) required for a single search shard task before it is considered for cancellation. Default is 0.5.
        """
        return pulumi.get(self, "heap_percent_threshold")

    @heap_percent_threshold.setter
    def heap_percent_threshold(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "heap_percent_threshold", value)

    @_builtins.property
    @pulumi.getter(name="heapVariance")
    def heap_variance(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The minimum variance required for a single search shard task’s heap usage compared to the rolling average of previously completed tasks before it is considered for cancellation. Default is 2.0.
        """
        return pulumi.get(self, "heap_variance")

    @heap_variance.setter
    def heap_variance(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "heap_variance", value)

    @_builtins.property
    @pulumi.getter(name="totalHeapPercentThreshold")
    def total_heap_percent_threshold(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The heap usage threshold (as a percentage) required for the sum of heap usages of all search shard tasks before cancellation is applied. Default is 0.5.
        """
        return pulumi.get(self, "total_heap_percent_threshold")

    @total_heap_percent_threshold.setter
    def total_heap_percent_threshold(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "total_heap_percent_threshold", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTaskArgsDict(TypedDict):
        cancellation_burst: NotRequired[pulumi.Input[_builtins.float]]
        """
        The maximum number of search tasks to cancel in a single iteration of the observer thread. Default is 5.0.
        """
        cancellation_rate: NotRequired[pulumi.Input[_builtins.float]]
        """
        The maximum number of search tasks to cancel per millisecond of elapsed time. Default is 0.003.
        """
        cancellation_ratio: NotRequired[pulumi.Input[_builtins.float]]
        """
        The maximum number of search tasks to cancel, as a percentage of successful search task completions. Default is 0.1.
        """
        cpu_time_millis_threshold: NotRequired[pulumi.Input[_builtins.int]]
        """
        The CPU usage threshold (in milliseconds) required for an individual parent task before it is considered for cancellation. Default is 30000.
        """
        elapsed_time_millis_threshold: NotRequired[pulumi.Input[_builtins.int]]
        """
        The elapsed time threshold (in milliseconds) required for an individual parent task before it is considered for cancellation. Default is 45000.
        """
        heap_moving_average_window_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        The window size used to calculate the rolling average of the heap usage for the completed parent tasks. Default is 10.
        """
        heap_percent_threshold: NotRequired[pulumi.Input[_builtins.float]]
        """
        The heap usage threshold (as a percentage) required for an individual parent task before it is considered for cancellation. Default is 0.2.
        """
        heap_variance: NotRequired[pulumi.Input[_builtins.float]]
        """
        The heap usage variance required for an individual parent task before it is considered for cancellation. A task is considered for cancellation when taskHeapUsage is greater than or equal to heapUsageMovingAverage * variance. Default is 2.0.
        """
        total_heap_percent_threshold: NotRequired[pulumi.Input[_builtins.float]]
        """
        The heap usage threshold (as a percentage) required for the sum of heap usages of all search tasks before cancellation is applied. Default is 0.5.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTaskArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchSearchBackpressureSearchTaskArgs:
    def __init__(__self__, *,
                 cancellation_burst: Optional[pulumi.Input[_builtins.float]] = None,
                 cancellation_rate: Optional[pulumi.Input[_builtins.float]] = None,
                 cancellation_ratio: Optional[pulumi.Input[_builtins.float]] = None,
                 cpu_time_millis_threshold: Optional[pulumi.Input[_builtins.int]] = None,
                 elapsed_time_millis_threshold: Optional[pulumi.Input[_builtins.int]] = None,
                 heap_moving_average_window_size: Optional[pulumi.Input[_builtins.int]] = None,
                 heap_percent_threshold: Optional[pulumi.Input[_builtins.float]] = None,
                 heap_variance: Optional[pulumi.Input[_builtins.float]] = None,
                 total_heap_percent_threshold: Optional[pulumi.Input[_builtins.float]] = None):
        """
        :param pulumi.Input[_builtins.float] cancellation_burst: The maximum number of search tasks to cancel in a single iteration of the observer thread. Default is 5.0.
        :param pulumi.Input[_builtins.float] cancellation_rate: The maximum number of search tasks to cancel per millisecond of elapsed time. Default is 0.003.
        :param pulumi.Input[_builtins.float] cancellation_ratio: The maximum number of search tasks to cancel, as a percentage of successful search task completions. Default is 0.1.
        :param pulumi.Input[_builtins.int] cpu_time_millis_threshold: The CPU usage threshold (in milliseconds) required for an individual parent task before it is considered for cancellation. Default is 30000.
        :param pulumi.Input[_builtins.int] elapsed_time_millis_threshold: The elapsed time threshold (in milliseconds) required for an individual parent task before it is considered for cancellation. Default is 45000.
        :param pulumi.Input[_builtins.int] heap_moving_average_window_size: The window size used to calculate the rolling average of the heap usage for the completed parent tasks. Default is 10.
        :param pulumi.Input[_builtins.float] heap_percent_threshold: The heap usage threshold (as a percentage) required for an individual parent task before it is considered for cancellation. Default is 0.2.
        :param pulumi.Input[_builtins.float] heap_variance: The heap usage variance required for an individual parent task before it is considered for cancellation. A task is considered for cancellation when taskHeapUsage is greater than or equal to heapUsageMovingAverage * variance. Default is 2.0.
        :param pulumi.Input[_builtins.float] total_heap_percent_threshold: The heap usage threshold (as a percentage) required for the sum of heap usages of all search tasks before cancellation is applied. Default is 0.5.
        """
        if cancellation_burst is not None:
            pulumi.set(__self__, "cancellation_burst", cancellation_burst)
        if cancellation_rate is not None:
            pulumi.set(__self__, "cancellation_rate", cancellation_rate)
        if cancellation_ratio is not None:
            pulumi.set(__self__, "cancellation_ratio", cancellation_ratio)
        if cpu_time_millis_threshold is not None:
            pulumi.set(__self__, "cpu_time_millis_threshold", cpu_time_millis_threshold)
        if elapsed_time_millis_threshold is not None:
            pulumi.set(__self__, "elapsed_time_millis_threshold", elapsed_time_millis_threshold)
        if heap_moving_average_window_size is not None:
            pulumi.set(__self__, "heap_moving_average_window_size", heap_moving_average_window_size)
        if heap_percent_threshold is not None:
            pulumi.set(__self__, "heap_percent_threshold", heap_percent_threshold)
        if heap_variance is not None:
            pulumi.set(__self__, "heap_variance", heap_variance)
        if total_heap_percent_threshold is not None:
            pulumi.set(__self__, "total_heap_percent_threshold", total_heap_percent_threshold)

    @_builtins.property
    @pulumi.getter(name="cancellationBurst")
    def cancellation_burst(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The maximum number of search tasks to cancel in a single iteration of the observer thread. Default is 5.0.
        """
        return pulumi.get(self, "cancellation_burst")

    @cancellation_burst.setter
    def cancellation_burst(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "cancellation_burst", value)

    @_builtins.property
    @pulumi.getter(name="cancellationRate")
    def cancellation_rate(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The maximum number of search tasks to cancel per millisecond of elapsed time. Default is 0.003.
        """
        return pulumi.get(self, "cancellation_rate")

    @cancellation_rate.setter
    def cancellation_rate(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "cancellation_rate", value)

    @_builtins.property
    @pulumi.getter(name="cancellationRatio")
    def cancellation_ratio(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The maximum number of search tasks to cancel, as a percentage of successful search task completions. Default is 0.1.
        """
        return pulumi.get(self, "cancellation_ratio")

    @cancellation_ratio.setter
    def cancellation_ratio(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "cancellation_ratio", value)

    @_builtins.property
    @pulumi.getter(name="cpuTimeMillisThreshold")
    def cpu_time_millis_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The CPU usage threshold (in milliseconds) required for an individual parent task before it is considered for cancellation. Default is 30000.
        """
        return pulumi.get(self, "cpu_time_millis_threshold")

    @cpu_time_millis_threshold.setter
    def cpu_time_millis_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "cpu_time_millis_threshold", value)

    @_builtins.property
    @pulumi.getter(name="elapsedTimeMillisThreshold")
    def elapsed_time_millis_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The elapsed time threshold (in milliseconds) required for an individual parent task before it is considered for cancellation. Default is 45000.
        """
        return pulumi.get(self, "elapsed_time_millis_threshold")

    @elapsed_time_millis_threshold.setter
    def elapsed_time_millis_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "elapsed_time_millis_threshold", value)

    @_builtins.property
    @pulumi.getter(name="heapMovingAverageWindowSize")
    def heap_moving_average_window_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The window size used to calculate the rolling average of the heap usage for the completed parent tasks. Default is 10.
        """
        return pulumi.get(self, "heap_moving_average_window_size")

    @heap_moving_average_window_size.setter
    def heap_moving_average_window_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "heap_moving_average_window_size", value)

    @_builtins.property
    @pulumi.getter(name="heapPercentThreshold")
    def heap_percent_threshold(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The heap usage threshold (as a percentage) required for an individual parent task before it is considered for cancellation. Default is 0.2.
        """
        return pulumi.get(self, "heap_percent_threshold")

    @heap_percent_threshold.setter
    def heap_percent_threshold(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "heap_percent_threshold", value)

    @_builtins.property
    @pulumi.getter(name="heapVariance")
    def heap_variance(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The heap usage variance required for an individual parent task before it is considered for cancellation. A task is considered for cancellation when taskHeapUsage is greater than or equal to heapUsageMovingAverage * variance. Default is 2.0.
        """
        return pulumi.get(self, "heap_variance")

    @heap_variance.setter
    def heap_variance(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "heap_variance", value)

    @_builtins.property
    @pulumi.getter(name="totalHeapPercentThreshold")
    def total_heap_percent_threshold(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The heap usage threshold (as a percentage) required for the sum of heap usages of all search tasks before cancellation is applied. Default is 0.5.
        """
        return pulumi.get(self, "total_heap_percent_threshold")

    @total_heap_percent_threshold.setter
    def total_heap_percent_threshold(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "total_heap_percent_threshold", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesArgsDict(TypedDict):
        cpu: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpuArgsDict']]
        """
        Top N queries monitoring by CPU
        """
        latency: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatencyArgsDict']]
        """
        Top N queries monitoring by latency
        """
        memory: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemoryArgsDict']]
        """
        Top N queries monitoring by memory
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesArgs:
    def __init__(__self__, *,
                 cpu: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpuArgs']] = None,
                 latency: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatencyArgs']] = None,
                 memory: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemoryArgs']] = None):
        """
        :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpuArgs'] cpu: Top N queries monitoring by CPU
        :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatencyArgs'] latency: Top N queries monitoring by latency
        :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemoryArgs'] memory: Top N queries monitoring by memory
        """
        if cpu is not None:
            pulumi.set(__self__, "cpu", cpu)
        if latency is not None:
            pulumi.set(__self__, "latency", latency)
        if memory is not None:
            pulumi.set(__self__, "memory", memory)

    @_builtins.property
    @pulumi.getter
    def cpu(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpuArgs']]:
        """
        Top N queries monitoring by CPU
        """
        return pulumi.get(self, "cpu")

    @cpu.setter
    def cpu(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpuArgs']]):
        pulumi.set(self, "cpu", value)

    @_builtins.property
    @pulumi.getter
    def latency(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatencyArgs']]:
        """
        Top N queries monitoring by latency
        """
        return pulumi.get(self, "latency")

    @latency.setter
    def latency(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatencyArgs']]):
        pulumi.set(self, "latency", value)

    @_builtins.property
    @pulumi.getter
    def memory(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemoryArgs']]:
        """
        Top N queries monitoring by memory
        """
        return pulumi.get(self, "memory")

    @memory.setter
    def memory(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemoryArgs']]):
        pulumi.set(self, "memory", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpuArgsDict(TypedDict):
        enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable or disable top N query monitoring by the metric. Default: `false`.
        """
        top_n_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specify the value of N for the top N queries by the metric.
        """
        window_size: NotRequired[pulumi.Input[_builtins.str]]
        """
        The window size of the top N queries by the metric.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpuArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesCpuArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 top_n_size: Optional[pulumi.Input[_builtins.int]] = None,
                 window_size: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.bool] enabled: Enable or disable top N query monitoring by the metric. Default: `false`.
        :param pulumi.Input[_builtins.int] top_n_size: Specify the value of N for the top N queries by the metric.
        :param pulumi.Input[_builtins.str] window_size: The window size of the top N queries by the metric.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if top_n_size is not None:
            pulumi.set(__self__, "top_n_size", top_n_size)
        if window_size is not None:
            pulumi.set(__self__, "window_size", window_size)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable or disable top N query monitoring by the metric. Default: `false`.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "enabled", value)

    @_builtins.property
    @pulumi.getter(name="topNSize")
    def top_n_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specify the value of N for the top N queries by the metric.
        """
        return pulumi.get(self, "top_n_size")

    @top_n_size.setter
    def top_n_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "top_n_size", value)

    @_builtins.property
    @pulumi.getter(name="windowSize")
    def window_size(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The window size of the top N queries by the metric.
        """
        return pulumi.get(self, "window_size")

    @window_size.setter
    def window_size(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "window_size", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatencyArgsDict(TypedDict):
        enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable or disable top N query monitoring by the metric. Default: `false`.
        """
        top_n_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specify the value of N for the top N queries by the metric.
        """
        window_size: NotRequired[pulumi.Input[_builtins.str]]
        """
        The window size of the top N queries by the metric.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatencyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesLatencyArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 top_n_size: Optional[pulumi.Input[_builtins.int]] = None,
                 window_size: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.bool] enabled: Enable or disable top N query monitoring by the metric. Default: `false`.
        :param pulumi.Input[_builtins.int] top_n_size: Specify the value of N for the top N queries by the metric.
        :param pulumi.Input[_builtins.str] window_size: The window size of the top N queries by the metric.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if top_n_size is not None:
            pulumi.set(__self__, "top_n_size", top_n_size)
        if window_size is not None:
            pulumi.set(__self__, "window_size", window_size)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable or disable top N query monitoring by the metric. Default: `false`.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "enabled", value)

    @_builtins.property
    @pulumi.getter(name="topNSize")
    def top_n_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specify the value of N for the top N queries by the metric.
        """
        return pulumi.get(self, "top_n_size")

    @top_n_size.setter
    def top_n_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "top_n_size", value)

    @_builtins.property
    @pulumi.getter(name="windowSize")
    def window_size(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The window size of the top N queries by the metric.
        """
        return pulumi.get(self, "window_size")

    @window_size.setter
    def window_size(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "window_size", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemoryArgsDict(TypedDict):
        enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable or disable top N query monitoring by the metric. Default: `false`.
        """
        top_n_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specify the value of N for the top N queries by the metric.
        """
        window_size: NotRequired[pulumi.Input[_builtins.str]]
        """
        The window size of the top N queries by the metric.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemoryArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchSearchInsightsTopQueriesMemoryArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 top_n_size: Optional[pulumi.Input[_builtins.int]] = None,
                 window_size: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.bool] enabled: Enable or disable top N query monitoring by the metric. Default: `false`.
        :param pulumi.Input[_builtins.int] top_n_size: Specify the value of N for the top N queries by the metric.
        :param pulumi.Input[_builtins.str] window_size: The window size of the top N queries by the metric.
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if top_n_size is not None:
            pulumi.set(__self__, "top_n_size", top_n_size)
        if window_size is not None:
            pulumi.set(__self__, "window_size", window_size)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable or disable top N query monitoring by the metric. Default: `false`.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "enabled", value)

    @_builtins.property
    @pulumi.getter(name="topNSize")
    def top_n_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specify the value of N for the top N queries by the metric.
        """
        return pulumi.get(self, "top_n_size")

    @top_n_size.setter
    def top_n_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "top_n_size", value)

    @_builtins.property
    @pulumi.getter(name="windowSize")
    def window_size(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The window size of the top N queries by the metric.
        """
        return pulumi.get(self, "window_size")

    @window_size.setter
    def window_size(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "window_size", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchSegrepArgsDict(TypedDict):
        pressure_checkpoint_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of indexing checkpoints that a replica shard can fall behind when copying from primary. Once `segrep.pressure.checkpoint.limit` is breached along with `segrep.pressure.time.limit`, the segment replication backpressure mechanism is initiated. Default is 4 checkpoints. Default: `4`.
        """
        pressure_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enables the segment replication backpressure mechanism. Default is false. Default: `false`.
        """
        pressure_replica_stale_limit: NotRequired[pulumi.Input[_builtins.float]]
        """
        The maximum number of stale replica shards that can exist in a replication group. Once `segrep.pressure.replica.stale.limit` is breached, the segment replication backpressure mechanism is initiated. Default is .5, which is 50% of a replication group. Default: `0.5`.
        """
        pressure_time_limit: NotRequired[pulumi.Input[_builtins.str]]
        """
        The maximum amount of time that a replica shard can take to copy from the primary shard. Once segrep.pressure.time.limit is breached along with segrep.pressure.checkpoint.limit, the segment replication backpressure mechanism is initiated. Default is 5 minutes. Default: `5m`.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchSegrepArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchSegrepArgs:
    def __init__(__self__, *,
                 pressure_checkpoint_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 pressure_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 pressure_replica_stale_limit: Optional[pulumi.Input[_builtins.float]] = None,
                 pressure_time_limit: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.int] pressure_checkpoint_limit: The maximum number of indexing checkpoints that a replica shard can fall behind when copying from primary. Once `segrep.pressure.checkpoint.limit` is breached along with `segrep.pressure.time.limit`, the segment replication backpressure mechanism is initiated. Default is 4 checkpoints. Default: `4`.
        :param pulumi.Input[_builtins.bool] pressure_enabled: Enables the segment replication backpressure mechanism. Default is false. Default: `false`.
        :param pulumi.Input[_builtins.float] pressure_replica_stale_limit: The maximum number of stale replica shards that can exist in a replication group. Once `segrep.pressure.replica.stale.limit` is breached, the segment replication backpressure mechanism is initiated. Default is .5, which is 50% of a replication group. Default: `0.5`.
        :param pulumi.Input[_builtins.str] pressure_time_limit: The maximum amount of time that a replica shard can take to copy from the primary shard. Once segrep.pressure.time.limit is breached along with segrep.pressure.checkpoint.limit, the segment replication backpressure mechanism is initiated. Default is 5 minutes. Default: `5m`.
        """
        if pressure_checkpoint_limit is not None:
            pulumi.set(__self__, "pressure_checkpoint_limit", pressure_checkpoint_limit)
        if pressure_enabled is not None:
            pulumi.set(__self__, "pressure_enabled", pressure_enabled)
        if pressure_replica_stale_limit is not None:
            pulumi.set(__self__, "pressure_replica_stale_limit", pressure_replica_stale_limit)
        if pressure_time_limit is not None:
            pulumi.set(__self__, "pressure_time_limit", pressure_time_limit)

    @_builtins.property
    @pulumi.getter(name="pressureCheckpointLimit")
    def pressure_checkpoint_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of indexing checkpoints that a replica shard can fall behind when copying from primary. Once `segrep.pressure.checkpoint.limit` is breached along with `segrep.pressure.time.limit`, the segment replication backpressure mechanism is initiated. Default is 4 checkpoints. Default: `4`.
        """
        return pulumi.get(self, "pressure_checkpoint_limit")

    @pressure_checkpoint_limit.setter
    def pressure_checkpoint_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "pressure_checkpoint_limit", value)

    @_builtins.property
    @pulumi.getter(name="pressureEnabled")
    def pressure_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enables the segment replication backpressure mechanism. Default is false. Default: `false`.
        """
        return pulumi.get(self, "pressure_enabled")

    @pressure_enabled.setter
    def pressure_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "pressure_enabled", value)

    @_builtins.property
    @pulumi.getter(name="pressureReplicaStaleLimit")
    def pressure_replica_stale_limit(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The maximum number of stale replica shards that can exist in a replication group. Once `segrep.pressure.replica.stale.limit` is breached, the segment replication backpressure mechanism is initiated. Default is .5, which is 50% of a replication group. Default: `0.5`.
        """
        return pulumi.get(self, "pressure_replica_stale_limit")

    @pressure_replica_stale_limit.setter
    def pressure_replica_stale_limit(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "pressure_replica_stale_limit", value)

    @_builtins.property
    @pulumi.getter(name="pressureTimeLimit")
    def pressure_time_limit(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The maximum amount of time that a replica shard can take to copy from the primary shard. Once segrep.pressure.time.limit is breached along with segrep.pressure.checkpoint.limit, the segment replication backpressure mechanism is initiated. Default is 5 minutes. Default: `5m`.
        """
        return pulumi.get(self, "pressure_time_limit")

    @pressure_time_limit.setter
    def pressure_time_limit(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "pressure_time_limit", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureArgsDict(TypedDict):
        enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable or disable shard indexing backpressure. Default is false.
        """
        enforced: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Run shard indexing backpressure in shadow mode or enforced mode. In shadow mode (value set as false), shard indexing backpressure tracks all granular-level metrics, but it doesn’t actually reject any indexing requests. In enforced mode (value set as true), shard indexing backpressure rejects any requests to the cluster that might cause a dip in its performance. Default is false.
        """
        operating_factor: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureOperatingFactorArgsDict']]
        """
        Operating factor
        """
        primary_parameter: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterArgsDict']]
        """
        Primary parameter
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 enforced: Optional[pulumi.Input[_builtins.bool]] = None,
                 operating_factor: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureOperatingFactorArgs']] = None,
                 primary_parameter: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterArgs']] = None):
        """
        :param pulumi.Input[_builtins.bool] enabled: Enable or disable shard indexing backpressure. Default is false.
        :param pulumi.Input[_builtins.bool] enforced: Run shard indexing backpressure in shadow mode or enforced mode. In shadow mode (value set as false), shard indexing backpressure tracks all granular-level metrics, but it doesn’t actually reject any indexing requests. In enforced mode (value set as true), shard indexing backpressure rejects any requests to the cluster that might cause a dip in its performance. Default is false.
        :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureOperatingFactorArgs'] operating_factor: Operating factor
        :param pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterArgs'] primary_parameter: Primary parameter
        """
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if enforced is not None:
            pulumi.set(__self__, "enforced", enforced)
        if operating_factor is not None:
            pulumi.set(__self__, "operating_factor", operating_factor)
        if primary_parameter is not None:
            pulumi.set(__self__, "primary_parameter", primary_parameter)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable or disable shard indexing backpressure. Default is false.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "enabled", value)

    @_builtins.property
    @pulumi.getter
    def enforced(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Run shard indexing backpressure in shadow mode or enforced mode. In shadow mode (value set as false), shard indexing backpressure tracks all granular-level metrics, but it doesn’t actually reject any indexing requests. In enforced mode (value set as true), shard indexing backpressure rejects any requests to the cluster that might cause a dip in its performance. Default is false.
        """
        return pulumi.get(self, "enforced")

    @enforced.setter
    def enforced(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "enforced", value)

    @_builtins.property
    @pulumi.getter(name="operatingFactor")
    def operating_factor(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureOperatingFactorArgs']]:
        """
        Operating factor
        """
        return pulumi.get(self, "operating_factor")

    @operating_factor.setter
    def operating_factor(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureOperatingFactorArgs']]):
        pulumi.set(self, "operating_factor", value)

    @_builtins.property
    @pulumi.getter(name="primaryParameter")
    def primary_parameter(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterArgs']]:
        """
        Primary parameter
        """
        return pulumi.get(self, "primary_parameter")

    @primary_parameter.setter
    def primary_parameter(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterArgs']]):
        pulumi.set(self, "primary_parameter", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureOperatingFactorArgsDict(TypedDict):
        lower: NotRequired[pulumi.Input[_builtins.float]]
        """
        Specify the lower occupancy limit of the allocated quota of memory for the shard. If the total memory usage of a shard is below this limit, shard indexing backpressure decreases the current allocated memory for that shard. Default is 0.75.
        """
        optimal: NotRequired[pulumi.Input[_builtins.float]]
        """
        Specify the optimal occupancy of the allocated quota of memory for the shard. If the total memory usage of a shard is at this level, shard indexing backpressure doesn’t change the current allocated memory for that shard. Default is 0.85.
        """
        upper: NotRequired[pulumi.Input[_builtins.float]]
        """
        Specify the upper occupancy limit of the allocated quota of memory for the shard. If the total memory usage of a shard is above this limit, shard indexing backpressure increases the current allocated memory for that shard. Default is 0.95.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureOperatingFactorArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchShardIndexingPressureOperatingFactorArgs:
    def __init__(__self__, *,
                 lower: Optional[pulumi.Input[_builtins.float]] = None,
                 optimal: Optional[pulumi.Input[_builtins.float]] = None,
                 upper: Optional[pulumi.Input[_builtins.float]] = None):
        """
        :param pulumi.Input[_builtins.float] lower: Specify the lower occupancy limit of the allocated quota of memory for the shard. If the total memory usage of a shard is below this limit, shard indexing backpressure decreases the current allocated memory for that shard. Default is 0.75.
        :param pulumi.Input[_builtins.float] optimal: Specify the optimal occupancy of the allocated quota of memory for the shard. If the total memory usage of a shard is at this level, shard indexing backpressure doesn’t change the current allocated memory for that shard. Default is 0.85.
        :param pulumi.Input[_builtins.float] upper: Specify the upper occupancy limit of the allocated quota of memory for the shard. If the total memory usage of a shard is above this limit, shard indexing backpressure increases the current allocated memory for that shard. Default is 0.95.
        """
        if lower is not None:
            pulumi.set(__self__, "lower", lower)
        if optimal is not None:
            pulumi.set(__self__, "optimal", optimal)
        if upper is not None:
            pulumi.set(__self__, "upper", upper)

    @_builtins.property
    @pulumi.getter
    def lower(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        Specify the lower occupancy limit of the allocated quota of memory for the shard. If the total memory usage of a shard is below this limit, shard indexing backpressure decreases the current allocated memory for that shard. Default is 0.75.
        """
        return pulumi.get(self, "lower")

    @lower.setter
    def lower(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "lower", value)

    @_builtins.property
    @pulumi.getter
    def optimal(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        Specify the optimal occupancy of the allocated quota of memory for the shard. If the total memory usage of a shard is at this level, shard indexing backpressure doesn’t change the current allocated memory for that shard. Default is 0.85.
        """
        return pulumi.get(self, "optimal")

    @optimal.setter
    def optimal(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "optimal", value)

    @_builtins.property
    @pulumi.getter
    def upper(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        Specify the upper occupancy limit of the allocated quota of memory for the shard. If the total memory usage of a shard is above this limit, shard indexing backpressure increases the current allocated memory for that shard. Default is 0.95.
        """
        return pulumi.get(self, "upper")

    @upper.setter
    def upper(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "upper", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterArgsDict(TypedDict):
        node: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterNodeArgsDict']]
        shard: NotRequired[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterShardArgsDict']]
elif False:
    OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterArgs:
    def __init__(__self__, *,
                 node: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterNodeArgs']] = None,
                 shard: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterShardArgs']] = None):
        if node is not None:
            pulumi.set(__self__, "node", node)
        if shard is not None:
            pulumi.set(__self__, "shard", shard)

    @_builtins.property
    @pulumi.getter
    def node(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterNodeArgs']]:
        return pulumi.get(self, "node")

    @node.setter
    def node(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterNodeArgs']]):
        pulumi.set(self, "node", value)

    @_builtins.property
    @pulumi.getter
    def shard(self) -> Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterShardArgs']]:
        return pulumi.get(self, "shard")

    @shard.setter
    def shard(self, value: Optional[pulumi.Input['OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterShardArgs']]):
        pulumi.set(self, "shard", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterNodeArgsDict(TypedDict):
        soft_limit: NotRequired[pulumi.Input[_builtins.float]]
        """
        Define the percentage of the node-level memory threshold that acts as a soft indicator for strain on a node. Default is 0.7.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterNodeArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterNodeArgs:
    def __init__(__self__, *,
                 soft_limit: Optional[pulumi.Input[_builtins.float]] = None):
        """
        :param pulumi.Input[_builtins.float] soft_limit: Define the percentage of the node-level memory threshold that acts as a soft indicator for strain on a node. Default is 0.7.
        """
        if soft_limit is not None:
            pulumi.set(__self__, "soft_limit", soft_limit)

    @_builtins.property
    @pulumi.getter(name="softLimit")
    def soft_limit(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        Define the percentage of the node-level memory threshold that acts as a soft indicator for strain on a node. Default is 0.7.
        """
        return pulumi.get(self, "soft_limit")

    @soft_limit.setter
    def soft_limit(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "soft_limit", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterShardArgsDict(TypedDict):
        min_limit: NotRequired[pulumi.Input[_builtins.float]]
        """
        Specify the minimum assigned quota for a new shard in any role (coordinator, primary, or replica). Shard indexing backpressure increases or decreases this allocated quota based on the inflow of traffic for the shard. Default is 0.001.
        """
elif False:
    OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterShardArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigOpensearchShardIndexingPressurePrimaryParameterShardArgs:
    def __init__(__self__, *,
                 min_limit: Optional[pulumi.Input[_builtins.float]] = None):
        """
        :param pulumi.Input[_builtins.float] min_limit: Specify the minimum assigned quota for a new shard in any role (coordinator, primary, or replica). Shard indexing backpressure increases or decreases this allocated quota based on the inflow of traffic for the shard. Default is 0.001.
        """
        if min_limit is not None:
            pulumi.set(__self__, "min_limit", min_limit)

    @_builtins.property
    @pulumi.getter(name="minLimit")
    def min_limit(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        Specify the minimum assigned quota for a new shard in any role (coordinator, primary, or replica). Shard indexing backpressure increases or decreases this allocated quota based on the inflow of traffic for the shard. Default is 0.001.
        """
        return pulumi.get(self, "min_limit")

    @min_limit.setter
    def min_limit(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "min_limit", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigPrivateAccessArgsDict(TypedDict):
        opensearch: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to opensearch with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        opensearch_dashboards: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to opensearch_dashboards with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
elif False:
    OpenSearchOpensearchUserConfigPrivateAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 opensearch: Optional[pulumi.Input[_builtins.bool]] = None,
                 opensearch_dashboards: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] opensearch: Allow clients to connect to opensearch with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] opensearch_dashboards: Allow clients to connect to opensearch_dashboards with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        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)

    @_builtins.property
    @pulumi.getter
    def opensearch(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to opensearch with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "opensearch")

    @opensearch.setter
    def opensearch(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "opensearch", value)

    @_builtins.property
    @pulumi.getter(name="opensearchDashboards")
    def opensearch_dashboards(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to opensearch_dashboards with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "opensearch_dashboards")

    @opensearch_dashboards.setter
    def opensearch_dashboards(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "opensearch_dashboards", value)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "prometheus", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigPrivatelinkAccessArgsDict(TypedDict):
        opensearch: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable opensearch.
        """
        opensearch_dashboards: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable opensearch_dashboards.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable prometheus.
        """
elif False:
    OpenSearchOpensearchUserConfigPrivatelinkAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 opensearch: Optional[pulumi.Input[_builtins.bool]] = None,
                 opensearch_dashboards: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] opensearch: Enable opensearch.
        :param pulumi.Input[_builtins.bool] opensearch_dashboards: Enable opensearch_dashboards.
        :param pulumi.Input[_builtins.bool] prometheus: Enable prometheus.
        """
        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)

    @_builtins.property
    @pulumi.getter
    def opensearch(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable opensearch.
        """
        return pulumi.get(self, "opensearch")

    @opensearch.setter
    def opensearch(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "opensearch", value)

    @_builtins.property
    @pulumi.getter(name="opensearchDashboards")
    def opensearch_dashboards(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable opensearch_dashboards.
        """
        return pulumi.get(self, "opensearch_dashboards")

    @opensearch_dashboards.setter
    def opensearch_dashboards(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "opensearch_dashboards", value)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable prometheus.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "prometheus", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigPublicAccessArgsDict(TypedDict):
        opensearch: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to opensearch from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        opensearch_dashboards: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to opensearch_dashboards from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
elif False:
    OpenSearchOpensearchUserConfigPublicAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 opensearch: Optional[pulumi.Input[_builtins.bool]] = None,
                 opensearch_dashboards: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] opensearch: Allow clients to connect to opensearch from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] opensearch_dashboards: Allow clients to connect to opensearch_dashboards from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        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)

    @_builtins.property
    @pulumi.getter
    def opensearch(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to opensearch from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "opensearch")

    @opensearch.setter
    def opensearch(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "opensearch", value)

    @_builtins.property
    @pulumi.getter(name="opensearchDashboards")
    def opensearch_dashboards(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to opensearch_dashboards from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "opensearch_dashboards")

    @opensearch_dashboards.setter
    def opensearch_dashboards(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "opensearch_dashboards", value)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "prometheus", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigS3MigrationArgsDict(TypedDict):
        access_key: pulumi.Input[_builtins.str]
        """
        AWS Access key.
        """
        base_path: pulumi.Input[_builtins.str]
        """
        The path to the repository data within its container. The value of this setting should not start or end with a /.
        """
        bucket: pulumi.Input[_builtins.str]
        """
        S3 bucket name.
        """
        indices: pulumi.Input[_builtins.str]
        """
        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
        """
        region: pulumi.Input[_builtins.str]
        """
        S3 region.
        """
        secret_key: pulumi.Input[_builtins.str]
        """
        AWS secret key.
        """
        snapshot_name: pulumi.Input[_builtins.str]
        """
        The snapshot name to restore from.
        """
        chunk_size: NotRequired[pulumi.Input[_builtins.str]]
        """
        Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
        """
        compress: NotRequired[pulumi.Input[_builtins.bool]]
        """
        When set to true metadata files are stored in compressed format.
        """
        endpoint: NotRequired[pulumi.Input[_builtins.str]]
        """
        The S3 service endpoint to connect to. If you are using an S3-compatible service then you should set this to the service’s endpoint.
        """
        include_aliases: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether to restore aliases alongside their associated indexes. Default is true.
        """
        readonly: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the repository is read-only. Default: `true`.
        """
        restore_global_state: NotRequired[pulumi.Input[_builtins.bool]]
        """
        If true, restore the cluster state. Defaults to false.
        """
        server_side_encryption: NotRequired[pulumi.Input[_builtins.bool]]
        """
        When set to true files are encrypted on server side.
        """
elif False:
    OpenSearchOpensearchUserConfigS3MigrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigS3MigrationArgs:
    def __init__(__self__, *,
                 access_key: pulumi.Input[_builtins.str],
                 base_path: pulumi.Input[_builtins.str],
                 bucket: pulumi.Input[_builtins.str],
                 indices: pulumi.Input[_builtins.str],
                 region: pulumi.Input[_builtins.str],
                 secret_key: pulumi.Input[_builtins.str],
                 snapshot_name: pulumi.Input[_builtins.str],
                 chunk_size: Optional[pulumi.Input[_builtins.str]] = None,
                 compress: Optional[pulumi.Input[_builtins.bool]] = None,
                 endpoint: Optional[pulumi.Input[_builtins.str]] = None,
                 include_aliases: Optional[pulumi.Input[_builtins.bool]] = None,
                 readonly: Optional[pulumi.Input[_builtins.bool]] = None,
                 restore_global_state: Optional[pulumi.Input[_builtins.bool]] = None,
                 server_side_encryption: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] access_key: AWS Access key.
        :param pulumi.Input[_builtins.str] base_path: The path to the repository data within its container. The value of this setting should not start or end with a /.
        :param pulumi.Input[_builtins.str] bucket: S3 bucket name.
        :param pulumi.Input[_builtins.str] indices: A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
        :param pulumi.Input[_builtins.str] region: S3 region.
        :param pulumi.Input[_builtins.str] secret_key: AWS secret key.
        :param pulumi.Input[_builtins.str] snapshot_name: The snapshot name to restore from.
        :param pulumi.Input[_builtins.str] chunk_size: Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
        :param pulumi.Input[_builtins.bool] compress: When set to true metadata files are stored in compressed format.
        :param pulumi.Input[_builtins.str] endpoint: The S3 service endpoint to connect to. If you are using an S3-compatible service then you should set this to the service’s endpoint.
        :param pulumi.Input[_builtins.bool] include_aliases: Whether to restore aliases alongside their associated indexes. Default is true.
        :param pulumi.Input[_builtins.bool] readonly: Whether the repository is read-only. Default: `true`.
        :param pulumi.Input[_builtins.bool] restore_global_state: If true, restore the cluster state. Defaults to false.
        :param pulumi.Input[_builtins.bool] server_side_encryption: When set to true files are encrypted on server side.
        """
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "base_path", base_path)
        pulumi.set(__self__, "bucket", bucket)
        pulumi.set(__self__, "indices", indices)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "secret_key", secret_key)
        pulumi.set(__self__, "snapshot_name", snapshot_name)
        if chunk_size is not None:
            pulumi.set(__self__, "chunk_size", chunk_size)
        if compress is not None:
            pulumi.set(__self__, "compress", compress)
        if endpoint is not None:
            pulumi.set(__self__, "endpoint", endpoint)
        if include_aliases is not None:
            pulumi.set(__self__, "include_aliases", include_aliases)
        if readonly is not None:
            pulumi.set(__self__, "readonly", readonly)
        if restore_global_state is not None:
            pulumi.set(__self__, "restore_global_state", restore_global_state)
        if server_side_encryption is not None:
            pulumi.set(__self__, "server_side_encryption", server_side_encryption)

    @_builtins.property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> pulumi.Input[_builtins.str]:
        """
        AWS Access key.
        """
        return pulumi.get(self, "access_key")

    @access_key.setter
    def access_key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "access_key", value)

    @_builtins.property
    @pulumi.getter(name="basePath")
    def base_path(self) -> pulumi.Input[_builtins.str]:
        """
        The path to the repository data within its container. The value of this setting should not start or end with a /.
        """
        return pulumi.get(self, "base_path")

    @base_path.setter
    def base_path(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "base_path", value)

    @_builtins.property
    @pulumi.getter
    def bucket(self) -> pulumi.Input[_builtins.str]:
        """
        S3 bucket name.
        """
        return pulumi.get(self, "bucket")

    @bucket.setter
    def bucket(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "bucket", value)

    @_builtins.property
    @pulumi.getter
    def indices(self) -> pulumi.Input[_builtins.str]:
        """
        A comma-delimited list of indices to restore from the snapshot. Multi-index syntax is supported. Example: `metrics*,logs*,data-20240823`.
        """
        return pulumi.get(self, "indices")

    @indices.setter
    def indices(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "indices", value)

    @_builtins.property
    @pulumi.getter
    def region(self) -> pulumi.Input[_builtins.str]:
        """
        S3 region.
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "region", value)

    @_builtins.property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> pulumi.Input[_builtins.str]:
        """
        AWS secret key.
        """
        return pulumi.get(self, "secret_key")

    @secret_key.setter
    def secret_key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "secret_key", value)

    @_builtins.property
    @pulumi.getter(name="snapshotName")
    def snapshot_name(self) -> pulumi.Input[_builtins.str]:
        """
        The snapshot name to restore from.
        """
        return pulumi.get(self, "snapshot_name")

    @snapshot_name.setter
    def snapshot_name(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "snapshot_name", value)

    @_builtins.property
    @pulumi.getter(name="chunkSize")
    def chunk_size(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Big files can be broken down into chunks during snapshotting if needed. Should be the same as for the 3rd party repository.
        """
        return pulumi.get(self, "chunk_size")

    @chunk_size.setter
    def chunk_size(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "chunk_size", value)

    @_builtins.property
    @pulumi.getter
    def compress(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        When set to true metadata files are stored in compressed format.
        """
        return pulumi.get(self, "compress")

    @compress.setter
    def compress(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "compress", value)

    @_builtins.property
    @pulumi.getter
    def endpoint(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The S3 service endpoint to connect to. If you are using an S3-compatible service then you should set this to the service’s endpoint.
        """
        return pulumi.get(self, "endpoint")

    @endpoint.setter
    def endpoint(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "endpoint", value)

    @_builtins.property
    @pulumi.getter(name="includeAliases")
    def include_aliases(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether to restore aliases alongside their associated indexes. Default is true.
        """
        return pulumi.get(self, "include_aliases")

    @include_aliases.setter
    def include_aliases(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "include_aliases", value)

    @_builtins.property
    @pulumi.getter
    def readonly(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the repository is read-only. Default: `true`.
        """
        return pulumi.get(self, "readonly")

    @readonly.setter
    def readonly(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "readonly", value)

    @_builtins.property
    @pulumi.getter(name="restoreGlobalState")
    def restore_global_state(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        If true, restore the cluster state. Defaults to false.
        """
        return pulumi.get(self, "restore_global_state")

    @restore_global_state.setter
    def restore_global_state(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "restore_global_state", value)

    @_builtins.property
    @pulumi.getter(name="serverSideEncryption")
    def server_side_encryption(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        When set to true files are encrypted on server side.
        """
        return pulumi.get(self, "server_side_encryption")

    @server_side_encryption.setter
    def server_side_encryption(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "server_side_encryption", value)


if not MYPY:
    class OpenSearchOpensearchUserConfigSamlArgsDict(TypedDict):
        enabled: pulumi.Input[_builtins.bool]
        """
        Enables or disables SAML-based authentication for OpenSearch. When enabled, users can authenticate using SAML with an Identity Provider. Default: `true`.
        """
        idp_entity_id: pulumi.Input[_builtins.str]
        """
        The unique identifier for the Identity Provider (IdP) entity that is used for SAML authentication. This value is typically provided by the IdP. Example: `test-idp-entity-id`.
        """
        idp_metadata_url: pulumi.Input[_builtins.str]
        """
        The URL of the SAML metadata for the Identity Provider (IdP). This is used to configure SAML-based authentication with the IdP. Example: `https://test-account.okta.com/app/exk491jujcVc83LEX697/sso/saml/metadata`.
        """
        sp_entity_id: pulumi.Input[_builtins.str]
        """
        The unique identifier for the Service Provider (SP) entity that is used for SAML authentication. This value is typically provided by the SP. Example: `test-sp-entity-id`.
        """
        idp_pemtrustedcas_content: NotRequired[pulumi.Input[_builtins.str]]
        """
        This parameter specifies the PEM-encoded root certificate authority (CA) content for the SAML identity provider (IdP) server verification. The root CA content is used to verify the SSL/TLS certificate presented by the server. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        roles_key: NotRequired[pulumi.Input[_builtins.str]]
        """
        Optional. Specifies the attribute in the SAML response where role information is stored, if available. Role attributes are not required for SAML authentication, but can be included in SAML assertions by most Identity Providers (IdPs) to determine user access levels or permissions. Example: `RoleName`.
        """
        subject_key: NotRequired[pulumi.Input[_builtins.str]]
        """
        Optional. Specifies the attribute in the SAML response where the subject identifier is stored. If not configured, the NameID attribute is used by default. Example: `NameID`.
        """
elif False:
    OpenSearchOpensearchUserConfigSamlArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchOpensearchUserConfigSamlArgs:
    def __init__(__self__, *,
                 enabled: pulumi.Input[_builtins.bool],
                 idp_entity_id: pulumi.Input[_builtins.str],
                 idp_metadata_url: pulumi.Input[_builtins.str],
                 sp_entity_id: pulumi.Input[_builtins.str],
                 idp_pemtrustedcas_content: Optional[pulumi.Input[_builtins.str]] = None,
                 roles_key: Optional[pulumi.Input[_builtins.str]] = None,
                 subject_key: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.bool] enabled: Enables or disables SAML-based authentication for OpenSearch. When enabled, users can authenticate using SAML with an Identity Provider. Default: `true`.
        :param pulumi.Input[_builtins.str] idp_entity_id: The unique identifier for the Identity Provider (IdP) entity that is used for SAML authentication. This value is typically provided by the IdP. Example: `test-idp-entity-id`.
        :param pulumi.Input[_builtins.str] idp_metadata_url: The URL of the SAML metadata for the Identity Provider (IdP). This is used to configure SAML-based authentication with the IdP. Example: `https://test-account.okta.com/app/exk491jujcVc83LEX697/sso/saml/metadata`.
        :param pulumi.Input[_builtins.str] sp_entity_id: The unique identifier for the Service Provider (SP) entity that is used for SAML authentication. This value is typically provided by the SP. Example: `test-sp-entity-id`.
        :param pulumi.Input[_builtins.str] idp_pemtrustedcas_content: This parameter specifies the PEM-encoded root certificate authority (CA) content for the SAML identity provider (IdP) server verification. The root CA content is used to verify the SSL/TLS certificate presented by the server. Example: `-----BEGIN CERTIFICATE-----
               ...
               -----END CERTIFICATE-----
               `.
        :param pulumi.Input[_builtins.str] roles_key: Optional. Specifies the attribute in the SAML response where role information is stored, if available. Role attributes are not required for SAML authentication, but can be included in SAML assertions by most Identity Providers (IdPs) to determine user access levels or permissions. Example: `RoleName`.
        :param pulumi.Input[_builtins.str] subject_key: Optional. Specifies the attribute in the SAML response where the subject identifier is stored. If not configured, the NameID attribute is used by default. Example: `NameID`.
        """
        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)

    @_builtins.property
    @pulumi.getter
    def enabled(self) -> pulumi.Input[_builtins.bool]:
        """
        Enables or disables SAML-based authentication for OpenSearch. When enabled, users can authenticate using SAML with an Identity Provider. Default: `true`.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: pulumi.Input[_builtins.bool]):
        pulumi.set(self, "enabled", value)

    @_builtins.property
    @pulumi.getter(name="idpEntityId")
    def idp_entity_id(self) -> pulumi.Input[_builtins.str]:
        """
        The unique identifier for the Identity Provider (IdP) entity that is used for SAML authentication. This value is typically provided by the IdP. Example: `test-idp-entity-id`.
        """
        return pulumi.get(self, "idp_entity_id")

    @idp_entity_id.setter
    def idp_entity_id(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "idp_entity_id", value)

    @_builtins.property
    @pulumi.getter(name="idpMetadataUrl")
    def idp_metadata_url(self) -> pulumi.Input[_builtins.str]:
        """
        The URL of the SAML metadata for the Identity Provider (IdP). This is used to configure SAML-based authentication with the IdP. Example: `https://test-account.okta.com/app/exk491jujcVc83LEX697/sso/saml/metadata`.
        """
        return pulumi.get(self, "idp_metadata_url")

    @idp_metadata_url.setter
    def idp_metadata_url(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "idp_metadata_url", value)

    @_builtins.property
    @pulumi.getter(name="spEntityId")
    def sp_entity_id(self) -> pulumi.Input[_builtins.str]:
        """
        The unique identifier for the Service Provider (SP) entity that is used for SAML authentication. This value is typically provided by the SP. Example: `test-sp-entity-id`.
        """
        return pulumi.get(self, "sp_entity_id")

    @sp_entity_id.setter
    def sp_entity_id(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "sp_entity_id", value)

    @_builtins.property
    @pulumi.getter(name="idpPemtrustedcasContent")
    def idp_pemtrustedcas_content(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        This parameter specifies the PEM-encoded root certificate authority (CA) content for the SAML identity provider (IdP) server verification. The root CA content is used to verify the SSL/TLS certificate presented by the server. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        return pulumi.get(self, "idp_pemtrustedcas_content")

    @idp_pemtrustedcas_content.setter
    def idp_pemtrustedcas_content(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "idp_pemtrustedcas_content", value)

    @_builtins.property
    @pulumi.getter(name="rolesKey")
    def roles_key(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Optional. Specifies the attribute in the SAML response where role information is stored, if available. Role attributes are not required for SAML authentication, but can be included in SAML assertions by most Identity Providers (IdPs) to determine user access levels or permissions. Example: `RoleName`.
        """
        return pulumi.get(self, "roles_key")

    @roles_key.setter
    def roles_key(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "roles_key", value)

    @_builtins.property
    @pulumi.getter(name="subjectKey")
    def subject_key(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Optional. Specifies the attribute in the SAML response where the subject identifier is stored. If not configured, the NameID attribute is used by default. Example: `NameID`.
        """
        return pulumi.get(self, "subject_key")

    @subject_key.setter
    def subject_key(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "subject_key", value)


if not MYPY:
    class OpenSearchServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    OpenSearchServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration
        :param pulumi.Input[_builtins.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)

    @_builtins.property
    @pulumi.getter(name="integrationType")
    def integration_type(self) -> pulumi.Input[_builtins.str]:
        """
        Type of the service integration
        """
        return pulumi.get(self, "integration_type")

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "integration_type", value)

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class OpenSearchTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    OpenSearchTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[_builtins.str],
                 value: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] key: Service tag key
        :param pulumi.Input[_builtins.str] value: Service tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def key(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "key", value)

    @_builtins.property
    @pulumi.getter
    def value(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag value
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "value", value)


if not MYPY:
    class OpenSearchTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    OpenSearchTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OpenSearchTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

    @email.setter
    def email(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "email", value)


if not MYPY:
    class OrganizationAddressTimeoutsArgsDict(TypedDict):
        create: NotRequired[pulumi.Input[_builtins.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).
        """
        delete: NotRequired[pulumi.Input[_builtins.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.
        """
        read: NotRequired[pulumi.Input[_builtins.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.
        """
        update: NotRequired[pulumi.Input[_builtins.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).
        """
elif False:
    OrganizationAddressTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OrganizationAddressTimeoutsArgs:
    def __init__(__self__, *,
                 create: Optional[pulumi.Input[_builtins.str]] = None,
                 delete: Optional[pulumi.Input[_builtins.str]] = None,
                 read: Optional[pulumi.Input[_builtins.str]] = None,
                 update: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.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[_builtins.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[_builtins.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[_builtins.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)

    @_builtins.property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "create", value)

    @_builtins.property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "delete", value)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "read", value)

    @_builtins.property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "update", value)


if not MYPY:
    class OrganizationApplicationUserTimeoutsArgsDict(TypedDict):
        create: NotRequired[pulumi.Input[_builtins.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).
        """
        delete: NotRequired[pulumi.Input[_builtins.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.
        """
        read: NotRequired[pulumi.Input[_builtins.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.
        """
        update: NotRequired[pulumi.Input[_builtins.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).
        """
elif False:
    OrganizationApplicationUserTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OrganizationApplicationUserTimeoutsArgs:
    def __init__(__self__, *,
                 create: Optional[pulumi.Input[_builtins.str]] = None,
                 delete: Optional[pulumi.Input[_builtins.str]] = None,
                 read: Optional[pulumi.Input[_builtins.str]] = None,
                 update: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.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[_builtins.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[_builtins.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[_builtins.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)

    @_builtins.property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "create", value)

    @_builtins.property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "delete", value)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "read", value)

    @_builtins.property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "update", value)


if not MYPY:
    class OrganizationApplicationUserTokenTimeoutsArgsDict(TypedDict):
        create: NotRequired[pulumi.Input[_builtins.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).
        """
        delete: NotRequired[pulumi.Input[_builtins.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.
        """
        read: NotRequired[pulumi.Input[_builtins.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.
        """
        update: NotRequired[pulumi.Input[_builtins.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).
        """
elif False:
    OrganizationApplicationUserTokenTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OrganizationApplicationUserTokenTimeoutsArgs:
    def __init__(__self__, *,
                 create: Optional[pulumi.Input[_builtins.str]] = None,
                 delete: Optional[pulumi.Input[_builtins.str]] = None,
                 read: Optional[pulumi.Input[_builtins.str]] = None,
                 update: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.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[_builtins.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[_builtins.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[_builtins.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)

    @_builtins.property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "create", value)

    @_builtins.property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "delete", value)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "read", value)

    @_builtins.property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "update", value)


if not MYPY:
    class OrganizationBillingGroupTimeoutsArgsDict(TypedDict):
        create: NotRequired[pulumi.Input[_builtins.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).
        """
        delete: NotRequired[pulumi.Input[_builtins.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.
        """
        read: NotRequired[pulumi.Input[_builtins.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.
        """
        update: NotRequired[pulumi.Input[_builtins.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).
        """
elif False:
    OrganizationBillingGroupTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OrganizationBillingGroupTimeoutsArgs:
    def __init__(__self__, *,
                 create: Optional[pulumi.Input[_builtins.str]] = None,
                 delete: Optional[pulumi.Input[_builtins.str]] = None,
                 read: Optional[pulumi.Input[_builtins.str]] = None,
                 update: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.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[_builtins.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[_builtins.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[_builtins.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)

    @_builtins.property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "create", value)

    @_builtins.property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "delete", value)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "read", value)

    @_builtins.property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "update", value)


if not MYPY:
    class OrganizationGroupProjectTimeoutsArgsDict(TypedDict):
        create: NotRequired[pulumi.Input[_builtins.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).
        """
        delete: NotRequired[pulumi.Input[_builtins.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.
        """
        read: NotRequired[pulumi.Input[_builtins.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.
        """
        update: NotRequired[pulumi.Input[_builtins.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).
        """
elif False:
    OrganizationGroupProjectTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OrganizationGroupProjectTimeoutsArgs:
    def __init__(__self__, *,
                 create: Optional[pulumi.Input[_builtins.str]] = None,
                 delete: Optional[pulumi.Input[_builtins.str]] = None,
                 read: Optional[pulumi.Input[_builtins.str]] = None,
                 update: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.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[_builtins.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[_builtins.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[_builtins.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)

    @_builtins.property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "create", value)

    @_builtins.property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "delete", value)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "read", value)

    @_builtins.property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "update", value)


if not MYPY:
    class OrganizationPermissionPermissionArgsDict(TypedDict):
        permissions: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]
        """
        List of [roles and permissions](https://aiven.io/docs/platform/concepts/permissions) to grant". The possible values are `admin`, `developer`, `operator`, `organization:app_users:write`, `organization:audit_logs:read`, `organization:billing:read`, `organization:billing:write`, `organization:domains:write`, `organization:groups:write`, `organization:networking:read`, `organization:networking:write`, `organization:projects:write`, `organization:users:write`, `project:audit_logs:read`, `project:integrations:read`, `project:integrations:write`, `project:networking:read`, `project:networking:write`, `project:permissions:read`, `project:services:read`, `project:services:write`, `read_only`, `role:organization:admin`, `role:services:maintenance`, `role:services:recover`, `service:configuration:write`, `service:data:write`, `service:logs:read`, `service:secrets:read` and `service:users:write`.
        """
        principal_id: pulumi.Input[_builtins.str]
        """
        ID of the user or group to grant permissions to. Only active users who have accepted an [invite](https://aiven.io/docs/platform/howto/manage-org-users) to join the organization can be granted permissions.
        """
        principal_type: pulumi.Input[_builtins.str]
        """
        An enumeration. The possible values are `user` and `user_group`.
        """
        create_time: NotRequired[pulumi.Input[_builtins.str]]
        """
        Create Time.
        """
        update_time: NotRequired[pulumi.Input[_builtins.str]]
        """
        Update Time.
        """
elif False:
    OrganizationPermissionPermissionArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OrganizationPermissionPermissionArgs:
    def __init__(__self__, *,
                 permissions: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]],
                 principal_id: pulumi.Input[_builtins.str],
                 principal_type: pulumi.Input[_builtins.str],
                 create_time: Optional[pulumi.Input[_builtins.str]] = None,
                 update_time: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] permissions: List of [roles and permissions](https://aiven.io/docs/platform/concepts/permissions) to grant". The possible values are `admin`, `developer`, `operator`, `organization:app_users:write`, `organization:audit_logs:read`, `organization:billing:read`, `organization:billing:write`, `organization:domains:write`, `organization:groups:write`, `organization:networking:read`, `organization:networking:write`, `organization:projects:write`, `organization:users:write`, `project:audit_logs:read`, `project:integrations:read`, `project:integrations:write`, `project:networking:read`, `project:networking:write`, `project:permissions:read`, `project:services:read`, `project:services:write`, `read_only`, `role:organization:admin`, `role:services:maintenance`, `role:services:recover`, `service:configuration:write`, `service:data:write`, `service:logs:read`, `service:secrets:read` and `service:users:write`.
        :param pulumi.Input[_builtins.str] principal_id: ID of the user or group to grant permissions to. Only active users who have accepted an [invite](https://aiven.io/docs/platform/howto/manage-org-users) to join the organization can be granted permissions.
        :param pulumi.Input[_builtins.str] principal_type: An enumeration. The possible values are `user` and `user_group`.
        :param pulumi.Input[_builtins.str] create_time: Create Time.
        :param pulumi.Input[_builtins.str] update_time: Update Time.
        """
        pulumi.set(__self__, "permissions", permissions)
        pulumi.set(__self__, "principal_id", principal_id)
        pulumi.set(__self__, "principal_type", principal_type)
        if create_time is not None:
            pulumi.set(__self__, "create_time", create_time)
        if update_time is not None:
            pulumi.set(__self__, "update_time", update_time)

    @_builtins.property
    @pulumi.getter
    def permissions(self) -> pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]:
        """
        List of [roles and permissions](https://aiven.io/docs/platform/concepts/permissions) to grant". The possible values are `admin`, `developer`, `operator`, `organization:app_users:write`, `organization:audit_logs:read`, `organization:billing:read`, `organization:billing:write`, `organization:domains:write`, `organization:groups:write`, `organization:networking:read`, `organization:networking:write`, `organization:projects:write`, `organization:users:write`, `project:audit_logs:read`, `project:integrations:read`, `project:integrations:write`, `project:networking:read`, `project:networking:write`, `project:permissions:read`, `project:services:read`, `project:services:write`, `read_only`, `role:organization:admin`, `role:services:maintenance`, `role:services:recover`, `service:configuration:write`, `service:data:write`, `service:logs:read`, `service:secrets:read` and `service:users:write`.
        """
        return pulumi.get(self, "permissions")

    @permissions.setter
    def permissions(self, value: pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]):
        pulumi.set(self, "permissions", value)

    @_builtins.property
    @pulumi.getter(name="principalId")
    def principal_id(self) -> pulumi.Input[_builtins.str]:
        """
        ID of the user or group to grant permissions to. Only active users who have accepted an [invite](https://aiven.io/docs/platform/howto/manage-org-users) to join the organization can be granted permissions.
        """
        return pulumi.get(self, "principal_id")

    @principal_id.setter
    def principal_id(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "principal_id", value)

    @_builtins.property
    @pulumi.getter(name="principalType")
    def principal_type(self) -> pulumi.Input[_builtins.str]:
        """
        An enumeration. The possible values are `user` and `user_group`.
        """
        return pulumi.get(self, "principal_type")

    @principal_type.setter
    def principal_type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "principal_type", value)

    @_builtins.property
    @pulumi.getter(name="createTime")
    def create_time(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Create Time.
        """
        return pulumi.get(self, "create_time")

    @create_time.setter
    def create_time(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "create_time", value)

    @_builtins.property
    @pulumi.getter(name="updateTime")
    def update_time(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Update Time.
        """
        return pulumi.get(self, "update_time")

    @update_time.setter
    def update_time(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "update_time", value)


if not MYPY:
    class OrganizationPermissionTimeoutsArgsDict(TypedDict):
        create: NotRequired[pulumi.Input[_builtins.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).
        """
        delete: NotRequired[pulumi.Input[_builtins.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.
        """
        read: NotRequired[pulumi.Input[_builtins.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.
        """
        update: NotRequired[pulumi.Input[_builtins.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).
        """
elif False:
    OrganizationPermissionTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OrganizationPermissionTimeoutsArgs:
    def __init__(__self__, *,
                 create: Optional[pulumi.Input[_builtins.str]] = None,
                 delete: Optional[pulumi.Input[_builtins.str]] = None,
                 read: Optional[pulumi.Input[_builtins.str]] = None,
                 update: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.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[_builtins.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[_builtins.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[_builtins.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)

    @_builtins.property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "create", value)

    @_builtins.property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "delete", value)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "read", value)

    @_builtins.property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "update", value)


if not MYPY:
    class OrganizationProjectTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Project tag key.
        """
        value: pulumi.Input[_builtins.str]
        """
        Project tag value.
        """
elif False:
    OrganizationProjectTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OrganizationProjectTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[_builtins.str],
                 value: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] key: Project tag key.
        :param pulumi.Input[_builtins.str] value: Project tag value.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def key(self) -> pulumi.Input[_builtins.str]:
        """
        Project tag key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "key", value)

    @_builtins.property
    @pulumi.getter
    def value(self) -> pulumi.Input[_builtins.str]:
        """
        Project tag value.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "value", value)


if not MYPY:
    class OrganizationProjectTimeoutsArgsDict(TypedDict):
        create: NotRequired[pulumi.Input[_builtins.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).
        """
        delete: NotRequired[pulumi.Input[_builtins.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.
        """
        read: NotRequired[pulumi.Input[_builtins.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.
        """
        update: NotRequired[pulumi.Input[_builtins.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).
        """
elif False:
    OrganizationProjectTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OrganizationProjectTimeoutsArgs:
    def __init__(__self__, *,
                 create: Optional[pulumi.Input[_builtins.str]] = None,
                 delete: Optional[pulumi.Input[_builtins.str]] = None,
                 read: Optional[pulumi.Input[_builtins.str]] = None,
                 update: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.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[_builtins.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[_builtins.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[_builtins.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)

    @_builtins.property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "create", value)

    @_builtins.property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "delete", value)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "read", value)

    @_builtins.property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "update", value)


if not MYPY:
    class OrganizationTimeoutsArgsDict(TypedDict):
        create: NotRequired[pulumi.Input[_builtins.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).
        """
        delete: NotRequired[pulumi.Input[_builtins.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.
        """
        read: NotRequired[pulumi.Input[_builtins.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.
        """
        update: NotRequired[pulumi.Input[_builtins.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).
        """
elif False:
    OrganizationTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OrganizationTimeoutsArgs:
    def __init__(__self__, *,
                 create: Optional[pulumi.Input[_builtins.str]] = None,
                 delete: Optional[pulumi.Input[_builtins.str]] = None,
                 read: Optional[pulumi.Input[_builtins.str]] = None,
                 update: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.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[_builtins.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[_builtins.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[_builtins.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)

    @_builtins.property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "create", value)

    @_builtins.property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "delete", value)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "read", value)

    @_builtins.property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "update", value)


if not MYPY:
    class OrganizationUserGroupMemberTimeoutsArgsDict(TypedDict):
        create: NotRequired[pulumi.Input[_builtins.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).
        """
        delete: NotRequired[pulumi.Input[_builtins.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.
        """
        read: NotRequired[pulumi.Input[_builtins.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.
        """
        update: NotRequired[pulumi.Input[_builtins.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).
        """
elif False:
    OrganizationUserGroupMemberTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OrganizationUserGroupMemberTimeoutsArgs:
    def __init__(__self__, *,
                 create: Optional[pulumi.Input[_builtins.str]] = None,
                 delete: Optional[pulumi.Input[_builtins.str]] = None,
                 read: Optional[pulumi.Input[_builtins.str]] = None,
                 update: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.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[_builtins.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[_builtins.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[_builtins.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)

    @_builtins.property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "create", value)

    @_builtins.property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "delete", value)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "read", value)

    @_builtins.property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "update", value)


if not MYPY:
    class OrganizationalUnitTimeoutsArgsDict(TypedDict):
        create: NotRequired[pulumi.Input[_builtins.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).
        """
        default: NotRequired[pulumi.Input[_builtins.str]]
        """
        Timeout for all operations. Deprecated, use operation-specific timeouts instead.
        """
        delete: NotRequired[pulumi.Input[_builtins.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.
        """
        read: NotRequired[pulumi.Input[_builtins.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.
        """
        update: NotRequired[pulumi.Input[_builtins.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).
        """
elif False:
    OrganizationalUnitTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class OrganizationalUnitTimeoutsArgs:
    def __init__(__self__, *,
                 create: Optional[pulumi.Input[_builtins.str]] = None,
                 default: Optional[pulumi.Input[_builtins.str]] = None,
                 delete: Optional[pulumi.Input[_builtins.str]] = None,
                 read: Optional[pulumi.Input[_builtins.str]] = None,
                 update: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.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[_builtins.str] default: Timeout for all operations. Deprecated, use operation-specific timeouts instead.
        :param pulumi.Input[_builtins.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[_builtins.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[_builtins.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 default is not None:
            warnings.warn("""Use operation-specific timeouts instead. This field will be removed in the next major version.""", DeprecationWarning)
            pulumi.log.warn("""default is deprecated: Use operation-specific timeouts instead. This field will be removed in the next major version.""")
        if default is not None:
            pulumi.set(__self__, "default", default)
        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)

    @_builtins.property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "create", value)

    @_builtins.property
    @pulumi.getter
    @_utilities.deprecated("""Use operation-specific timeouts instead. This field will be removed in the next major version.""")
    def default(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Timeout for all operations. Deprecated, use operation-specific timeouts instead.
        """
        return pulumi.get(self, "default")

    @default.setter
    def default(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "default", value)

    @_builtins.property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "delete", value)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "read", value)

    @_builtins.property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "update", value)


if not MYPY:
    class PgComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    PgComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

    @_builtins.property
    @pulumi.getter
    def component(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Service component name
        """
        return pulumi.get(self, "component")

    @component.setter
    def component(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "component", value)

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

    @connection_uri.setter
    def connection_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "connection_uri", value)

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_authentication_method", value)

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

    @kafka_ssl_ca.setter
    def kafka_ssl_ca(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_ssl_ca", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def route(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Network access route
        """
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "route", value)

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ssl", value)

    @_builtins.property
    @pulumi.getter
    def usage(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        DNS usage name
        """
        return pulumi.get(self, "usage")

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "usage", value)


if not MYPY:
    class PgDatabaseTimeoutsArgsDict(TypedDict):
        create: NotRequired[pulumi.Input[_builtins.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).
        """
        default: NotRequired[pulumi.Input[_builtins.str]]
        """
        Timeout for all operations. Deprecated, use operation-specific timeouts instead.
        """
        delete: NotRequired[pulumi.Input[_builtins.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.
        """
        read: NotRequired[pulumi.Input[_builtins.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.
        """
        update: NotRequired[pulumi.Input[_builtins.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).
        """
elif False:
    PgDatabaseTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgDatabaseTimeoutsArgs:
    def __init__(__self__, *,
                 create: Optional[pulumi.Input[_builtins.str]] = None,
                 default: Optional[pulumi.Input[_builtins.str]] = None,
                 delete: Optional[pulumi.Input[_builtins.str]] = None,
                 read: Optional[pulumi.Input[_builtins.str]] = None,
                 update: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.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[_builtins.str] default: Timeout for all operations. Deprecated, use operation-specific timeouts instead.
        :param pulumi.Input[_builtins.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[_builtins.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[_builtins.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 default is not None:
            warnings.warn("""Use operation-specific timeouts instead. This field will be removed in the next major version.""", DeprecationWarning)
            pulumi.log.warn("""default is deprecated: Use operation-specific timeouts instead. This field will be removed in the next major version.""")
        if default is not None:
            pulumi.set(__self__, "default", default)
        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)

    @_builtins.property
    @pulumi.getter
    def create(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "create", value)

    @_builtins.property
    @pulumi.getter
    @_utilities.deprecated("""Use operation-specific timeouts instead. This field will be removed in the next major version.""")
    def default(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Timeout for all operations. Deprecated, use operation-specific timeouts instead.
        """
        return pulumi.get(self, "default")

    @default.setter
    def default(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "default", value)

    @_builtins.property
    @pulumi.getter
    def delete(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "delete", value)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "read", value)

    @_builtins.property
    @pulumi.getter
    def update(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "update", value)


if not MYPY:
    class PgPgArgsDict(TypedDict):
        bouncer: NotRequired[pulumi.Input[_builtins.str]]
        """
        PgBouncer connection details for [connection pooling](https://aiven.io/docs/products/postgresql/concepts/pg-connection-pooling).
        """
        dbname: NotRequired[pulumi.Input[_builtins.str]]
        """
        Primary PostgreSQL database name.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        PostgreSQL primary node host IP or name.
        """
        max_connections: NotRequired[pulumi.Input[_builtins.int]]
        """
        The [number of allowed connections](https://aiven.io/docs/products/postgresql/reference/pg-connection-limits). Varies based on the service plan.
        """
        params: NotRequired[pulumi.Input[Sequence[pulumi.Input['PgPgParamArgsDict']]]]
        """
        PostgreSQL connection parameters.
        """
        password: NotRequired[pulumi.Input[_builtins.str]]
        """
        PostgreSQL admin user password.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL port.
        """
        replica_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        PostgreSQL replica URI for services with a replica.
        """
        sslmode: NotRequired[pulumi.Input[_builtins.str]]
        """
        PostgreSQL SSL mode setting.
        """
        standby_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        PostgreSQL standby connection URIs.
        """
        syncing_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        PostgreSQL syncing connection URIs.
        """
        uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        PostgreSQL primary connection URI.
        """
        uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        PostgreSQL primary connection URIs.
        """
        user: NotRequired[pulumi.Input[_builtins.str]]
        """
        PostgreSQL admin user name.
        """
elif False:
    PgPgArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgPgArgs:
    def __init__(__self__, *,
                 bouncer: Optional[pulumi.Input[_builtins.str]] = None,
                 dbname: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 max_connections: Optional[pulumi.Input[_builtins.int]] = None,
                 params: Optional[pulumi.Input[Sequence[pulumi.Input['PgPgParamArgs']]]] = None,
                 password: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 replica_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 sslmode: Optional[pulumi.Input[_builtins.str]] = None,
                 standby_uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 syncing_uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 uri: Optional[pulumi.Input[_builtins.str]] = None,
                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 user: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] bouncer: PgBouncer connection details for [connection pooling](https://aiven.io/docs/products/postgresql/concepts/pg-connection-pooling).
        :param pulumi.Input[_builtins.str] dbname: Primary PostgreSQL database name.
        :param pulumi.Input[_builtins.str] host: PostgreSQL primary node host IP or name.
        :param pulumi.Input[_builtins.int] max_connections: The [number of allowed connections](https://aiven.io/docs/products/postgresql/reference/pg-connection-limits). Varies based on the service plan.
        :param pulumi.Input[Sequence[pulumi.Input['PgPgParamArgs']]] params: PostgreSQL connection parameters.
        :param pulumi.Input[_builtins.str] password: PostgreSQL admin user password.
        :param pulumi.Input[_builtins.int] port: PostgreSQL port.
        :param pulumi.Input[_builtins.str] replica_uri: PostgreSQL replica URI for services with a replica.
        :param pulumi.Input[_builtins.str] sslmode: PostgreSQL SSL mode setting.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] standby_uris: PostgreSQL standby connection URIs.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] syncing_uris: PostgreSQL syncing connection URIs.
        :param pulumi.Input[_builtins.str] uri: PostgreSQL primary connection URI.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uris: PostgreSQL primary connection URIs.
        :param pulumi.Input[_builtins.str] user: PostgreSQL admin user name.
        """
        if bouncer is not None:
            warnings.warn("""This field was added by mistake and has never worked. It will be removed in future versions.""", DeprecationWarning)
            pulumi.log.warn("""bouncer is deprecated: This field was added by mistake and has never worked. It will be removed in future versions.""")
        if bouncer is not None:
            pulumi.set(__self__, "bouncer", bouncer)
        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 params is not None:
            pulumi.set(__self__, "params", params)
        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 standby_uris is not None:
            pulumi.set(__self__, "standby_uris", standby_uris)
        if syncing_uris is not None:
            pulumi.set(__self__, "syncing_uris", syncing_uris)
        if uri is not None:
            pulumi.set(__self__, "uri", uri)
        if uris is not None:
            pulumi.set(__self__, "uris", uris)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @_builtins.property
    @pulumi.getter
    @_utilities.deprecated("""This field was added by mistake and has never worked. It will be removed in future versions.""")
    def bouncer(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PgBouncer connection details for [connection pooling](https://aiven.io/docs/products/postgresql/concepts/pg-connection-pooling).
        """
        return pulumi.get(self, "bouncer")

    @bouncer.setter
    def bouncer(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "bouncer", value)

    @_builtins.property
    @pulumi.getter
    def dbname(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Primary PostgreSQL database name.
        """
        return pulumi.get(self, "dbname")

    @dbname.setter
    def dbname(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "dbname", value)

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PostgreSQL primary node host IP or name.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter(name="maxConnections")
    def max_connections(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The [number of allowed connections](https://aiven.io/docs/products/postgresql/reference/pg-connection-limits). Varies based on the service plan.
        """
        return pulumi.get(self, "max_connections")

    @max_connections.setter
    def max_connections(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_connections", value)

    @_builtins.property
    @pulumi.getter
    def params(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['PgPgParamArgs']]]]:
        """
        PostgreSQL connection parameters.
        """
        return pulumi.get(self, "params")

    @params.setter
    def params(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['PgPgParamArgs']]]]):
        pulumi.set(self, "params", value)

    @_builtins.property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PostgreSQL admin user password.
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "password", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL port.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter(name="replicaUri")
    def replica_uri(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "replica_uri", value)

    @_builtins.property
    @pulumi.getter
    def sslmode(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PostgreSQL SSL mode setting.
        """
        return pulumi.get(self, "sslmode")

    @sslmode.setter
    def sslmode(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "sslmode", value)

    @_builtins.property
    @pulumi.getter(name="standbyUris")
    def standby_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        PostgreSQL standby connection URIs.
        """
        return pulumi.get(self, "standby_uris")

    @standby_uris.setter
    def standby_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "standby_uris", value)

    @_builtins.property
    @pulumi.getter(name="syncingUris")
    def syncing_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        PostgreSQL syncing connection URIs.
        """
        return pulumi.get(self, "syncing_uris")

    @syncing_uris.setter
    def syncing_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "syncing_uris", value)

    @_builtins.property
    @pulumi.getter
    def uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PostgreSQL primary connection URI.
        """
        return pulumi.get(self, "uri")

    @uri.setter
    def uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "uri", value)

    @_builtins.property
    @pulumi.getter
    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        PostgreSQL primary connection URIs.
        """
        return pulumi.get(self, "uris")

    @uris.setter
    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "uris", value)

    @_builtins.property
    @pulumi.getter
    def user(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PostgreSQL admin user name.
        """
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "user", value)


if not MYPY:
    class PgPgParamArgsDict(TypedDict):
        database_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Primary PostgreSQL database name.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        PostgreSQL host IP or name.
        """
        password: NotRequired[pulumi.Input[_builtins.str]]
        """
        PostgreSQL admin user password.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL port.
        """
        sslmode: NotRequired[pulumi.Input[_builtins.str]]
        """
        PostgreSQL SSL mode setting.
        """
        user: NotRequired[pulumi.Input[_builtins.str]]
        """
        PostgreSQL admin user name.
        """
elif False:
    PgPgParamArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgPgParamArgs:
    def __init__(__self__, *,
                 database_name: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 password: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 sslmode: Optional[pulumi.Input[_builtins.str]] = None,
                 user: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] database_name: Primary PostgreSQL database name.
        :param pulumi.Input[_builtins.str] host: PostgreSQL host IP or name.
        :param pulumi.Input[_builtins.str] password: PostgreSQL admin user password.
        :param pulumi.Input[_builtins.int] port: PostgreSQL port.
        :param pulumi.Input[_builtins.str] sslmode: PostgreSQL SSL mode setting.
        :param pulumi.Input[_builtins.str] user: PostgreSQL admin user name.
        """
        if database_name is not None:
            pulumi.set(__self__, "database_name", database_name)
        if host is not None:
            pulumi.set(__self__, "host", host)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if port is not None:
            pulumi.set(__self__, "port", port)
        if sslmode is not None:
            pulumi.set(__self__, "sslmode", sslmode)
        if user is not None:
            pulumi.set(__self__, "user", user)

    @_builtins.property
    @pulumi.getter(name="databaseName")
    def database_name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Primary PostgreSQL database name.
        """
        return pulumi.get(self, "database_name")

    @database_name.setter
    def database_name(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "database_name", value)

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PostgreSQL host IP or name.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PostgreSQL admin user password.
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "password", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL port.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def sslmode(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PostgreSQL SSL mode setting.
        """
        return pulumi.get(self, "sslmode")

    @sslmode.setter
    def sslmode(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "sslmode", value)

    @_builtins.property
    @pulumi.getter
    def user(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PostgreSQL admin user name.
        """
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "user", value)


if not MYPY:
    class PgPgUserConfigArgsDict(TypedDict):
        additional_backup_regions: NotRequired[pulumi.Input[_builtins.str]]
        """
        Additional Cloud Regions for Backup Replication.
        """
        admin_password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Custom password for admin user. Defaults to random string. This must be set only when a new service is being created.
        """
        admin_username: NotRequired[pulumi.Input[_builtins.str]]
        """
        Custom username for admin user. This must be set only when a new service is being created. Example: `avnadmin`.
        """
        backup_hour: NotRequired[pulumi.Input[_builtins.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. Example: `3`.
        """
        backup_interval_hours: NotRequired[pulumi.Input[_builtins.int]]
        """
        Interval in hours between automatic backups. Minimum value is 3 hours. Must be a divisor of 24 (3, 4, 6, 8, 12, 24). (Applicable to ACU plans only). Example: `24`.
        """
        backup_minute: NotRequired[pulumi.Input[_builtins.int]]
        """
        The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed. Example: `30`.
        """
        backup_retention_days: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of days to retain automatic backups. Backups older than this value will be automatically deleted. (Applicable to ACU plans only). Example: `7`.
        """
        enable_ha_replica_dns: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Creates a dedicated read-only DNS that automatically falls back to the primary if standby nodes are unavailable. It switches back when a standby recovers. Default: `false`.
        """
        enable_ipv6: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Register AAAA DNS records for the service, and allow IPv6 packets to service ports.
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['PgPgUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        migration: NotRequired[pulumi.Input['PgPgUserConfigMigrationArgsDict']]
        """
        Migrate data from existing server
        """
        node_count: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of nodes for the service. Example: `3`.
        """
        pg: NotRequired[pulumi.Input['PgPgUserConfigPgArgsDict']]
        """
        postgresql.conf configuration values
        """
        pg_qualstats: NotRequired[pulumi.Input['PgPgUserConfigPgQualstatsArgsDict']]
        """
        System-wide settings for the pg*qualstats extension
        """
        pg_read_replica: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Should the service which is being forked be a read replica (deprecated, use read_replica service integration instead).
        """
        pg_service_to_fork_from: NotRequired[pulumi.Input[_builtins.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. Example: `anotherservicename`.
        """
        pg_stat_monitor_enable: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable the pg*stat*monitor extension. Changing this parameter causes a service restart. When this extension is enabled, pg*stat*statements results for utility commands are unreliable. Default: `false`.
        """
        pg_version: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `10`, `11`, `12`, `13`, `14`, `15`, `16`, `17`, `18`, and newer. PostgreSQL major version.
        """
        pgaudit: NotRequired[pulumi.Input['PgPgUserConfigPgauditArgsDict']]
        """
        System-wide settings for the pgaudit extension
        """
        pgbouncer: NotRequired[pulumi.Input['PgPgUserConfigPgbouncerArgsDict']]
        """
        PGBouncer connection pooling settings
        """
        pglookout: NotRequired[pulumi.Input['PgPgUserConfigPglookoutArgsDict']]
        """
        System-wide settings for pglookout
        """
        private_access: NotRequired[pulumi.Input['PgPgUserConfigPrivateAccessArgsDict']]
        """
        Allow access to selected service ports from private networks
        """
        privatelink_access: NotRequired[pulumi.Input['PgPgUserConfigPrivatelinkAccessArgsDict']]
        """
        Allow access to selected service components through Privatelink
        """
        project_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        public_access: NotRequired[pulumi.Input['PgPgUserConfigPublicAccessArgsDict']]
        """
        Allow access to selected service ports from the public Internet
        """
        recovery_target_time: NotRequired[pulumi.Input[_builtins.str]]
        """
        Recovery target time when forking a service. This has effect only when a new service is being created. Example: `2019-01-01 23:34:45`.
        """
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        service_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        shared_buffers_percentage: NotRequired[pulumi.Input[_builtins.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. Changing this parameter causes a service restart. Example: `41.5`.
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
        synchronous_replication: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `off`, `quorum`. Synchronous replication type. Note that the service plan also needs to support synchronous replication.
        """
        timescaledb: NotRequired[pulumi.Input['PgPgUserConfigTimescaledbArgsDict']]
        """
        System-wide settings for the timescaledb extension
        """
        variant: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `aiven`, `timescale`. Variant of the PostgreSQL service, may affect the features that are exposed by default.
        """
        work_mem: NotRequired[pulumi.Input[_builtins.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. The default is 1MB + 0.075% of total RAM (up to 32MB). Example: `4`.
        """
elif False:
    PgPgUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgPgUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[_builtins.str]] = None,
                 admin_password: Optional[pulumi.Input[_builtins.str]] = None,
                 admin_username: Optional[pulumi.Input[_builtins.str]] = None,
                 backup_hour: Optional[pulumi.Input[_builtins.int]] = None,
                 backup_interval_hours: Optional[pulumi.Input[_builtins.int]] = None,
                 backup_minute: Optional[pulumi.Input[_builtins.int]] = None,
                 backup_retention_days: Optional[pulumi.Input[_builtins.int]] = None,
                 enable_ha_replica_dns: Optional[pulumi.Input[_builtins.bool]] = None,
                 enable_ipv6: Optional[pulumi.Input[_builtins.bool]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['PgPgUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 migration: Optional[pulumi.Input['PgPgUserConfigMigrationArgs']] = None,
                 node_count: Optional[pulumi.Input[_builtins.int]] = None,
                 pg: Optional[pulumi.Input['PgPgUserConfigPgArgs']] = None,
                 pg_qualstats: Optional[pulumi.Input['PgPgUserConfigPgQualstatsArgs']] = None,
                 pg_read_replica: Optional[pulumi.Input[_builtins.bool]] = None,
                 pg_service_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 pg_stat_monitor_enable: Optional[pulumi.Input[_builtins.bool]] = None,
                 pg_version: Optional[pulumi.Input[_builtins.str]] = None,
                 pgaudit: Optional[pulumi.Input['PgPgUserConfigPgauditArgs']] = 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[_builtins.str]] = None,
                 public_access: Optional[pulumi.Input['PgPgUserConfigPublicAccessArgs']] = None,
                 recovery_target_time: Optional[pulumi.Input[_builtins.str]] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 service_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 shared_buffers_percentage: Optional[pulumi.Input[_builtins.float]] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None,
                 synchronous_replication: Optional[pulumi.Input[_builtins.str]] = None,
                 timescaledb: Optional[pulumi.Input['PgPgUserConfigTimescaledbArgs']] = None,
                 variant: Optional[pulumi.Input[_builtins.str]] = None,
                 work_mem: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[_builtins.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[_builtins.str] admin_username: Custom username for admin user. This must be set only when a new service is being created. Example: `avnadmin`.
        :param pulumi.Input[_builtins.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. Example: `3`.
        :param pulumi.Input[_builtins.int] backup_interval_hours: Interval in hours between automatic backups. Minimum value is 3 hours. Must be a divisor of 24 (3, 4, 6, 8, 12, 24). (Applicable to ACU plans only). Example: `24`.
        :param pulumi.Input[_builtins.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. Example: `30`.
        :param pulumi.Input[_builtins.int] backup_retention_days: Number of days to retain automatic backups. Backups older than this value will be automatically deleted. (Applicable to ACU plans only). Example: `7`.
        :param pulumi.Input[_builtins.bool] enable_ha_replica_dns: Creates a dedicated read-only DNS that automatically falls back to the primary if standby nodes are unavailable. It switches back when a standby recovers. Default: `false`.
        :param pulumi.Input[_builtins.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[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.int] node_count: Number of nodes for the service. Example: `3`.
        :param pulumi.Input['PgPgUserConfigPgArgs'] pg: postgresql.conf configuration values
        :param pulumi.Input['PgPgUserConfigPgQualstatsArgs'] pg_qualstats: System-wide settings for the pg*qualstats extension
        :param pulumi.Input[_builtins.bool] pg_read_replica: Should the service which is being forked be a read replica (deprecated, use read_replica service integration instead).
        :param pulumi.Input[_builtins.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. Example: `anotherservicename`.
        :param pulumi.Input[_builtins.bool] pg_stat_monitor_enable: Enable the pg*stat*monitor extension. Changing this parameter causes a service restart. When this extension is enabled, pg*stat*statements results for utility commands are unreliable. Default: `false`.
        :param pulumi.Input[_builtins.str] pg_version: Enum: `10`, `11`, `12`, `13`, `14`, `15`, `16`, `17`, `18`, and newer. PostgreSQL major version.
        :param pulumi.Input['PgPgUserConfigPgauditArgs'] pgaudit: System-wide settings for the pgaudit extension
        :param pulumi.Input['PgPgUserConfigPgbouncerArgs'] pgbouncer: PGBouncer connection pooling settings
        :param pulumi.Input['PgPgUserConfigPglookoutArgs'] pglookout: System-wide settings for pglookout
        :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[_builtins.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. Example: `anotherprojectname`.
        :param pulumi.Input['PgPgUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
        :param pulumi.Input[_builtins.str] recovery_target_time: Recovery target time when forking a service. This has effect only when a new service is being created. Example: `2019-01-01 23:34:45`.
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input[_builtins.str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        :param pulumi.Input[_builtins.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. Changing this parameter causes a service restart. Example: `41.5`.
        :param pulumi.Input[_builtins.bool] static_ips: Use static public IP addresses.
        :param pulumi.Input[_builtins.str] synchronous_replication: Enum: `off`, `quorum`. Synchronous replication type. Note that the service plan also needs to support synchronous replication.
        :param pulumi.Input['PgPgUserConfigTimescaledbArgs'] timescaledb: System-wide settings for the timescaledb extension
        :param pulumi.Input[_builtins.str] variant: Enum: `aiven`, `timescale`. Variant of the PostgreSQL service, may affect the features that are exposed by default.
        :param pulumi.Input[_builtins.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. The default is 1MB + 0.075% of total RAM (up to 32MB). Example: `4`.
        """
        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_interval_hours is not None:
            pulumi.set(__self__, "backup_interval_hours", backup_interval_hours)
        if backup_minute is not None:
            pulumi.set(__self__, "backup_minute", backup_minute)
        if backup_retention_days is not None:
            pulumi.set(__self__, "backup_retention_days", backup_retention_days)
        if enable_ha_replica_dns is not None:
            pulumi.set(__self__, "enable_ha_replica_dns", enable_ha_replica_dns)
        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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `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 node_count is not None:
            pulumi.set(__self__, "node_count", node_count)
        if pg is not None:
            pulumi.set(__self__, "pg", pg)
        if pg_qualstats is not None:
            warnings.warn("""This property is deprecated.""", DeprecationWarning)
            pulumi.log.warn("""pg_qualstats is deprecated: This property is deprecated.""")
        if pg_qualstats is not None:
            pulumi.set(__self__, "pg_qualstats", pg_qualstats)
        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:
            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 pgaudit is not None:
            pulumi.set(__self__, "pgaudit", pgaudit)
        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_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        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)

    @_builtins.property
    @pulumi.getter(name="additionalBackupRegions")
    def additional_backup_regions(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @_builtins.property
    @pulumi.getter(name="adminPassword")
    def admin_password(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "admin_password", value)

    @_builtins.property
    @pulumi.getter(name="adminUsername")
    def admin_username(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Custom username for admin user. This must be set only when a new service is being created. Example: `avnadmin`.
        """
        return pulumi.get(self, "admin_username")

    @admin_username.setter
    def admin_username(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "admin_username", value)

    @_builtins.property
    @pulumi.getter(name="backupHour")
    def backup_hour(self) -> Optional[pulumi.Input[_builtins.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. Example: `3`.
        """
        return pulumi.get(self, "backup_hour")

    @backup_hour.setter
    def backup_hour(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "backup_hour", value)

    @_builtins.property
    @pulumi.getter(name="backupIntervalHours")
    def backup_interval_hours(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Interval in hours between automatic backups. Minimum value is 3 hours. Must be a divisor of 24 (3, 4, 6, 8, 12, 24). (Applicable to ACU plans only). Example: `24`.
        """
        return pulumi.get(self, "backup_interval_hours")

    @backup_interval_hours.setter
    def backup_interval_hours(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "backup_interval_hours", value)

    @_builtins.property
    @pulumi.getter(name="backupMinute")
    def backup_minute(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed. Example: `30`.
        """
        return pulumi.get(self, "backup_minute")

    @backup_minute.setter
    def backup_minute(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "backup_minute", value)

    @_builtins.property
    @pulumi.getter(name="backupRetentionDays")
    def backup_retention_days(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of days to retain automatic backups. Backups older than this value will be automatically deleted. (Applicable to ACU plans only). Example: `7`.
        """
        return pulumi.get(self, "backup_retention_days")

    @backup_retention_days.setter
    def backup_retention_days(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "backup_retention_days", value)

    @_builtins.property
    @pulumi.getter(name="enableHaReplicaDns")
    def enable_ha_replica_dns(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Creates a dedicated read-only DNS that automatically falls back to the primary if standby nodes are unavailable. It switches back when a standby recovers. Default: `false`.
        """
        return pulumi.get(self, "enable_ha_replica_dns")

    @enable_ha_replica_dns.setter
    def enable_ha_replica_dns(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "enable_ha_replica_dns", value)

    @_builtins.property
    @pulumi.getter(name="enableIpv6")
    def enable_ipv6(self) -> Optional[pulumi.Input[_builtins.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[_builtins.bool]]):
        pulumi.set(self, "enable_ipv6", value)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "ip_filters", value)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="nodeCount")
    def node_count(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of nodes for the service. Example: `3`.
        """
        return pulumi.get(self, "node_count")

    @node_count.setter
    def node_count(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "node_count", value)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="pgQualstats")
    @_utilities.deprecated("""This property is deprecated.""")
    def pg_qualstats(self) -> Optional[pulumi.Input['PgPgUserConfigPgQualstatsArgs']]:
        """
        System-wide settings for the pg*qualstats extension
        """
        return pulumi.get(self, "pg_qualstats")

    @pg_qualstats.setter
    def pg_qualstats(self, value: Optional[pulumi.Input['PgPgUserConfigPgQualstatsArgs']]):
        pulumi.set(self, "pg_qualstats", value)

    @_builtins.property
    @pulumi.getter(name="pgReadReplica")
    def pg_read_replica(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Should the service which is being forked be a read replica (deprecated, use read_replica service integration instead).
        """
        return pulumi.get(self, "pg_read_replica")

    @pg_read_replica.setter
    def pg_read_replica(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "pg_read_replica", value)

    @_builtins.property
    @pulumi.getter(name="pgServiceToForkFrom")
    def pg_service_to_fork_from(self) -> Optional[pulumi.Input[_builtins.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. Example: `anotherservicename`.
        """
        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[_builtins.str]]):
        pulumi.set(self, "pg_service_to_fork_from", value)

    @_builtins.property
    @pulumi.getter(name="pgStatMonitorEnable")
    def pg_stat_monitor_enable(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable the pg*stat*monitor extension. Changing this parameter causes a service restart. When this extension is enabled, pg*stat*statements results for utility commands are unreliable. Default: `false`.
        """
        return pulumi.get(self, "pg_stat_monitor_enable")

    @pg_stat_monitor_enable.setter
    def pg_stat_monitor_enable(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "pg_stat_monitor_enable", value)

    @_builtins.property
    @pulumi.getter(name="pgVersion")
    def pg_version(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `10`, `11`, `12`, `13`, `14`, `15`, `16`, `17`, `18`, and newer. PostgreSQL major version.
        """
        return pulumi.get(self, "pg_version")

    @pg_version.setter
    def pg_version(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "pg_version", value)

    @_builtins.property
    @pulumi.getter
    def pgaudit(self) -> Optional[pulumi.Input['PgPgUserConfigPgauditArgs']]:
        """
        System-wide settings for the pgaudit extension
        """
        return pulumi.get(self, "pgaudit")

    @pgaudit.setter
    def pgaudit(self, value: Optional[pulumi.Input['PgPgUserConfigPgauditArgs']]):
        pulumi.set(self, "pgaudit", value)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter
    def pglookout(self) -> Optional[pulumi.Input['PgPgUserConfigPglookoutArgs']]:
        """
        System-wide settings for pglookout
        """
        return pulumi.get(self, "pglookout")

    @pglookout.setter
    def pglookout(self, value: Optional[pulumi.Input['PgPgUserConfigPglookoutArgs']]):
        pulumi.set(self, "pglookout", value)

    @_builtins.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)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="projectToForkFrom")
    def project_to_fork_from(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        return pulumi.get(self, "project_to_fork_from")

    @project_to_fork_from.setter
    def project_to_fork_from(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "project_to_fork_from", value)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="recoveryTargetTime")
    def recovery_target_time(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Recovery target time when forking a service. This has effect only when a new service is being created. Example: `2019-01-01 23:34:45`.
        """
        return pulumi.get(self, "recovery_target_time")

    @recovery_target_time.setter
    def recovery_target_time(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "recovery_target_time", value)

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

    @service_log.setter
    def service_log(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "service_log", value)

    @_builtins.property
    @pulumi.getter(name="serviceToForkFrom")
    def service_to_fork_from(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        return pulumi.get(self, "service_to_fork_from")

    @service_to_fork_from.setter
    def service_to_fork_from(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "service_to_fork_from", value)

    @_builtins.property
    @pulumi.getter(name="sharedBuffersPercentage")
    def shared_buffers_percentage(self) -> Optional[pulumi.Input[_builtins.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. Changing this parameter causes a service restart. Example: `41.5`.
        """
        return pulumi.get(self, "shared_buffers_percentage")

    @shared_buffers_percentage.setter
    def shared_buffers_percentage(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "shared_buffers_percentage", value)

    @_builtins.property
    @pulumi.getter(name="staticIps")
    def static_ips(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Use static public IP addresses.
        """
        return pulumi.get(self, "static_ips")

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "static_ips", value)

    @_builtins.property
    @pulumi.getter(name="synchronousReplication")
    def synchronous_replication(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `off`, `quorum`. 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[_builtins.str]]):
        pulumi.set(self, "synchronous_replication", value)

    @_builtins.property
    @pulumi.getter
    def timescaledb(self) -> Optional[pulumi.Input['PgPgUserConfigTimescaledbArgs']]:
        """
        System-wide settings for the timescaledb extension
        """
        return pulumi.get(self, "timescaledb")

    @timescaledb.setter
    def timescaledb(self, value: Optional[pulumi.Input['PgPgUserConfigTimescaledbArgs']]):
        pulumi.set(self, "timescaledb", value)

    @_builtins.property
    @pulumi.getter
    def variant(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `aiven`, `timescale`. 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[_builtins.str]]):
        pulumi.set(self, "variant", value)

    @_builtins.property
    @pulumi.getter(name="workMem")
    def work_mem(self) -> Optional[pulumi.Input[_builtins.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. The default is 1MB + 0.075% of total RAM (up to 32MB). Example: `4`.
        """
        return pulumi.get(self, "work_mem")

    @work_mem.setter
    def work_mem(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "work_mem", value)


if not MYPY:
    class PgPgUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    PgPgUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgPgUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "network", value)

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "description", value)


if not MYPY:
    class PgPgUserConfigMigrationArgsDict(TypedDict):
        host: pulumi.Input[_builtins.str]
        """
        Hostname or IP address of the server where to migrate data from. Example: `my.server.com`.
        """
        port: pulumi.Input[_builtins.int]
        """
        Port number of the server where to migrate data from. Example: `1234`.
        """
        dbname: NotRequired[pulumi.Input[_builtins.str]]
        """
        Database name for bootstrapping the initial connection. Example: `defaultdb`.
        """
        ignore_dbs: NotRequired[pulumi.Input[_builtins.str]]
        """
        Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
        """
        ignore_roles: NotRequired[pulumi.Input[_builtins.str]]
        """
        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
        """
        method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
        """
        password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        The server where to migrate data from is secured with SSL. Default: `true`.
        """
        username: NotRequired[pulumi.Input[_builtins.str]]
        """
        User name for authentication with the server where to migrate data from. Example: `myname`.
        """
elif False:
    PgPgUserConfigMigrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgPgUserConfigMigrationArgs:
    def __init__(__self__, *,
                 host: pulumi.Input[_builtins.str],
                 port: pulumi.Input[_builtins.int],
                 dbname: Optional[pulumi.Input[_builtins.str]] = None,
                 ignore_dbs: Optional[pulumi.Input[_builtins.str]] = None,
                 ignore_roles: Optional[pulumi.Input[_builtins.str]] = None,
                 method: Optional[pulumi.Input[_builtins.str]] = None,
                 password: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 username: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] host: Hostname or IP address of the server where to migrate data from. Example: `my.server.com`.
        :param pulumi.Input[_builtins.int] port: Port number of the server where to migrate data from. Example: `1234`.
        :param pulumi.Input[_builtins.str] dbname: Database name for bootstrapping the initial connection. Example: `defaultdb`.
        :param pulumi.Input[_builtins.str] ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
        :param pulumi.Input[_builtins.str] ignore_roles: Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
        :param pulumi.Input[_builtins.str] method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
        :param pulumi.Input[_builtins.str] password: Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
        :param pulumi.Input[_builtins.bool] ssl: The server where to migrate data from is secured with SSL. Default: `true`.
        :param pulumi.Input[_builtins.str] username: User name for authentication with the server where to migrate data from. Example: `myname`.
        """
        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 ignore_roles is not None:
            pulumi.set(__self__, "ignore_roles", ignore_roles)
        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)

    @_builtins.property
    @pulumi.getter
    def host(self) -> pulumi.Input[_builtins.str]:
        """
        Hostname or IP address of the server where to migrate data from. Example: `my.server.com`.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> pulumi.Input[_builtins.int]:
        """
        Port number of the server where to migrate data from. Example: `1234`.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def dbname(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Database name for bootstrapping the initial connection. Example: `defaultdb`.
        """
        return pulumi.get(self, "dbname")

    @dbname.setter
    def dbname(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "dbname", value)

    @_builtins.property
    @pulumi.getter(name="ignoreDbs")
    def ignore_dbs(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
        """
        return pulumi.get(self, "ignore_dbs")

    @ignore_dbs.setter
    def ignore_dbs(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ignore_dbs", value)

    @_builtins.property
    @pulumi.getter(name="ignoreRoles")
    def ignore_roles(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
        """
        return pulumi.get(self, "ignore_roles")

    @ignore_roles.setter
    def ignore_roles(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ignore_roles", value)

    @_builtins.property
    @pulumi.getter
    def method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
        """
        return pulumi.get(self, "method")

    @method.setter
    def method(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "method", value)

    @_builtins.property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "password", value)

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        The server where to migrate data from is secured with SSL. Default: `true`.
        """
        return pulumi.get(self, "ssl")

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ssl", value)

    @_builtins.property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        User name for authentication with the server where to migrate data from. Example: `myname`.
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "username", value)


if not MYPY:
    class PgPgUserConfigPgArgsDict(TypedDict):
        autovacuum_analyze_scale_factor: NotRequired[pulumi.Input[_builtins.float]]
        """
        Specifies a fraction of the table size to add to autovacuum*analyze*threshold when deciding whether to trigger an ANALYZE (e.g. `0.2` for 20% of the table size). The default is `0.2`.
        """
        autovacuum_analyze_threshold: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the minimum number of inserted, updated or deleted tuples needed to trigger an ANALYZE in any one table. The default is `50`.
        """
        autovacuum_freeze_max_age: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the maximum age (in transactions) that a table's pg_class.relfrozenxid field can attain before a VACUUM operation is forced to prevent transaction ID wraparound within the table. The system launches autovacuum processes to prevent wraparound even when autovacuum is otherwise disabled. Changing this parameter causes a service restart.
        """
        autovacuum_max_workers: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the maximum number of autovacuum processes (other than the autovacuum launcher) that may be running at any one time. The default is `3`. Changing this parameter causes a service restart.
        """
        autovacuum_naptime: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the minimum delay between autovacuum runs on any given database. The delay is measured in seconds. The default is `60`.
        """
        autovacuum_vacuum_cost_delay: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the cost delay value that will be used in automatic VACUUM operations. If `-1` is specified, the regular vacuum*cost*delay value will be used. The default is `2` (upstream default).
        """
        autovacuum_vacuum_cost_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the cost limit value that will be used in automatic VACUUM operations. If `-1` is specified, the regular vacuum*cost*limit value will be used. The default is `-1` (upstream default).
        """
        autovacuum_vacuum_scale_factor: NotRequired[pulumi.Input[_builtins.float]]
        """
        Specifies a fraction of the table size to add to autovacuum*vacuum*threshold when deciding whether to trigger a VACUUM (e.g. `0.2` for 20% of the table size). The default is `0.2`.
        """
        autovacuum_vacuum_threshold: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the minimum number of updated or deleted tuples needed to trigger a VACUUM in any one table. The default is `50`.
        """
        bgwriter_delay: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the delay between activity rounds for the background writer in milliseconds. The default is `200`. Example: `200`.
        """
        bgwriter_flush_after: NotRequired[pulumi.Input[_builtins.int]]
        """
        Whenever more than bgwriter*flush*after bytes have been written by the background writer, attempt to force the OS to issue these writes to the underlying storage. Specified in kilobytes. Setting of 0 disables forced writeback. The default is `512`. Example: `512`.
        """
        bgwriter_lru_maxpages: NotRequired[pulumi.Input[_builtins.int]]
        """
        In each round, no more than this many buffers will be written by the background writer. Setting this to zero disables background writing. The default is `100`. Example: `100`.
        """
        bgwriter_lru_multiplier: NotRequired[pulumi.Input[_builtins.float]]
        """
        The average recent need for new buffers is multiplied by bgwriter*lru*multiplier to arrive at an estimate of the number that will be needed during the next round, (up to bgwriter*lru*maxpages). 1.0 represents a “just in time” policy of writing exactly the number of buffers predicted to be needed. Larger values provide some cushion against spikes in demand, while smaller values intentionally leave writes to be done by server processes. The default is `2.0`. Example: `2`.
        """
        deadlock_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        This is the amount of time, in milliseconds, to wait on a lock before checking to see if there is a deadlock condition. The default is `1000` (upstream default). Example: `1000`.
        """
        default_toast_compression: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `lz4`, `pglz`. Specifies the default TOAST compression method for values of compressible columns. The default is `lz4`. Only available for PostgreSQL 14+.
        """
        idle_in_transaction_session_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        Time out sessions with open transactions after this number of milliseconds.
        """
        io_combine_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        EXPERIMENTAL: Controls the largest I/O size in operations that combine I/O in 8kB units. Version 17 and up only. Default: `16`.
        """
        io_max_combine_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        EXPERIMENTAL: Controls the largest I/O size in operations that combine I/O in 8kB units, and silently limits the user-settable parameter io*combine*limit. Version 18 and up only. Changing this parameter causes a service restart. Default: `16`.
        """
        io_max_concurrency: NotRequired[pulumi.Input[_builtins.int]]
        """
        EXPERIMENTAL: Controls the maximum number of I/O operations that one process can execute simultaneously. Version 18 and up only. Changing this parameter causes a service restart. Default: `-1`.
        """
        io_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `io_uring`, `sync`, `worker`. EXPERIMENTAL: Controls the maximum number of I/O operations that one process can execute simultaneously. Version 18 and up only. Changing this parameter causes a service restart. Default: `worker`.
        """
        io_workers: NotRequired[pulumi.Input[_builtins.int]]
        """
        EXPERIMENTAL: Number of IO worker processes, for io_method=worker. Version 18 and up only. Changing this parameter causes a service restart. Default: `3`.
        """
        jit: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Controls system-wide use of Just-in-Time Compilation (JIT).
        """
        log_autovacuum_min_duration: NotRequired[pulumi.Input[_builtins.int]]
        """
        Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one disables logging autovacuum actions. The default is `1000`.
        """
        log_error_verbosity: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `DEFAULT`, `TERSE`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
        """
        log_line_prefix: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
        """
        log_min_duration_statement: NotRequired[pulumi.Input[_builtins.int]]
        """
        Log statements that take more than this number of milliseconds to run, -1 disables.
        """
        log_temp_files: NotRequired[pulumi.Input[_builtins.int]]
        """
        Log statements for each temporary file created larger than this number of kilobytes, -1 disables.
        """
        max_connections: NotRequired[pulumi.Input[_builtins.int]]
        """
        Sets the PostgreSQL maximum number of concurrent connections to the database server. This is a limited-release parameter. Contact your account team to confirm your eligibility. You cannot decrease this parameter value when set. For services with a read replica, first increase the read replica's value. After the change is applied to the replica, you can increase the primary service's value. Changing this parameter causes a service restart.
        """
        max_files_per_process: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL maximum number of files that can be open per process. The default is `1000` (upstream default). Changing this parameter causes a service restart.
        """
        max_locks_per_transaction: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL maximum locks per transaction. Changing this parameter causes a service restart.
        """
        max_logical_replication_workers: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL maximum logical replication workers (taken from the pool of max*parallel*workers). The default is `4` (upstream default). Changing this parameter causes a service restart.
        """
        max_parallel_workers: NotRequired[pulumi.Input[_builtins.int]]
        """
        Sets the maximum number of workers that the system can support for parallel queries. The default is `8` (upstream default).
        """
        max_parallel_workers_per_gather: NotRequired[pulumi.Input[_builtins.int]]
        """
        Sets the maximum number of workers that can be started by a single Gather or Gather Merge node. The default is `2` (upstream default).
        """
        max_pred_locks_per_transaction: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL maximum predicate locks per transaction. The default is `64` (upstream default). Changing this parameter causes a service restart.
        """
        max_prepared_transactions: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL maximum prepared transactions. The default is `0`. Changing this parameter causes a service restart.
        """
        max_replication_slots: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL maximum replication slots. The default is `20`. Changing this parameter causes a service restart.
        """
        max_slot_wal_keep_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL maximum WAL size (MB) reserved for replication slots. If `-1` is specified, replication slots may retain an unlimited amount of WAL files. The default is `-1` (upstream default). wal*keep*size minimum WAL size setting takes precedence over this.
        """
        max_stack_depth: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum depth of the stack in bytes. The default is `2097152` (upstream default).
        """
        max_standby_archive_delay: NotRequired[pulumi.Input[_builtins.int]]
        """
        Max standby archive delay in milliseconds. The default is `30000` (upstream default).
        """
        max_standby_streaming_delay: NotRequired[pulumi.Input[_builtins.int]]
        """
        Max standby streaming delay in milliseconds. The default is `30000` (upstream default).
        """
        max_sync_workers_per_subscription: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum number of synchronization workers per subscription. The default is `2`.
        """
        max_wal_senders: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL maximum WAL senders. The default is `20`. Changing this parameter causes a service restart.
        """
        max_worker_processes: NotRequired[pulumi.Input[_builtins.int]]
        """
        Sets the maximum number of background processes that the system can support. The default is `8`. Changing this parameter causes a service restart.
        """
        password_encryption: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `md5`, `scram-sha-256`. Chooses the algorithm for encrypting passwords.
        """
        pg_partman_bgw_dot_interval: NotRequired[pulumi.Input[_builtins.int]]
        """
        Sets the time interval in seconds to run pg_partman's scheduled tasks. The default is `3600`. Example: `3600`.
        """
        pg_partman_bgw_dot_role: NotRequired[pulumi.Input[_builtins.str]]
        """
        Controls which role to use for pg_partman's scheduled background tasks. Example: `myrolename`.
        """
        pg_stat_monitor_dot_pgsm_enable_query_plan: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enables or disables query plan monitoring. Changing this parameter causes a service restart. Only available for PostgreSQL 13+.
        """
        pg_stat_monitor_dot_pgsm_max_buckets: NotRequired[pulumi.Input[_builtins.int]]
        """
        Sets the maximum number of buckets. Changing this parameter causes a service restart. Only available for PostgreSQL 13+. Example: `10`.
        """
        pg_stat_statements_dot_track: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `all`, `none`, `top`. Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default is `top`.
        """
        temp_file_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        PostgreSQL temporary file limit in KiB, -1 for unlimited.
        """
        timezone: NotRequired[pulumi.Input[_builtins.str]]
        """
        PostgreSQL service timezone. Example: `Europe/Helsinki`.
        """
        track_activity_query_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies the number of bytes reserved to track the currently executing command for each active session. Changing this parameter causes a service restart. Example: `1024`.
        """
        track_commit_timestamp: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `off`, `on`. Record commit time of transactions. Changing this parameter causes a service restart.
        """
        track_functions: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `all`, `none`, `pl`. Enables tracking of function call counts and time used.
        """
        track_io_timing: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `off`, `on`. Enables timing of database I/O calls. The default is `off`. When on, it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms.
        """
        wal_sender_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        Terminate replication connections that are inactive for longer than this amount of time, in milliseconds. Setting this value to zero disables the timeout. Example: `60000`.
        """
        wal_writer_delay: NotRequired[pulumi.Input[_builtins.int]]
        """
        WAL flush interval in milliseconds. The default is `200`. Setting this parameter to a lower value may negatively impact performance. Example: `50`.
        """
elif False:
    PgPgUserConfigPgArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgPgUserConfigPgArgs:
    def __init__(__self__, *,
                 autovacuum_analyze_scale_factor: Optional[pulumi.Input[_builtins.float]] = None,
                 autovacuum_analyze_threshold: Optional[pulumi.Input[_builtins.int]] = None,
                 autovacuum_freeze_max_age: Optional[pulumi.Input[_builtins.int]] = None,
                 autovacuum_max_workers: Optional[pulumi.Input[_builtins.int]] = None,
                 autovacuum_naptime: Optional[pulumi.Input[_builtins.int]] = None,
                 autovacuum_vacuum_cost_delay: Optional[pulumi.Input[_builtins.int]] = None,
                 autovacuum_vacuum_cost_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 autovacuum_vacuum_scale_factor: Optional[pulumi.Input[_builtins.float]] = None,
                 autovacuum_vacuum_threshold: Optional[pulumi.Input[_builtins.int]] = None,
                 bgwriter_delay: Optional[pulumi.Input[_builtins.int]] = None,
                 bgwriter_flush_after: Optional[pulumi.Input[_builtins.int]] = None,
                 bgwriter_lru_maxpages: Optional[pulumi.Input[_builtins.int]] = None,
                 bgwriter_lru_multiplier: Optional[pulumi.Input[_builtins.float]] = None,
                 deadlock_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 default_toast_compression: Optional[pulumi.Input[_builtins.str]] = None,
                 idle_in_transaction_session_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 io_combine_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 io_max_combine_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 io_max_concurrency: Optional[pulumi.Input[_builtins.int]] = None,
                 io_method: Optional[pulumi.Input[_builtins.str]] = None,
                 io_workers: Optional[pulumi.Input[_builtins.int]] = None,
                 jit: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_autovacuum_min_duration: Optional[pulumi.Input[_builtins.int]] = None,
                 log_error_verbosity: Optional[pulumi.Input[_builtins.str]] = None,
                 log_line_prefix: Optional[pulumi.Input[_builtins.str]] = None,
                 log_min_duration_statement: Optional[pulumi.Input[_builtins.int]] = None,
                 log_temp_files: Optional[pulumi.Input[_builtins.int]] = None,
                 max_connections: Optional[pulumi.Input[_builtins.int]] = None,
                 max_files_per_process: Optional[pulumi.Input[_builtins.int]] = None,
                 max_locks_per_transaction: Optional[pulumi.Input[_builtins.int]] = None,
                 max_logical_replication_workers: Optional[pulumi.Input[_builtins.int]] = None,
                 max_parallel_workers: Optional[pulumi.Input[_builtins.int]] = None,
                 max_parallel_workers_per_gather: Optional[pulumi.Input[_builtins.int]] = None,
                 max_pred_locks_per_transaction: Optional[pulumi.Input[_builtins.int]] = None,
                 max_prepared_transactions: Optional[pulumi.Input[_builtins.int]] = None,
                 max_replication_slots: Optional[pulumi.Input[_builtins.int]] = None,
                 max_slot_wal_keep_size: Optional[pulumi.Input[_builtins.int]] = None,
                 max_stack_depth: Optional[pulumi.Input[_builtins.int]] = None,
                 max_standby_archive_delay: Optional[pulumi.Input[_builtins.int]] = None,
                 max_standby_streaming_delay: Optional[pulumi.Input[_builtins.int]] = None,
                 max_sync_workers_per_subscription: Optional[pulumi.Input[_builtins.int]] = None,
                 max_wal_senders: Optional[pulumi.Input[_builtins.int]] = None,
                 max_worker_processes: Optional[pulumi.Input[_builtins.int]] = None,
                 password_encryption: Optional[pulumi.Input[_builtins.str]] = None,
                 pg_partman_bgw_dot_interval: Optional[pulumi.Input[_builtins.int]] = None,
                 pg_partman_bgw_dot_role: Optional[pulumi.Input[_builtins.str]] = None,
                 pg_stat_monitor_dot_pgsm_enable_query_plan: Optional[pulumi.Input[_builtins.bool]] = None,
                 pg_stat_monitor_dot_pgsm_max_buckets: Optional[pulumi.Input[_builtins.int]] = None,
                 pg_stat_statements_dot_track: Optional[pulumi.Input[_builtins.str]] = None,
                 temp_file_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 timezone: Optional[pulumi.Input[_builtins.str]] = None,
                 track_activity_query_size: Optional[pulumi.Input[_builtins.int]] = None,
                 track_commit_timestamp: Optional[pulumi.Input[_builtins.str]] = None,
                 track_functions: Optional[pulumi.Input[_builtins.str]] = None,
                 track_io_timing: Optional[pulumi.Input[_builtins.str]] = None,
                 wal_sender_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 wal_writer_delay: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.float] autovacuum_analyze_scale_factor: Specifies a fraction of the table size to add to autovacuum*analyze*threshold when deciding whether to trigger an ANALYZE (e.g. `0.2` for 20% of the table size). The default is `0.2`.
        :param pulumi.Input[_builtins.int] autovacuum_analyze_threshold: Specifies the minimum number of inserted, updated or deleted tuples needed to trigger an ANALYZE in any one table. The default is `50`.
        :param pulumi.Input[_builtins.int] autovacuum_freeze_max_age: Specifies the maximum age (in transactions) that a table's pg_class.relfrozenxid field can attain before a VACUUM operation is forced to prevent transaction ID wraparound within the table. The system launches autovacuum processes to prevent wraparound even when autovacuum is otherwise disabled. Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] autovacuum_max_workers: Specifies the maximum number of autovacuum processes (other than the autovacuum launcher) that may be running at any one time. The default is `3`. Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] autovacuum_naptime: Specifies the minimum delay between autovacuum runs on any given database. The delay is measured in seconds. The default is `60`.
        :param pulumi.Input[_builtins.int] autovacuum_vacuum_cost_delay: Specifies the cost delay value that will be used in automatic VACUUM operations. If `-1` is specified, the regular vacuum*cost*delay value will be used. The default is `2` (upstream default).
        :param pulumi.Input[_builtins.int] autovacuum_vacuum_cost_limit: Specifies the cost limit value that will be used in automatic VACUUM operations. If `-1` is specified, the regular vacuum*cost*limit value will be used. The default is `-1` (upstream default).
        :param pulumi.Input[_builtins.float] autovacuum_vacuum_scale_factor: Specifies a fraction of the table size to add to autovacuum*vacuum*threshold when deciding whether to trigger a VACUUM (e.g. `0.2` for 20% of the table size). The default is `0.2`.
        :param pulumi.Input[_builtins.int] autovacuum_vacuum_threshold: Specifies the minimum number of updated or deleted tuples needed to trigger a VACUUM in any one table. The default is `50`.
        :param pulumi.Input[_builtins.int] bgwriter_delay: Specifies the delay between activity rounds for the background writer in milliseconds. The default is `200`. Example: `200`.
        :param pulumi.Input[_builtins.int] bgwriter_flush_after: Whenever more than bgwriter*flush*after bytes have been written by the background writer, attempt to force the OS to issue these writes to the underlying storage. Specified in kilobytes. Setting of 0 disables forced writeback. The default is `512`. Example: `512`.
        :param pulumi.Input[_builtins.int] bgwriter_lru_maxpages: In each round, no more than this many buffers will be written by the background writer. Setting this to zero disables background writing. The default is `100`. Example: `100`.
        :param pulumi.Input[_builtins.float] bgwriter_lru_multiplier: The average recent need for new buffers is multiplied by bgwriter*lru*multiplier to arrive at an estimate of the number that will be needed during the next round, (up to bgwriter*lru*maxpages). 1.0 represents a “just in time” policy of writing exactly the number of buffers predicted to be needed. Larger values provide some cushion against spikes in demand, while smaller values intentionally leave writes to be done by server processes. The default is `2.0`. Example: `2`.
        :param pulumi.Input[_builtins.int] deadlock_timeout: This is the amount of time, in milliseconds, to wait on a lock before checking to see if there is a deadlock condition. The default is `1000` (upstream default). Example: `1000`.
        :param pulumi.Input[_builtins.str] default_toast_compression: Enum: `lz4`, `pglz`. Specifies the default TOAST compression method for values of compressible columns. The default is `lz4`. Only available for PostgreSQL 14+.
        :param pulumi.Input[_builtins.int] idle_in_transaction_session_timeout: Time out sessions with open transactions after this number of milliseconds.
        :param pulumi.Input[_builtins.int] io_combine_limit: EXPERIMENTAL: Controls the largest I/O size in operations that combine I/O in 8kB units. Version 17 and up only. Default: `16`.
        :param pulumi.Input[_builtins.int] io_max_combine_limit: EXPERIMENTAL: Controls the largest I/O size in operations that combine I/O in 8kB units, and silently limits the user-settable parameter io*combine*limit. Version 18 and up only. Changing this parameter causes a service restart. Default: `16`.
        :param pulumi.Input[_builtins.int] io_max_concurrency: EXPERIMENTAL: Controls the maximum number of I/O operations that one process can execute simultaneously. Version 18 and up only. Changing this parameter causes a service restart. Default: `-1`.
        :param pulumi.Input[_builtins.str] io_method: Enum: `io_uring`, `sync`, `worker`. EXPERIMENTAL: Controls the maximum number of I/O operations that one process can execute simultaneously. Version 18 and up only. Changing this parameter causes a service restart. Default: `worker`.
        :param pulumi.Input[_builtins.int] io_workers: EXPERIMENTAL: Number of IO worker processes, for io_method=worker. Version 18 and up only. Changing this parameter causes a service restart. Default: `3`.
        :param pulumi.Input[_builtins.bool] jit: Controls system-wide use of Just-in-Time Compilation (JIT).
        :param pulumi.Input[_builtins.int] log_autovacuum_min_duration: Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one disables logging autovacuum actions. The default is `1000`.
        :param pulumi.Input[_builtins.str] log_error_verbosity: Enum: `DEFAULT`, `TERSE`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
        :param pulumi.Input[_builtins.str] log_line_prefix: Enum: `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
        :param pulumi.Input[_builtins.int] log_min_duration_statement: Log statements that take more than this number of milliseconds to run, -1 disables.
        :param pulumi.Input[_builtins.int] log_temp_files: Log statements for each temporary file created larger than this number of kilobytes, -1 disables.
        :param pulumi.Input[_builtins.int] max_connections: Sets the PostgreSQL maximum number of concurrent connections to the database server. This is a limited-release parameter. Contact your account team to confirm your eligibility. You cannot decrease this parameter value when set. For services with a read replica, first increase the read replica's value. After the change is applied to the replica, you can increase the primary service's value. Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] max_files_per_process: PostgreSQL maximum number of files that can be open per process. The default is `1000` (upstream default). Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] max_locks_per_transaction: PostgreSQL maximum locks per transaction. Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] max_logical_replication_workers: PostgreSQL maximum logical replication workers (taken from the pool of max*parallel*workers). The default is `4` (upstream default). Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] max_parallel_workers: Sets the maximum number of workers that the system can support for parallel queries. The default is `8` (upstream default).
        :param pulumi.Input[_builtins.int] max_parallel_workers_per_gather: Sets the maximum number of workers that can be started by a single Gather or Gather Merge node. The default is `2` (upstream default).
        :param pulumi.Input[_builtins.int] max_pred_locks_per_transaction: PostgreSQL maximum predicate locks per transaction. The default is `64` (upstream default). Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] max_prepared_transactions: PostgreSQL maximum prepared transactions. The default is `0`. Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] max_replication_slots: PostgreSQL maximum replication slots. The default is `20`. Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] max_slot_wal_keep_size: PostgreSQL maximum WAL size (MB) reserved for replication slots. If `-1` is specified, replication slots may retain an unlimited amount of WAL files. The default is `-1` (upstream default). wal*keep*size minimum WAL size setting takes precedence over this.
        :param pulumi.Input[_builtins.int] max_stack_depth: Maximum depth of the stack in bytes. The default is `2097152` (upstream default).
        :param pulumi.Input[_builtins.int] max_standby_archive_delay: Max standby archive delay in milliseconds. The default is `30000` (upstream default).
        :param pulumi.Input[_builtins.int] max_standby_streaming_delay: Max standby streaming delay in milliseconds. The default is `30000` (upstream default).
        :param pulumi.Input[_builtins.int] max_sync_workers_per_subscription: Maximum number of synchronization workers per subscription. The default is `2`.
        :param pulumi.Input[_builtins.int] max_wal_senders: PostgreSQL maximum WAL senders. The default is `20`. Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.int] max_worker_processes: Sets the maximum number of background processes that the system can support. The default is `8`. Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.str] password_encryption: Enum: `md5`, `scram-sha-256`. Chooses the algorithm for encrypting passwords.
        :param pulumi.Input[_builtins.int] pg_partman_bgw_dot_interval: Sets the time interval in seconds to run pg_partman's scheduled tasks. The default is `3600`. Example: `3600`.
        :param pulumi.Input[_builtins.str] pg_partman_bgw_dot_role: Controls which role to use for pg_partman's scheduled background tasks. Example: `myrolename`.
        :param pulumi.Input[_builtins.bool] pg_stat_monitor_dot_pgsm_enable_query_plan: Enables or disables query plan monitoring. Changing this parameter causes a service restart. Only available for PostgreSQL 13+.
        :param pulumi.Input[_builtins.int] pg_stat_monitor_dot_pgsm_max_buckets: Sets the maximum number of buckets. Changing this parameter causes a service restart. Only available for PostgreSQL 13+. Example: `10`.
        :param pulumi.Input[_builtins.str] pg_stat_statements_dot_track: Enum: `all`, `none`, `top`. Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default is `top`.
        :param pulumi.Input[_builtins.int] temp_file_limit: PostgreSQL temporary file limit in KiB, -1 for unlimited.
        :param pulumi.Input[_builtins.str] timezone: PostgreSQL service timezone. Example: `Europe/Helsinki`.
        :param pulumi.Input[_builtins.int] track_activity_query_size: Specifies the number of bytes reserved to track the currently executing command for each active session. Changing this parameter causes a service restart. Example: `1024`.
        :param pulumi.Input[_builtins.str] track_commit_timestamp: Enum: `off`, `on`. Record commit time of transactions. Changing this parameter causes a service restart.
        :param pulumi.Input[_builtins.str] track_functions: Enum: `all`, `none`, `pl`. Enables tracking of function call counts and time used.
        :param pulumi.Input[_builtins.str] track_io_timing: Enum: `off`, `on`. Enables timing of database I/O calls. The default is `off`. When on, it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms.
        :param pulumi.Input[_builtins.int] wal_sender_timeout: Terminate replication connections that are inactive for longer than this amount of time, in milliseconds. Setting this value to zero disables the timeout. Example: `60000`.
        :param pulumi.Input[_builtins.int] wal_writer_delay: WAL flush interval in milliseconds. The default is `200`. Setting this parameter to a lower value may negatively impact performance. Example: `50`.
        """
        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 io_combine_limit is not None:
            pulumi.set(__self__, "io_combine_limit", io_combine_limit)
        if io_max_combine_limit is not None:
            pulumi.set(__self__, "io_max_combine_limit", io_max_combine_limit)
        if io_max_concurrency is not None:
            pulumi.set(__self__, "io_max_concurrency", io_max_concurrency)
        if io_method is not None:
            pulumi.set(__self__, "io_method", io_method)
        if io_workers is not None:
            pulumi.set(__self__, "io_workers", io_workers)
        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_connections is not None:
            pulumi.set(__self__, "max_connections", max_connections)
        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_sync_workers_per_subscription is not None:
            pulumi.set(__self__, "max_sync_workers_per_subscription", max_sync_workers_per_subscription)
        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 password_encryption is not None:
            pulumi.set(__self__, "password_encryption", password_encryption)
        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)

    @_builtins.property
    @pulumi.getter(name="autovacuumAnalyzeScaleFactor")
    def autovacuum_analyze_scale_factor(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        Specifies a fraction of the table size to add to autovacuum*analyze*threshold when deciding whether to trigger an ANALYZE (e.g. `0.2` for 20% of the table size). The default is `0.2`.
        """
        return pulumi.get(self, "autovacuum_analyze_scale_factor")

    @autovacuum_analyze_scale_factor.setter
    def autovacuum_analyze_scale_factor(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "autovacuum_analyze_scale_factor", value)

    @_builtins.property
    @pulumi.getter(name="autovacuumAnalyzeThreshold")
    def autovacuum_analyze_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the minimum number of inserted, updated or deleted tuples needed to trigger an ANALYZE in any one table. The default is `50`.
        """
        return pulumi.get(self, "autovacuum_analyze_threshold")

    @autovacuum_analyze_threshold.setter
    def autovacuum_analyze_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "autovacuum_analyze_threshold", value)

    @_builtins.property
    @pulumi.getter(name="autovacuumFreezeMaxAge")
    def autovacuum_freeze_max_age(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the maximum age (in transactions) that a table's pg_class.relfrozenxid field can attain before a VACUUM operation is forced to prevent transaction ID wraparound within the table. The system launches autovacuum processes to prevent wraparound even when autovacuum is otherwise disabled. Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "autovacuum_freeze_max_age")

    @autovacuum_freeze_max_age.setter
    def autovacuum_freeze_max_age(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "autovacuum_freeze_max_age", value)

    @_builtins.property
    @pulumi.getter(name="autovacuumMaxWorkers")
    def autovacuum_max_workers(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the maximum number of autovacuum processes (other than the autovacuum launcher) that may be running at any one time. The default is `3`. Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "autovacuum_max_workers")

    @autovacuum_max_workers.setter
    def autovacuum_max_workers(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "autovacuum_max_workers", value)

    @_builtins.property
    @pulumi.getter(name="autovacuumNaptime")
    def autovacuum_naptime(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the minimum delay between autovacuum runs on any given database. The delay is measured in seconds. The default is `60`.
        """
        return pulumi.get(self, "autovacuum_naptime")

    @autovacuum_naptime.setter
    def autovacuum_naptime(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "autovacuum_naptime", value)

    @_builtins.property
    @pulumi.getter(name="autovacuumVacuumCostDelay")
    def autovacuum_vacuum_cost_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the cost delay value that will be used in automatic VACUUM operations. If `-1` is specified, the regular vacuum*cost*delay value will be used. The default is `2` (upstream default).
        """
        return pulumi.get(self, "autovacuum_vacuum_cost_delay")

    @autovacuum_vacuum_cost_delay.setter
    def autovacuum_vacuum_cost_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "autovacuum_vacuum_cost_delay", value)

    @_builtins.property
    @pulumi.getter(name="autovacuumVacuumCostLimit")
    def autovacuum_vacuum_cost_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the cost limit value that will be used in automatic VACUUM operations. If `-1` is specified, the regular vacuum*cost*limit value will be used. The default is `-1` (upstream default).
        """
        return pulumi.get(self, "autovacuum_vacuum_cost_limit")

    @autovacuum_vacuum_cost_limit.setter
    def autovacuum_vacuum_cost_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "autovacuum_vacuum_cost_limit", value)

    @_builtins.property
    @pulumi.getter(name="autovacuumVacuumScaleFactor")
    def autovacuum_vacuum_scale_factor(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        Specifies a fraction of the table size to add to autovacuum*vacuum*threshold when deciding whether to trigger a VACUUM (e.g. `0.2` for 20% of the table size). The default is `0.2`.
        """
        return pulumi.get(self, "autovacuum_vacuum_scale_factor")

    @autovacuum_vacuum_scale_factor.setter
    def autovacuum_vacuum_scale_factor(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "autovacuum_vacuum_scale_factor", value)

    @_builtins.property
    @pulumi.getter(name="autovacuumVacuumThreshold")
    def autovacuum_vacuum_threshold(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the minimum number of updated or deleted tuples needed to trigger a VACUUM in any one table. The default is `50`.
        """
        return pulumi.get(self, "autovacuum_vacuum_threshold")

    @autovacuum_vacuum_threshold.setter
    def autovacuum_vacuum_threshold(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "autovacuum_vacuum_threshold", value)

    @_builtins.property
    @pulumi.getter(name="bgwriterDelay")
    def bgwriter_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the delay between activity rounds for the background writer in milliseconds. The default is `200`. Example: `200`.
        """
        return pulumi.get(self, "bgwriter_delay")

    @bgwriter_delay.setter
    def bgwriter_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "bgwriter_delay", value)

    @_builtins.property
    @pulumi.getter(name="bgwriterFlushAfter")
    def bgwriter_flush_after(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Whenever more than bgwriter*flush*after bytes have been written by the background writer, attempt to force the OS to issue these writes to the underlying storage. Specified in kilobytes. Setting of 0 disables forced writeback. The default is `512`. Example: `512`.
        """
        return pulumi.get(self, "bgwriter_flush_after")

    @bgwriter_flush_after.setter
    def bgwriter_flush_after(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "bgwriter_flush_after", value)

    @_builtins.property
    @pulumi.getter(name="bgwriterLruMaxpages")
    def bgwriter_lru_maxpages(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        In each round, no more than this many buffers will be written by the background writer. Setting this to zero disables background writing. The default is `100`. Example: `100`.
        """
        return pulumi.get(self, "bgwriter_lru_maxpages")

    @bgwriter_lru_maxpages.setter
    def bgwriter_lru_maxpages(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "bgwriter_lru_maxpages", value)

    @_builtins.property
    @pulumi.getter(name="bgwriterLruMultiplier")
    def bgwriter_lru_multiplier(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        The average recent need for new buffers is multiplied by bgwriter*lru*multiplier to arrive at an estimate of the number that will be needed during the next round, (up to bgwriter*lru*maxpages). 1.0 represents a “just in time” policy of writing exactly the number of buffers predicted to be needed. Larger values provide some cushion against spikes in demand, while smaller values intentionally leave writes to be done by server processes. The default is `2.0`. Example: `2`.
        """
        return pulumi.get(self, "bgwriter_lru_multiplier")

    @bgwriter_lru_multiplier.setter
    def bgwriter_lru_multiplier(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "bgwriter_lru_multiplier", value)

    @_builtins.property
    @pulumi.getter(name="deadlockTimeout")
    def deadlock_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        This is the amount of time, in milliseconds, to wait on a lock before checking to see if there is a deadlock condition. The default is `1000` (upstream default). Example: `1000`.
        """
        return pulumi.get(self, "deadlock_timeout")

    @deadlock_timeout.setter
    def deadlock_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "deadlock_timeout", value)

    @_builtins.property
    @pulumi.getter(name="defaultToastCompression")
    def default_toast_compression(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `lz4`, `pglz`. Specifies the default TOAST compression method for values of compressible columns. The default is `lz4`. Only available for PostgreSQL 14+.
        """
        return pulumi.get(self, "default_toast_compression")

    @default_toast_compression.setter
    def default_toast_compression(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "default_toast_compression", value)

    @_builtins.property
    @pulumi.getter(name="idleInTransactionSessionTimeout")
    def idle_in_transaction_session_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Time out sessions with open transactions after this number of milliseconds.
        """
        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[_builtins.int]]):
        pulumi.set(self, "idle_in_transaction_session_timeout", value)

    @_builtins.property
    @pulumi.getter(name="ioCombineLimit")
    def io_combine_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        EXPERIMENTAL: Controls the largest I/O size in operations that combine I/O in 8kB units. Version 17 and up only. Default: `16`.
        """
        return pulumi.get(self, "io_combine_limit")

    @io_combine_limit.setter
    def io_combine_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "io_combine_limit", value)

    @_builtins.property
    @pulumi.getter(name="ioMaxCombineLimit")
    def io_max_combine_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        EXPERIMENTAL: Controls the largest I/O size in operations that combine I/O in 8kB units, and silently limits the user-settable parameter io*combine*limit. Version 18 and up only. Changing this parameter causes a service restart. Default: `16`.
        """
        return pulumi.get(self, "io_max_combine_limit")

    @io_max_combine_limit.setter
    def io_max_combine_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "io_max_combine_limit", value)

    @_builtins.property
    @pulumi.getter(name="ioMaxConcurrency")
    def io_max_concurrency(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        EXPERIMENTAL: Controls the maximum number of I/O operations that one process can execute simultaneously. Version 18 and up only. Changing this parameter causes a service restart. Default: `-1`.
        """
        return pulumi.get(self, "io_max_concurrency")

    @io_max_concurrency.setter
    def io_max_concurrency(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "io_max_concurrency", value)

    @_builtins.property
    @pulumi.getter(name="ioMethod")
    def io_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `io_uring`, `sync`, `worker`. EXPERIMENTAL: Controls the maximum number of I/O operations that one process can execute simultaneously. Version 18 and up only. Changing this parameter causes a service restart. Default: `worker`.
        """
        return pulumi.get(self, "io_method")

    @io_method.setter
    def io_method(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "io_method", value)

    @_builtins.property
    @pulumi.getter(name="ioWorkers")
    def io_workers(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        EXPERIMENTAL: Number of IO worker processes, for io_method=worker. Version 18 and up only. Changing this parameter causes a service restart. Default: `3`.
        """
        return pulumi.get(self, "io_workers")

    @io_workers.setter
    def io_workers(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "io_workers", value)

    @_builtins.property
    @pulumi.getter
    def jit(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Controls system-wide use of Just-in-Time Compilation (JIT).
        """
        return pulumi.get(self, "jit")

    @jit.setter
    def jit(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "jit", value)

    @_builtins.property
    @pulumi.getter(name="logAutovacuumMinDuration")
    def log_autovacuum_min_duration(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Causes each action executed by autovacuum to be logged if it ran for at least the specified number of milliseconds. Setting this to zero logs all autovacuum actions. Minus-one disables logging autovacuum actions. The default is `1000`.
        """
        return pulumi.get(self, "log_autovacuum_min_duration")

    @log_autovacuum_min_duration.setter
    def log_autovacuum_min_duration(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "log_autovacuum_min_duration", value)

    @_builtins.property
    @pulumi.getter(name="logErrorVerbosity")
    def log_error_verbosity(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `DEFAULT`, `TERSE`, `VERBOSE`. Controls the amount of detail written in the server log for each message that is logged.
        """
        return pulumi.get(self, "log_error_verbosity")

    @log_error_verbosity.setter
    def log_error_verbosity(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "log_error_verbosity", value)

    @_builtins.property
    @pulumi.getter(name="logLinePrefix")
    def log_line_prefix(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `'%m [%p] %q[user=%u,db=%d,app=%a] '`, `'%t [%p]: [%l-1] user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h '`, `'pid=%p,user=%u,db=%d,app=%a,client=%h,txid=%x,qid=%Q '`. Choose from one of the available log formats.
        """
        return pulumi.get(self, "log_line_prefix")

    @log_line_prefix.setter
    def log_line_prefix(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "log_line_prefix", value)

    @_builtins.property
    @pulumi.getter(name="logMinDurationStatement")
    def log_min_duration_statement(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Log statements that take more than this number of milliseconds to run, -1 disables.
        """
        return pulumi.get(self, "log_min_duration_statement")

    @log_min_duration_statement.setter
    def log_min_duration_statement(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "log_min_duration_statement", value)

    @_builtins.property
    @pulumi.getter(name="logTempFiles")
    def log_temp_files(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Log statements for each temporary file created larger than this number of kilobytes, -1 disables.
        """
        return pulumi.get(self, "log_temp_files")

    @log_temp_files.setter
    def log_temp_files(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "log_temp_files", value)

    @_builtins.property
    @pulumi.getter(name="maxConnections")
    def max_connections(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Sets the PostgreSQL maximum number of concurrent connections to the database server. This is a limited-release parameter. Contact your account team to confirm your eligibility. You cannot decrease this parameter value when set. For services with a read replica, first increase the read replica's value. After the change is applied to the replica, you can increase the primary service's value. Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "max_connections")

    @max_connections.setter
    def max_connections(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_connections", value)

    @_builtins.property
    @pulumi.getter(name="maxFilesPerProcess")
    def max_files_per_process(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL maximum number of files that can be open per process. The default is `1000` (upstream default). Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "max_files_per_process")

    @max_files_per_process.setter
    def max_files_per_process(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_files_per_process", value)

    @_builtins.property
    @pulumi.getter(name="maxLocksPerTransaction")
    def max_locks_per_transaction(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL maximum locks per transaction. Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "max_locks_per_transaction")

    @max_locks_per_transaction.setter
    def max_locks_per_transaction(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_locks_per_transaction", value)

    @_builtins.property
    @pulumi.getter(name="maxLogicalReplicationWorkers")
    def max_logical_replication_workers(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL maximum logical replication workers (taken from the pool of max*parallel*workers). The default is `4` (upstream default). Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "max_logical_replication_workers")

    @max_logical_replication_workers.setter
    def max_logical_replication_workers(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_logical_replication_workers", value)

    @_builtins.property
    @pulumi.getter(name="maxParallelWorkers")
    def max_parallel_workers(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Sets the maximum number of workers that the system can support for parallel queries. The default is `8` (upstream default).
        """
        return pulumi.get(self, "max_parallel_workers")

    @max_parallel_workers.setter
    def max_parallel_workers(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_parallel_workers", value)

    @_builtins.property
    @pulumi.getter(name="maxParallelWorkersPerGather")
    def max_parallel_workers_per_gather(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Sets the maximum number of workers that can be started by a single Gather or Gather Merge node. The default is `2` (upstream default).
        """
        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[_builtins.int]]):
        pulumi.set(self, "max_parallel_workers_per_gather", value)

    @_builtins.property
    @pulumi.getter(name="maxPredLocksPerTransaction")
    def max_pred_locks_per_transaction(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL maximum predicate locks per transaction. The default is `64` (upstream default). Changing this parameter causes a service restart.
        """
        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[_builtins.int]]):
        pulumi.set(self, "max_pred_locks_per_transaction", value)

    @_builtins.property
    @pulumi.getter(name="maxPreparedTransactions")
    def max_prepared_transactions(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL maximum prepared transactions. The default is `0`. Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "max_prepared_transactions")

    @max_prepared_transactions.setter
    def max_prepared_transactions(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_prepared_transactions", value)

    @_builtins.property
    @pulumi.getter(name="maxReplicationSlots")
    def max_replication_slots(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL maximum replication slots. The default is `20`. Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "max_replication_slots")

    @max_replication_slots.setter
    def max_replication_slots(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_replication_slots", value)

    @_builtins.property
    @pulumi.getter(name="maxSlotWalKeepSize")
    def max_slot_wal_keep_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL maximum WAL size (MB) reserved for replication slots. If `-1` is specified, replication slots may retain an unlimited amount of WAL files. The default is `-1` (upstream default). wal*keep*size minimum WAL size setting takes precedence over this.
        """
        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[_builtins.int]]):
        pulumi.set(self, "max_slot_wal_keep_size", value)

    @_builtins.property
    @pulumi.getter(name="maxStackDepth")
    def max_stack_depth(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum depth of the stack in bytes. The default is `2097152` (upstream default).
        """
        return pulumi.get(self, "max_stack_depth")

    @max_stack_depth.setter
    def max_stack_depth(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_stack_depth", value)

    @_builtins.property
    @pulumi.getter(name="maxStandbyArchiveDelay")
    def max_standby_archive_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Max standby archive delay in milliseconds. The default is `30000` (upstream default).
        """
        return pulumi.get(self, "max_standby_archive_delay")

    @max_standby_archive_delay.setter
    def max_standby_archive_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_standby_archive_delay", value)

    @_builtins.property
    @pulumi.getter(name="maxStandbyStreamingDelay")
    def max_standby_streaming_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Max standby streaming delay in milliseconds. The default is `30000` (upstream default).
        """
        return pulumi.get(self, "max_standby_streaming_delay")

    @max_standby_streaming_delay.setter
    def max_standby_streaming_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_standby_streaming_delay", value)

    @_builtins.property
    @pulumi.getter(name="maxSyncWorkersPerSubscription")
    def max_sync_workers_per_subscription(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum number of synchronization workers per subscription. The default is `2`.
        """
        return pulumi.get(self, "max_sync_workers_per_subscription")

    @max_sync_workers_per_subscription.setter
    def max_sync_workers_per_subscription(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_sync_workers_per_subscription", value)

    @_builtins.property
    @pulumi.getter(name="maxWalSenders")
    def max_wal_senders(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL maximum WAL senders. The default is `20`. Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "max_wal_senders")

    @max_wal_senders.setter
    def max_wal_senders(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_wal_senders", value)

    @_builtins.property
    @pulumi.getter(name="maxWorkerProcesses")
    def max_worker_processes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Sets the maximum number of background processes that the system can support. The default is `8`. Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "max_worker_processes")

    @max_worker_processes.setter
    def max_worker_processes(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_worker_processes", value)

    @_builtins.property
    @pulumi.getter(name="passwordEncryption")
    def password_encryption(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `md5`, `scram-sha-256`. Chooses the algorithm for encrypting passwords.
        """
        return pulumi.get(self, "password_encryption")

    @password_encryption.setter
    def password_encryption(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "password_encryption", value)

    @_builtins.property
    @pulumi.getter(name="pgPartmanBgwDotInterval")
    def pg_partman_bgw_dot_interval(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Sets the time interval in seconds to run pg_partman's scheduled tasks. The default is `3600`. Example: `3600`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "pg_partman_bgw_dot_interval", value)

    @_builtins.property
    @pulumi.getter(name="pgPartmanBgwDotRole")
    def pg_partman_bgw_dot_role(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Controls which role to use for pg_partman's scheduled background tasks. Example: `myrolename`.
        """
        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[_builtins.str]]):
        pulumi.set(self, "pg_partman_bgw_dot_role", value)

    @_builtins.property
    @pulumi.getter(name="pgStatMonitorDotPgsmEnableQueryPlan")
    def pg_stat_monitor_dot_pgsm_enable_query_plan(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enables or disables query plan monitoring. Changing this parameter causes a service restart. Only available for PostgreSQL 13+.
        """
        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[_builtins.bool]]):
        pulumi.set(self, "pg_stat_monitor_dot_pgsm_enable_query_plan", value)

    @_builtins.property
    @pulumi.getter(name="pgStatMonitorDotPgsmMaxBuckets")
    def pg_stat_monitor_dot_pgsm_max_buckets(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Sets the maximum number of buckets. Changing this parameter causes a service restart. Only available for PostgreSQL 13+. Example: `10`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "pg_stat_monitor_dot_pgsm_max_buckets", value)

    @_builtins.property
    @pulumi.getter(name="pgStatStatementsDotTrack")
    def pg_stat_statements_dot_track(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `all`, `none`, `top`. Controls which statements are counted. Specify top to track top-level statements (those issued directly by clients), all to also track nested statements (such as statements invoked within functions), or none to disable statement statistics collection. The default is `top`.
        """
        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[_builtins.str]]):
        pulumi.set(self, "pg_stat_statements_dot_track", value)

    @_builtins.property
    @pulumi.getter(name="tempFileLimit")
    def temp_file_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PostgreSQL temporary file limit in KiB, -1 for unlimited.
        """
        return pulumi.get(self, "temp_file_limit")

    @temp_file_limit.setter
    def temp_file_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "temp_file_limit", value)

    @_builtins.property
    @pulumi.getter
    def timezone(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PostgreSQL service timezone. Example: `Europe/Helsinki`.
        """
        return pulumi.get(self, "timezone")

    @timezone.setter
    def timezone(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "timezone", value)

    @_builtins.property
    @pulumi.getter(name="trackActivityQuerySize")
    def track_activity_query_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies the number of bytes reserved to track the currently executing command for each active session. Changing this parameter causes a service restart. Example: `1024`.
        """
        return pulumi.get(self, "track_activity_query_size")

    @track_activity_query_size.setter
    def track_activity_query_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "track_activity_query_size", value)

    @_builtins.property
    @pulumi.getter(name="trackCommitTimestamp")
    def track_commit_timestamp(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `off`, `on`. Record commit time of transactions. Changing this parameter causes a service restart.
        """
        return pulumi.get(self, "track_commit_timestamp")

    @track_commit_timestamp.setter
    def track_commit_timestamp(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "track_commit_timestamp", value)

    @_builtins.property
    @pulumi.getter(name="trackFunctions")
    def track_functions(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `all`, `none`, `pl`. Enables tracking of function call counts and time used.
        """
        return pulumi.get(self, "track_functions")

    @track_functions.setter
    def track_functions(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "track_functions", value)

    @_builtins.property
    @pulumi.getter(name="trackIoTiming")
    def track_io_timing(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `off`, `on`. Enables timing of database I/O calls. The default is `off`. When on, it will repeatedly query the operating system for the current time, which may cause significant overhead on some platforms.
        """
        return pulumi.get(self, "track_io_timing")

    @track_io_timing.setter
    def track_io_timing(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "track_io_timing", value)

    @_builtins.property
    @pulumi.getter(name="walSenderTimeout")
    def wal_sender_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Terminate replication connections that are inactive for longer than this amount of time, in milliseconds. Setting this value to zero disables the timeout. Example: `60000`.
        """
        return pulumi.get(self, "wal_sender_timeout")

    @wal_sender_timeout.setter
    def wal_sender_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "wal_sender_timeout", value)

    @_builtins.property
    @pulumi.getter(name="walWriterDelay")
    def wal_writer_delay(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        WAL flush interval in milliseconds. The default is `200`. Setting this parameter to a lower value may negatively impact performance. Example: `50`.
        """
        return pulumi.get(self, "wal_writer_delay")

    @wal_writer_delay.setter
    def wal_writer_delay(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "wal_writer_delay", value)


if not MYPY:
    class PgPgUserConfigPgQualstatsArgsDict(TypedDict):
        enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable / Disable pg_qualstats. Default: `false`.
        """
        min_err_estimate_num: NotRequired[pulumi.Input[_builtins.int]]
        """
        Error estimation num threshold to save quals. Default: `0`.
        """
        min_err_estimate_ratio: NotRequired[pulumi.Input[_builtins.int]]
        """
        Error estimation ratio threshold to save quals. Default: `0`.
        """
        track_constants: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable / Disable pg_qualstats constants tracking. Default: `true`.
        """
        track_pg_catalog: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Track quals on system catalogs too. Default: `false`.
        """
elif False:
    PgPgUserConfigPgQualstatsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgPgUserConfigPgQualstatsArgs:
    def __init__(__self__, *,
                 enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 min_err_estimate_num: Optional[pulumi.Input[_builtins.int]] = None,
                 min_err_estimate_ratio: Optional[pulumi.Input[_builtins.int]] = None,
                 track_constants: Optional[pulumi.Input[_builtins.bool]] = None,
                 track_pg_catalog: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] enabled: Enable / Disable pg_qualstats. Default: `false`.
        :param pulumi.Input[_builtins.int] min_err_estimate_num: Error estimation num threshold to save quals. Default: `0`.
        :param pulumi.Input[_builtins.int] min_err_estimate_ratio: Error estimation ratio threshold to save quals. Default: `0`.
        :param pulumi.Input[_builtins.bool] track_constants: Enable / Disable pg_qualstats constants tracking. Default: `true`.
        :param pulumi.Input[_builtins.bool] track_pg_catalog: Track quals on system catalogs too. Default: `false`.
        """
        if enabled is not None:
            warnings.warn("""This property is deprecated.""", DeprecationWarning)
            pulumi.log.warn("""enabled is deprecated: This property is deprecated.""")
        if enabled is not None:
            pulumi.set(__self__, "enabled", enabled)
        if min_err_estimate_num is not None:
            warnings.warn("""This property is deprecated.""", DeprecationWarning)
            pulumi.log.warn("""min_err_estimate_num is deprecated: This property is deprecated.""")
        if min_err_estimate_num is not None:
            pulumi.set(__self__, "min_err_estimate_num", min_err_estimate_num)
        if min_err_estimate_ratio is not None:
            warnings.warn("""This property is deprecated.""", DeprecationWarning)
            pulumi.log.warn("""min_err_estimate_ratio is deprecated: This property is deprecated.""")
        if min_err_estimate_ratio is not None:
            pulumi.set(__self__, "min_err_estimate_ratio", min_err_estimate_ratio)
        if track_constants is not None:
            warnings.warn("""This property is deprecated.""", DeprecationWarning)
            pulumi.log.warn("""track_constants is deprecated: This property is deprecated.""")
        if track_constants is not None:
            pulumi.set(__self__, "track_constants", track_constants)
        if track_pg_catalog is not None:
            warnings.warn("""This property is deprecated.""", DeprecationWarning)
            pulumi.log.warn("""track_pg_catalog is deprecated: This property is deprecated.""")
        if track_pg_catalog is not None:
            pulumi.set(__self__, "track_pg_catalog", track_pg_catalog)

    @_builtins.property
    @pulumi.getter
    @_utilities.deprecated("""This property is deprecated.""")
    def enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable / Disable pg_qualstats. Default: `false`.
        """
        return pulumi.get(self, "enabled")

    @enabled.setter
    def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "enabled", value)

    @_builtins.property
    @pulumi.getter(name="minErrEstimateNum")
    @_utilities.deprecated("""This property is deprecated.""")
    def min_err_estimate_num(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Error estimation num threshold to save quals. Default: `0`.
        """
        return pulumi.get(self, "min_err_estimate_num")

    @min_err_estimate_num.setter
    def min_err_estimate_num(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "min_err_estimate_num", value)

    @_builtins.property
    @pulumi.getter(name="minErrEstimateRatio")
    @_utilities.deprecated("""This property is deprecated.""")
    def min_err_estimate_ratio(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Error estimation ratio threshold to save quals. Default: `0`.
        """
        return pulumi.get(self, "min_err_estimate_ratio")

    @min_err_estimate_ratio.setter
    def min_err_estimate_ratio(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "min_err_estimate_ratio", value)

    @_builtins.property
    @pulumi.getter(name="trackConstants")
    @_utilities.deprecated("""This property is deprecated.""")
    def track_constants(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable / Disable pg_qualstats constants tracking. Default: `true`.
        """
        return pulumi.get(self, "track_constants")

    @track_constants.setter
    def track_constants(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "track_constants", value)

    @_builtins.property
    @pulumi.getter(name="trackPgCatalog")
    @_utilities.deprecated("""This property is deprecated.""")
    def track_pg_catalog(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Track quals on system catalogs too. Default: `false`.
        """
        return pulumi.get(self, "track_pg_catalog")

    @track_pg_catalog.setter
    def track_pg_catalog(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "track_pg_catalog", value)


if not MYPY:
    class PgPgUserConfigPgauditArgsDict(TypedDict):
        feature_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable pgaudit extension. When enabled, pgaudit extension will be automatically installed.Otherwise, extension will be uninstalled but auditing configurations will be preserved. Default: `false`.
        """
        log_catalog: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Specifies that session logging should be enabled in the case where all relations in a statement are in pg_catalog. Default: `true`.
        """
        log_client: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Specifies whether log messages will be visible to a client process such as psql. Default: `false`.
        """
        log_level: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `debug1`, `debug2`, `debug3`, `debug4`, `debug5`, `info`, `log`, `notice`, `warning`. Specifies the log level that will be used for log entries. Default: `log`.
        """
        log_max_string_length: NotRequired[pulumi.Input[_builtins.int]]
        """
        Crop parameters representation and whole statements if they exceed this threshold. A (default) value of -1 disable the truncation. Default: `-1`.
        """
        log_nested_statements: NotRequired[pulumi.Input[_builtins.bool]]
        """
        This GUC allows to turn off logging nested statements, that is, statements that are executed as part of another ExecutorRun. Default: `true`.
        """
        log_parameter: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Specifies that audit logging should include the parameters that were passed with the statement. Default: `false`.
        """
        log_parameter_max_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Specifies that parameter values longer than this setting (in bytes) should not be logged, but replaced with \\n\\n. Default: `0`.
        """
        log_relation: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Specifies whether session audit logging should create a separate log entry for each relation (TABLE, VIEW, etc.) referenced in a SELECT or DML statement. Default: `false`.
        """
        log_rows: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Log Rows. Default: `false`.
        """
        log_statement: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Specifies whether logging will include the statement text and parameters (if enabled). Default: `true`.
        """
        log_statement_once: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Specifies whether logging will include the statement text and parameters with the first log entry for a statement/substatement combination or with every entry. Default: `false`.
        """
        logs: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Specifies which classes of statements will be logged by session audit logging.
        """
        role: NotRequired[pulumi.Input[_builtins.str]]
        """
        Specifies the master role to use for object audit logging.
        """
elif False:
    PgPgUserConfigPgauditArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgPgUserConfigPgauditArgs:
    def __init__(__self__, *,
                 feature_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_catalog: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_client: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_level: Optional[pulumi.Input[_builtins.str]] = None,
                 log_max_string_length: Optional[pulumi.Input[_builtins.int]] = None,
                 log_nested_statements: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_parameter: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_parameter_max_size: Optional[pulumi.Input[_builtins.int]] = None,
                 log_relation: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_rows: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_statement: Optional[pulumi.Input[_builtins.bool]] = None,
                 log_statement_once: Optional[pulumi.Input[_builtins.bool]] = None,
                 logs: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 role: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.bool] feature_enabled: Enable pgaudit extension. When enabled, pgaudit extension will be automatically installed.Otherwise, extension will be uninstalled but auditing configurations will be preserved. Default: `false`.
        :param pulumi.Input[_builtins.bool] log_catalog: Specifies that session logging should be enabled in the case where all relations in a statement are in pg_catalog. Default: `true`.
        :param pulumi.Input[_builtins.bool] log_client: Specifies whether log messages will be visible to a client process such as psql. Default: `false`.
        :param pulumi.Input[_builtins.str] log_level: Enum: `debug1`, `debug2`, `debug3`, `debug4`, `debug5`, `info`, `log`, `notice`, `warning`. Specifies the log level that will be used for log entries. Default: `log`.
        :param pulumi.Input[_builtins.int] log_max_string_length: Crop parameters representation and whole statements if they exceed this threshold. A (default) value of -1 disable the truncation. Default: `-1`.
        :param pulumi.Input[_builtins.bool] log_nested_statements: This GUC allows to turn off logging nested statements, that is, statements that are executed as part of another ExecutorRun. Default: `true`.
        :param pulumi.Input[_builtins.bool] log_parameter: Specifies that audit logging should include the parameters that were passed with the statement. Default: `false`.
        :param pulumi.Input[_builtins.int] log_parameter_max_size: Specifies that parameter values longer than this setting (in bytes) should not be logged, but replaced with \\n\\n. Default: `0`.
        :param pulumi.Input[_builtins.bool] log_relation: Specifies whether session audit logging should create a separate log entry for each relation (TABLE, VIEW, etc.) referenced in a SELECT or DML statement. Default: `false`.
        :param pulumi.Input[_builtins.bool] log_rows: Log Rows. Default: `false`.
        :param pulumi.Input[_builtins.bool] log_statement: Specifies whether logging will include the statement text and parameters (if enabled). Default: `true`.
        :param pulumi.Input[_builtins.bool] log_statement_once: Specifies whether logging will include the statement text and parameters with the first log entry for a statement/substatement combination or with every entry. Default: `false`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] logs: Specifies which classes of statements will be logged by session audit logging.
        :param pulumi.Input[_builtins.str] role: Specifies the master role to use for object audit logging.
        """
        if feature_enabled is not None:
            pulumi.set(__self__, "feature_enabled", feature_enabled)
        if log_catalog is not None:
            pulumi.set(__self__, "log_catalog", log_catalog)
        if log_client is not None:
            pulumi.set(__self__, "log_client", log_client)
        if log_level is not None:
            pulumi.set(__self__, "log_level", log_level)
        if log_max_string_length is not None:
            pulumi.set(__self__, "log_max_string_length", log_max_string_length)
        if log_nested_statements is not None:
            pulumi.set(__self__, "log_nested_statements", log_nested_statements)
        if log_parameter is not None:
            pulumi.set(__self__, "log_parameter", log_parameter)
        if log_parameter_max_size is not None:
            pulumi.set(__self__, "log_parameter_max_size", log_parameter_max_size)
        if log_relation is not None:
            pulumi.set(__self__, "log_relation", log_relation)
        if log_rows is not None:
            pulumi.set(__self__, "log_rows", log_rows)
        if log_statement is not None:
            pulumi.set(__self__, "log_statement", log_statement)
        if log_statement_once is not None:
            pulumi.set(__self__, "log_statement_once", log_statement_once)
        if logs is not None:
            pulumi.set(__self__, "logs", logs)
        if role is not None:
            pulumi.set(__self__, "role", role)

    @_builtins.property
    @pulumi.getter(name="featureEnabled")
    def feature_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable pgaudit extension. When enabled, pgaudit extension will be automatically installed.Otherwise, extension will be uninstalled but auditing configurations will be preserved. Default: `false`.
        """
        return pulumi.get(self, "feature_enabled")

    @feature_enabled.setter
    def feature_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "feature_enabled", value)

    @_builtins.property
    @pulumi.getter(name="logCatalog")
    def log_catalog(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Specifies that session logging should be enabled in the case where all relations in a statement are in pg_catalog. Default: `true`.
        """
        return pulumi.get(self, "log_catalog")

    @log_catalog.setter
    def log_catalog(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "log_catalog", value)

    @_builtins.property
    @pulumi.getter(name="logClient")
    def log_client(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Specifies whether log messages will be visible to a client process such as psql. Default: `false`.
        """
        return pulumi.get(self, "log_client")

    @log_client.setter
    def log_client(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "log_client", value)

    @_builtins.property
    @pulumi.getter(name="logLevel")
    def log_level(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `debug1`, `debug2`, `debug3`, `debug4`, `debug5`, `info`, `log`, `notice`, `warning`. Specifies the log level that will be used for log entries. Default: `log`.
        """
        return pulumi.get(self, "log_level")

    @log_level.setter
    def log_level(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "log_level", value)

    @_builtins.property
    @pulumi.getter(name="logMaxStringLength")
    def log_max_string_length(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Crop parameters representation and whole statements if they exceed this threshold. A (default) value of -1 disable the truncation. Default: `-1`.
        """
        return pulumi.get(self, "log_max_string_length")

    @log_max_string_length.setter
    def log_max_string_length(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "log_max_string_length", value)

    @_builtins.property
    @pulumi.getter(name="logNestedStatements")
    def log_nested_statements(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        This GUC allows to turn off logging nested statements, that is, statements that are executed as part of another ExecutorRun. Default: `true`.
        """
        return pulumi.get(self, "log_nested_statements")

    @log_nested_statements.setter
    def log_nested_statements(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "log_nested_statements", value)

    @_builtins.property
    @pulumi.getter(name="logParameter")
    def log_parameter(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Specifies that audit logging should include the parameters that were passed with the statement. Default: `false`.
        """
        return pulumi.get(self, "log_parameter")

    @log_parameter.setter
    def log_parameter(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "log_parameter", value)

    @_builtins.property
    @pulumi.getter(name="logParameterMaxSize")
    def log_parameter_max_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Specifies that parameter values longer than this setting (in bytes) should not be logged, but replaced with \\n\\n. Default: `0`.
        """
        return pulumi.get(self, "log_parameter_max_size")

    @log_parameter_max_size.setter
    def log_parameter_max_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "log_parameter_max_size", value)

    @_builtins.property
    @pulumi.getter(name="logRelation")
    def log_relation(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Specifies whether session audit logging should create a separate log entry for each relation (TABLE, VIEW, etc.) referenced in a SELECT or DML statement. Default: `false`.
        """
        return pulumi.get(self, "log_relation")

    @log_relation.setter
    def log_relation(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "log_relation", value)

    @_builtins.property
    @pulumi.getter(name="logRows")
    def log_rows(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Log Rows. Default: `false`.
        """
        return pulumi.get(self, "log_rows")

    @log_rows.setter
    def log_rows(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "log_rows", value)

    @_builtins.property
    @pulumi.getter(name="logStatement")
    def log_statement(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Specifies whether logging will include the statement text and parameters (if enabled). Default: `true`.
        """
        return pulumi.get(self, "log_statement")

    @log_statement.setter
    def log_statement(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "log_statement", value)

    @_builtins.property
    @pulumi.getter(name="logStatementOnce")
    def log_statement_once(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Specifies whether logging will include the statement text and parameters with the first log entry for a statement/substatement combination or with every entry. Default: `false`.
        """
        return pulumi.get(self, "log_statement_once")

    @log_statement_once.setter
    def log_statement_once(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "log_statement_once", value)

    @_builtins.property
    @pulumi.getter
    def logs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Specifies which classes of statements will be logged by session audit logging.
        """
        return pulumi.get(self, "logs")

    @logs.setter
    def logs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "logs", value)

    @_builtins.property
    @pulumi.getter
    def role(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Specifies the master role to use for object audit logging.
        """
        return pulumi.get(self, "role")

    @role.setter
    def role(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "role", value)


if not MYPY:
    class PgPgUserConfigPgbouncerArgsDict(TypedDict):
        autodb_idle_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        If the automatically created database pools have been unused this many seconds, they are freed. If 0 then timeout is disabled. (seconds). Default: `3600`.
        """
        autodb_max_db_connections: NotRequired[pulumi.Input[_builtins.int]]
        """
        Do not allow more than this many server connections per database (regardless of user). Setting it to 0 means unlimited. Example: `0`.
        """
        autodb_pool_mode: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `session`, `statement`, `transaction`. PGBouncer pool mode. Default: `transaction`.
        """
        autodb_pool_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        If non-zero then create automatically a pool of that size per user when a pool doesn't exist. Default: `0`.
        """
        ignore_startup_parameters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        List of parameters to ignore when given in startup packet.
        """
        max_prepared_statements: NotRequired[pulumi.Input[_builtins.int]]
        """
        PgBouncer tracks protocol-level named prepared statements related commands sent by the client in transaction and statement pooling modes when max*prepared*statements is set to a non-zero value. Setting it to 0 disables prepared statements. max*prepared*statements defaults to 100, and its maximum is 3000. Default: `100`.
        """
        min_pool_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Add more server connections to pool if below this number. Improves behavior when usual load comes suddenly back after period of total inactivity. The value is effectively capped at the pool size. Default: `0`.
        """
        server_idle_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        If a server connection has been idle more than this many seconds it will be dropped. If 0 then timeout is disabled. (seconds). Default: `600`.
        """
        server_lifetime: NotRequired[pulumi.Input[_builtins.int]]
        """
        The pooler will close an unused server connection that has been connected longer than this. (seconds). Default: `3600`.
        """
        server_reset_query_always: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Run server*reset*query (DISCARD ALL) in all pooling modes. Default: `false`.
        """
elif False:
    PgPgUserConfigPgbouncerArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgPgUserConfigPgbouncerArgs:
    def __init__(__self__, *,
                 autodb_idle_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 autodb_max_db_connections: Optional[pulumi.Input[_builtins.int]] = None,
                 autodb_pool_mode: Optional[pulumi.Input[_builtins.str]] = None,
                 autodb_pool_size: Optional[pulumi.Input[_builtins.int]] = None,
                 ignore_startup_parameters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 max_prepared_statements: Optional[pulumi.Input[_builtins.int]] = None,
                 min_pool_size: Optional[pulumi.Input[_builtins.int]] = None,
                 server_idle_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 server_lifetime: Optional[pulumi.Input[_builtins.int]] = None,
                 server_reset_query_always: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.int] autodb_idle_timeout: If the automatically created database pools have been unused this many seconds, they are freed. If 0 then timeout is disabled. (seconds). Default: `3600`.
        :param pulumi.Input[_builtins.int] autodb_max_db_connections: Do not allow more than this many server connections per database (regardless of user). Setting it to 0 means unlimited. Example: `0`.
        :param pulumi.Input[_builtins.str] autodb_pool_mode: Enum: `session`, `statement`, `transaction`. PGBouncer pool mode. Default: `transaction`.
        :param pulumi.Input[_builtins.int] autodb_pool_size: If non-zero then create automatically a pool of that size per user when a pool doesn't exist. Default: `0`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ignore_startup_parameters: List of parameters to ignore when given in startup packet.
        :param pulumi.Input[_builtins.int] max_prepared_statements: PgBouncer tracks protocol-level named prepared statements related commands sent by the client in transaction and statement pooling modes when max*prepared*statements is set to a non-zero value. Setting it to 0 disables prepared statements. max*prepared*statements defaults to 100, and its maximum is 3000. Default: `100`.
        :param pulumi.Input[_builtins.int] min_pool_size: Add more server connections to pool if below this number. Improves behavior when usual load comes suddenly back after period of total inactivity. The value is effectively capped at the pool size. Default: `0`.
        :param pulumi.Input[_builtins.int] server_idle_timeout: If a server connection has been idle more than this many seconds it will be dropped. If 0 then timeout is disabled. (seconds). Default: `600`.
        :param pulumi.Input[_builtins.int] server_lifetime: The pooler will close an unused server connection that has been connected longer than this. (seconds). Default: `3600`.
        :param pulumi.Input[_builtins.bool] server_reset_query_always: Run server*reset*query (DISCARD ALL) in all pooling modes. Default: `false`.
        """
        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 max_prepared_statements is not None:
            pulumi.set(__self__, "max_prepared_statements", max_prepared_statements)
        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)

    @_builtins.property
    @pulumi.getter(name="autodbIdleTimeout")
    def autodb_idle_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        If the automatically created database pools have been unused this many seconds, they are freed. If 0 then timeout is disabled. (seconds). Default: `3600`.
        """
        return pulumi.get(self, "autodb_idle_timeout")

    @autodb_idle_timeout.setter
    def autodb_idle_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "autodb_idle_timeout", value)

    @_builtins.property
    @pulumi.getter(name="autodbMaxDbConnections")
    def autodb_max_db_connections(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Do not allow more than this many server connections per database (regardless of user). Setting it to 0 means unlimited. Example: `0`.
        """
        return pulumi.get(self, "autodb_max_db_connections")

    @autodb_max_db_connections.setter
    def autodb_max_db_connections(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "autodb_max_db_connections", value)

    @_builtins.property
    @pulumi.getter(name="autodbPoolMode")
    def autodb_pool_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `session`, `statement`, `transaction`. PGBouncer pool mode. Default: `transaction`.
        """
        return pulumi.get(self, "autodb_pool_mode")

    @autodb_pool_mode.setter
    def autodb_pool_mode(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "autodb_pool_mode", value)

    @_builtins.property
    @pulumi.getter(name="autodbPoolSize")
    def autodb_pool_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        If non-zero then create automatically a pool of that size per user when a pool doesn't exist. Default: `0`.
        """
        return pulumi.get(self, "autodb_pool_size")

    @autodb_pool_size.setter
    def autodb_pool_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "autodb_pool_size", value)

    @_builtins.property
    @pulumi.getter(name="ignoreStartupParameters")
    def ignore_startup_parameters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        List of parameters to ignore when given in startup packet.
        """
        return pulumi.get(self, "ignore_startup_parameters")

    @ignore_startup_parameters.setter
    def ignore_startup_parameters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "ignore_startup_parameters", value)

    @_builtins.property
    @pulumi.getter(name="maxPreparedStatements")
    def max_prepared_statements(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        PgBouncer tracks protocol-level named prepared statements related commands sent by the client in transaction and statement pooling modes when max*prepared*statements is set to a non-zero value. Setting it to 0 disables prepared statements. max*prepared*statements defaults to 100, and its maximum is 3000. Default: `100`.
        """
        return pulumi.get(self, "max_prepared_statements")

    @max_prepared_statements.setter
    def max_prepared_statements(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_prepared_statements", value)

    @_builtins.property
    @pulumi.getter(name="minPoolSize")
    def min_pool_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Add more server connections to pool if below this number. Improves behavior when usual load comes suddenly back after period of total inactivity. The value is effectively capped at the pool size. Default: `0`.
        """
        return pulumi.get(self, "min_pool_size")

    @min_pool_size.setter
    def min_pool_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "min_pool_size", value)

    @_builtins.property
    @pulumi.getter(name="serverIdleTimeout")
    def server_idle_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        If a server connection has been idle more than this many seconds it will be dropped. If 0 then timeout is disabled. (seconds). Default: `600`.
        """
        return pulumi.get(self, "server_idle_timeout")

    @server_idle_timeout.setter
    def server_idle_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "server_idle_timeout", value)

    @_builtins.property
    @pulumi.getter(name="serverLifetime")
    def server_lifetime(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The pooler will close an unused server connection that has been connected longer than this. (seconds). Default: `3600`.
        """
        return pulumi.get(self, "server_lifetime")

    @server_lifetime.setter
    def server_lifetime(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "server_lifetime", value)

    @_builtins.property
    @pulumi.getter(name="serverResetQueryAlways")
    def server_reset_query_always(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Run server*reset*query (DISCARD ALL) in all pooling modes. Default: `false`.
        """
        return pulumi.get(self, "server_reset_query_always")

    @server_reset_query_always.setter
    def server_reset_query_always(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "server_reset_query_always", value)


if not MYPY:
    class PgPgUserConfigPglookoutArgsDict(TypedDict):
        max_failover_replication_time_lag: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of seconds of master unavailability before triggering database failover to standby. Default: `60`.
        """
elif False:
    PgPgUserConfigPglookoutArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgPgUserConfigPglookoutArgs:
    def __init__(__self__, *,
                 max_failover_replication_time_lag: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.int] max_failover_replication_time_lag: Number of seconds of master unavailability before triggering database failover to standby. Default: `60`.
        """
        if max_failover_replication_time_lag is not None:
            pulumi.set(__self__, "max_failover_replication_time_lag", max_failover_replication_time_lag)

    @_builtins.property
    @pulumi.getter(name="maxFailoverReplicationTimeLag")
    def max_failover_replication_time_lag(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of seconds of master unavailability before triggering database failover to standby. Default: `60`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "max_failover_replication_time_lag", value)


if not MYPY:
    class PgPgUserConfigPrivateAccessArgsDict(TypedDict):
        pg: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to pg with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        pgbouncer: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to pgbouncer with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
elif False:
    PgPgUserConfigPrivateAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgPgUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 pg: Optional[pulumi.Input[_builtins.bool]] = None,
                 pgbouncer: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] pg: Allow clients to connect to pg with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] pgbouncer: Allow clients to connect to pgbouncer with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        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)

    @_builtins.property
    @pulumi.getter
    def pg(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to pg with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "pg")

    @pg.setter
    def pg(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "pg", value)

    @_builtins.property
    @pulumi.getter
    def pgbouncer(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to pgbouncer with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "pgbouncer")

    @pgbouncer.setter
    def pgbouncer(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "pgbouncer", value)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "prometheus", value)


if not MYPY:
    class PgPgUserConfigPrivatelinkAccessArgsDict(TypedDict):
        pg: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable pg.
        """
        pgbouncer: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable pgbouncer.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable prometheus.
        """
elif False:
    PgPgUserConfigPrivatelinkAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgPgUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 pg: Optional[pulumi.Input[_builtins.bool]] = None,
                 pgbouncer: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] pg: Enable pg.
        :param pulumi.Input[_builtins.bool] pgbouncer: Enable pgbouncer.
        :param pulumi.Input[_builtins.bool] prometheus: Enable prometheus.
        """
        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)

    @_builtins.property
    @pulumi.getter
    def pg(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable pg.
        """
        return pulumi.get(self, "pg")

    @pg.setter
    def pg(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "pg", value)

    @_builtins.property
    @pulumi.getter
    def pgbouncer(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable pgbouncer.
        """
        return pulumi.get(self, "pgbouncer")

    @pgbouncer.setter
    def pgbouncer(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "pgbouncer", value)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable prometheus.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "prometheus", value)


if not MYPY:
    class PgPgUserConfigPublicAccessArgsDict(TypedDict):
        pg: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to pg from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        pgbouncer: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to pgbouncer from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
elif False:
    PgPgUserConfigPublicAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgPgUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 pg: Optional[pulumi.Input[_builtins.bool]] = None,
                 pgbouncer: Optional[pulumi.Input[_builtins.bool]] = None,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] pg: Allow clients to connect to pg from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] pgbouncer: Allow clients to connect to pgbouncer from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        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)

    @_builtins.property
    @pulumi.getter
    def pg(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to pg from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "pg")

    @pg.setter
    def pg(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "pg", value)

    @_builtins.property
    @pulumi.getter
    def pgbouncer(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to pgbouncer from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "pgbouncer")

    @pgbouncer.setter
    def pgbouncer(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "pgbouncer", value)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "prometheus", value)


if not MYPY:
    class PgPgUserConfigTimescaledbArgsDict(TypedDict):
        max_background_workers: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of background workers for timescaledb operations. You should configure this setting to the sum of your number of databases and the total number of concurrent background workers you want running at any given point in time. Changing this parameter causes a service restart. Default: `16`.
        """
elif False:
    PgPgUserConfigTimescaledbArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgPgUserConfigTimescaledbArgs:
    def __init__(__self__, *,
                 max_background_workers: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.int] max_background_workers: The number of background workers for timescaledb operations. You should configure this setting to the sum of your number of databases and the total number of concurrent background workers you want running at any given point in time. Changing this parameter causes a service restart. Default: `16`.
        """
        if max_background_workers is not None:
            pulumi.set(__self__, "max_background_workers", max_background_workers)

    @_builtins.property
    @pulumi.getter(name="maxBackgroundWorkers")
    def max_background_workers(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of background workers for timescaledb operations. You should configure this setting to the sum of your number of databases and the total number of concurrent background workers you want running at any given point in time. Changing this parameter causes a service restart. Default: `16`.
        """
        return pulumi.get(self, "max_background_workers")

    @max_background_workers.setter
    def max_background_workers(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_background_workers", value)


if not MYPY:
    class PgServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration. The possible values are `read_replica` and `disaster_recovery`.
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    PgServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration. The possible values are `read_replica` and `disaster_recovery`.
        :param pulumi.Input[_builtins.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)

    @_builtins.property
    @pulumi.getter(name="integrationType")
    def integration_type(self) -> pulumi.Input[_builtins.str]:
        """
        Type of the service integration. The possible values are `read_replica` and `disaster_recovery`.
        """
        return pulumi.get(self, "integration_type")

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "integration_type", value)

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class PgTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    PgTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[_builtins.str],
                 value: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] key: Service tag key
        :param pulumi.Input[_builtins.str] value: Service tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def key(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "key", value)

    @_builtins.property
    @pulumi.getter
    def value(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag value
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "value", value)


if not MYPY:
    class PgTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    PgTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class PgTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

    @email.setter
    def email(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "email", value)


if not MYPY:
    class ProjectTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Project tag key.
        """
        value: pulumi.Input[_builtins.str]
        """
        Project tag value.
        """
elif False:
    ProjectTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ProjectTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[_builtins.str],
                 value: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] key: Project tag key.
        :param pulumi.Input[_builtins.str] value: Project tag value.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def key(self) -> pulumi.Input[_builtins.str]:
        """
        Project tag key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "key", value)

    @_builtins.property
    @pulumi.getter
    def value(self) -> pulumi.Input[_builtins.str]:
        """
        Project tag value.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "value", value)


if not MYPY:
    class RedisComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    RedisComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RedisComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

    @_builtins.property
    @pulumi.getter
    def component(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Service component name
        """
        return pulumi.get(self, "component")

    @component.setter
    def component(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "component", value)

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

    @connection_uri.setter
    def connection_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "connection_uri", value)

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_authentication_method", value)

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

    @kafka_ssl_ca.setter
    def kafka_ssl_ca(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_ssl_ca", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def route(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Network access route
        """
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "route", value)

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ssl", value)

    @_builtins.property
    @pulumi.getter
    def usage(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        DNS usage name
        """
        return pulumi.get(self, "usage")

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "usage", value)


if not MYPY:
    class RedisRedisArgsDict(TypedDict):
        password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Redis password.
        """
        replica_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Redis replica server URI.
        """
        slave_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Redis slave server URIs.
        """
        uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Redis server URIs.
        """
elif False:
    RedisRedisArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RedisRedisArgs:
    def __init__(__self__, *,
                 password: Optional[pulumi.Input[_builtins.str]] = None,
                 replica_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 slave_uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[_builtins.str] password: Redis password.
        :param pulumi.Input[_builtins.str] replica_uri: Redis replica server URI.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] slave_uris: Redis slave server URIs.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uris: Redis server URIs.
        """
        if password is not None:
            pulumi.set(__self__, "password", password)
        if replica_uri is not None:
            pulumi.set(__self__, "replica_uri", replica_uri)
        if slave_uris is not None:
            pulumi.set(__self__, "slave_uris", slave_uris)
        if uris is not None:
            pulumi.set(__self__, "uris", uris)

    @_builtins.property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Redis password.
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "password", value)

    @_builtins.property
    @pulumi.getter(name="replicaUri")
    def replica_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Redis replica server URI.
        """
        return pulumi.get(self, "replica_uri")

    @replica_uri.setter
    def replica_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "replica_uri", value)

    @_builtins.property
    @pulumi.getter(name="slaveUris")
    def slave_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Redis slave server URIs.
        """
        return pulumi.get(self, "slave_uris")

    @slave_uris.setter
    def slave_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "slave_uris", value)

    @_builtins.property
    @pulumi.getter
    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Redis server URIs.
        """
        return pulumi.get(self, "uris")

    @uris.setter
    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "uris", value)


if not MYPY:
    class RedisRedisUserConfigArgsDict(TypedDict):
        additional_backup_regions: NotRequired[pulumi.Input[_builtins.str]]
        """
        Additional Cloud Regions for Backup Replication.
        """
        backup_hour: NotRequired[pulumi.Input[_builtins.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. Example: `3`.
        """
        backup_minute: NotRequired[pulumi.Input[_builtins.int]]
        """
        The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed. Example: `30`.
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['RedisRedisUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        migration: NotRequired[pulumi.Input['RedisRedisUserConfigMigrationArgsDict']]
        """
        Migrate data from existing server
        """
        private_access: NotRequired[pulumi.Input['RedisRedisUserConfigPrivateAccessArgsDict']]
        """
        Allow access to selected service ports from private networks
        """
        privatelink_access: NotRequired[pulumi.Input['RedisRedisUserConfigPrivatelinkAccessArgsDict']]
        """
        Allow access to selected service components through Privatelink
        """
        project_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        public_access: NotRequired[pulumi.Input['RedisRedisUserConfigPublicAccessArgsDict']]
        """
        Allow access to selected service ports from the public Internet
        """
        recovery_basebackup_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of the basebackup to restore in forked service. Example: `backup-20191112t091354293891z`.
        """
        redis_acl_channels_default: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `allchannels`, `resetchannels`. Determines default pub/sub channels' ACL for new users if ACL is not supplied. When this option is not defined, all_channels is assumed to keep backward compatibility. This option doesn't affect Redis configuration acl-pubsub-default.
        """
        redis_io_threads: NotRequired[pulumi.Input[_builtins.int]]
        """
        Set Redis IO thread count. Changing this will cause a restart of the Redis service. Example: `1`.
        """
        redis_lfu_decay_time: NotRequired[pulumi.Input[_builtins.int]]
        """
        LFU maxmemory-policy counter decay time in minutes. Default: `1`.
        """
        redis_lfu_log_factor: NotRequired[pulumi.Input[_builtins.int]]
        """
        Counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory-policies. Default: `10`.
        """
        redis_maxmemory_policy: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `allkeys-lfu`, `allkeys-lru`, `allkeys-random`, `noeviction`, `volatile-lfu`, `volatile-lru`, `volatile-random`, `volatile-ttl`. Redis maxmemory-policy. Default: `noeviction`.
        """
        redis_notify_keyspace_events: NotRequired[pulumi.Input[_builtins.str]]
        """
        Set notify-keyspace-events option.
        """
        redis_number_of_databases: NotRequired[pulumi.Input[_builtins.int]]
        """
        Set number of Redis databases. Changing this will cause a restart of the Redis service. Example: `16`.
        """
        redis_persistence: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `off`, `rdb`. When persistence is `rdb`, Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to the backup schedule for backup purposes. When persistence is `off`, no RDB dumps or backups are done, so data can be lost at any moment if the service is restarted for any reason, or if the service is powered off. Also, the service can't be forked.
        """
        redis_pubsub_client_output_buffer_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        Set output buffer limit for pub / sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan. Example: `64`.
        """
        redis_ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Require SSL to access Redis. Default: `true`.
        """
        redis_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        Redis idle connection timeout in seconds. Default: `300`.
        """
        redis_version: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `7.0`, and newer. Redis major version.
        """
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        service_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
elif False:
    RedisRedisUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RedisRedisUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[_builtins.str]] = None,
                 backup_hour: Optional[pulumi.Input[_builtins.int]] = None,
                 backup_minute: Optional[pulumi.Input[_builtins.int]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['RedisRedisUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]] = None,
                 public_access: Optional[pulumi.Input['RedisRedisUserConfigPublicAccessArgs']] = None,
                 recovery_basebackup_name: Optional[pulumi.Input[_builtins.str]] = None,
                 redis_acl_channels_default: Optional[pulumi.Input[_builtins.str]] = None,
                 redis_io_threads: Optional[pulumi.Input[_builtins.int]] = None,
                 redis_lfu_decay_time: Optional[pulumi.Input[_builtins.int]] = None,
                 redis_lfu_log_factor: Optional[pulumi.Input[_builtins.int]] = None,
                 redis_maxmemory_policy: Optional[pulumi.Input[_builtins.str]] = None,
                 redis_notify_keyspace_events: Optional[pulumi.Input[_builtins.str]] = None,
                 redis_number_of_databases: Optional[pulumi.Input[_builtins.int]] = None,
                 redis_persistence: Optional[pulumi.Input[_builtins.str]] = None,
                 redis_pubsub_client_output_buffer_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 redis_ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 redis_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 redis_version: Optional[pulumi.Input[_builtins.str]] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 service_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[_builtins.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. Example: `3`.
        :param pulumi.Input[_builtins.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. Example: `30`.
        :param pulumi.Input[Sequence[pulumi.Input['RedisRedisUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input['RedisRedisUserConfigMigrationArgs'] migration: Migrate data from existing server
        :param pulumi.Input['RedisRedisUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks
        :param pulumi.Input['RedisRedisUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink
        :param pulumi.Input[_builtins.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. Example: `anotherprojectname`.
        :param pulumi.Input['RedisRedisUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
        :param pulumi.Input[_builtins.str] recovery_basebackup_name: Name of the basebackup to restore in forked service. Example: `backup-20191112t091354293891z`.
        :param pulumi.Input[_builtins.str] redis_acl_channels_default: Enum: `allchannels`, `resetchannels`. Determines default pub/sub channels' ACL for new users if ACL is not supplied. When this option is not defined, all_channels is assumed to keep backward compatibility. This option doesn't affect Redis configuration acl-pubsub-default.
        :param pulumi.Input[_builtins.int] redis_io_threads: Set Redis IO thread count. Changing this will cause a restart of the Redis service. Example: `1`.
        :param pulumi.Input[_builtins.int] redis_lfu_decay_time: LFU maxmemory-policy counter decay time in minutes. Default: `1`.
        :param pulumi.Input[_builtins.int] redis_lfu_log_factor: Counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory-policies. Default: `10`.
        :param pulumi.Input[_builtins.str] redis_maxmemory_policy: Enum: `allkeys-lfu`, `allkeys-lru`, `allkeys-random`, `noeviction`, `volatile-lfu`, `volatile-lru`, `volatile-random`, `volatile-ttl`. Redis maxmemory-policy. Default: `noeviction`.
        :param pulumi.Input[_builtins.str] redis_notify_keyspace_events: Set notify-keyspace-events option.
        :param pulumi.Input[_builtins.int] redis_number_of_databases: Set number of Redis databases. Changing this will cause a restart of the Redis service. Example: `16`.
        :param pulumi.Input[_builtins.str] redis_persistence: Enum: `off`, `rdb`. When persistence is `rdb`, Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to the backup schedule for backup purposes. When persistence is `off`, no RDB dumps or backups are done, so data can be lost at any moment if the service is restarted for any reason, or if the service is powered off. Also, the service can't be forked.
        :param pulumi.Input[_builtins.int] redis_pubsub_client_output_buffer_limit: Set output buffer limit for pub / sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan. Example: `64`.
        :param pulumi.Input[_builtins.bool] redis_ssl: Require SSL to access Redis. Default: `true`.
        :param pulumi.Input[_builtins.int] redis_timeout: Redis idle connection timeout in seconds. Default: `300`.
        :param pulumi.Input[_builtins.str] redis_version: Enum: `7.0`, and newer. Redis major version.
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input[_builtins.str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        :param pulumi.Input[_builtins.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 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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `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 redis_version is not None:
            pulumi.set(__self__, "redis_version", redis_version)
        if service_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        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)

    @_builtins.property
    @pulumi.getter(name="additionalBackupRegions")
    def additional_backup_regions(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @_builtins.property
    @pulumi.getter(name="backupHour")
    def backup_hour(self) -> Optional[pulumi.Input[_builtins.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. Example: `3`.
        """
        return pulumi.get(self, "backup_hour")

    @backup_hour.setter
    def backup_hour(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "backup_hour", value)

    @_builtins.property
    @pulumi.getter(name="backupMinute")
    def backup_minute(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed. Example: `30`.
        """
        return pulumi.get(self, "backup_minute")

    @backup_minute.setter
    def backup_minute(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "backup_minute", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RedisRedisUserConfigIpFilterObjectArgs']]]]:
        """
        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['RedisRedisUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "ip_filters", value)

    @_builtins.property
    @pulumi.getter
    def migration(self) -> Optional[pulumi.Input['RedisRedisUserConfigMigrationArgs']]:
        """
        Migrate data from existing server
        """
        return pulumi.get(self, "migration")

    @migration.setter
    def migration(self, value: Optional[pulumi.Input['RedisRedisUserConfigMigrationArgs']]):
        pulumi.set(self, "migration", value)

    @_builtins.property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['RedisRedisUserConfigPrivateAccessArgs']]:
        """
        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['RedisRedisUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @_builtins.property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['RedisRedisUserConfigPrivatelinkAccessArgs']]:
        """
        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['RedisRedisUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)

    @_builtins.property
    @pulumi.getter(name="projectToForkFrom")
    def project_to_fork_from(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        return pulumi.get(self, "project_to_fork_from")

    @project_to_fork_from.setter
    def project_to_fork_from(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "project_to_fork_from", value)

    @_builtins.property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['RedisRedisUserConfigPublicAccessArgs']]:
        """
        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['RedisRedisUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

    @_builtins.property
    @pulumi.getter(name="recoveryBasebackupName")
    def recovery_basebackup_name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of the basebackup to restore in forked service. Example: `backup-20191112t091354293891z`.
        """
        return pulumi.get(self, "recovery_basebackup_name")

    @recovery_basebackup_name.setter
    def recovery_basebackup_name(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "recovery_basebackup_name", value)

    @_builtins.property
    @pulumi.getter(name="redisAclChannelsDefault")
    def redis_acl_channels_default(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `allchannels`, `resetchannels`. Determines default pub/sub channels' ACL for new users if ACL is not supplied. When this option is not defined, all_channels is assumed to keep backward compatibility. This option doesn't affect Redis configuration acl-pubsub-default.
        """
        return pulumi.get(self, "redis_acl_channels_default")

    @redis_acl_channels_default.setter
    def redis_acl_channels_default(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "redis_acl_channels_default", value)

    @_builtins.property
    @pulumi.getter(name="redisIoThreads")
    def redis_io_threads(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Set Redis IO thread count. Changing this will cause a restart of the Redis service. Example: `1`.
        """
        return pulumi.get(self, "redis_io_threads")

    @redis_io_threads.setter
    def redis_io_threads(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "redis_io_threads", value)

    @_builtins.property
    @pulumi.getter(name="redisLfuDecayTime")
    def redis_lfu_decay_time(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        LFU maxmemory-policy counter decay time in minutes. Default: `1`.
        """
        return pulumi.get(self, "redis_lfu_decay_time")

    @redis_lfu_decay_time.setter
    def redis_lfu_decay_time(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "redis_lfu_decay_time", value)

    @_builtins.property
    @pulumi.getter(name="redisLfuLogFactor")
    def redis_lfu_log_factor(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory-policies. Default: `10`.
        """
        return pulumi.get(self, "redis_lfu_log_factor")

    @redis_lfu_log_factor.setter
    def redis_lfu_log_factor(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "redis_lfu_log_factor", value)

    @_builtins.property
    @pulumi.getter(name="redisMaxmemoryPolicy")
    def redis_maxmemory_policy(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `allkeys-lfu`, `allkeys-lru`, `allkeys-random`, `noeviction`, `volatile-lfu`, `volatile-lru`, `volatile-random`, `volatile-ttl`. Redis maxmemory-policy. Default: `noeviction`.
        """
        return pulumi.get(self, "redis_maxmemory_policy")

    @redis_maxmemory_policy.setter
    def redis_maxmemory_policy(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "redis_maxmemory_policy", value)

    @_builtins.property
    @pulumi.getter(name="redisNotifyKeyspaceEvents")
    def redis_notify_keyspace_events(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Set notify-keyspace-events option.
        """
        return pulumi.get(self, "redis_notify_keyspace_events")

    @redis_notify_keyspace_events.setter
    def redis_notify_keyspace_events(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "redis_notify_keyspace_events", value)

    @_builtins.property
    @pulumi.getter(name="redisNumberOfDatabases")
    def redis_number_of_databases(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Set number of Redis databases. Changing this will cause a restart of the Redis service. Example: `16`.
        """
        return pulumi.get(self, "redis_number_of_databases")

    @redis_number_of_databases.setter
    def redis_number_of_databases(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "redis_number_of_databases", value)

    @_builtins.property
    @pulumi.getter(name="redisPersistence")
    def redis_persistence(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `off`, `rdb`. When persistence is `rdb`, Redis does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to the backup schedule for backup purposes. When persistence is `off`, no RDB dumps or backups are done, so data can be lost at any moment if the service is restarted for any reason, or if the service is powered off. Also, the service can't be forked.
        """
        return pulumi.get(self, "redis_persistence")

    @redis_persistence.setter
    def redis_persistence(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "redis_persistence", value)

    @_builtins.property
    @pulumi.getter(name="redisPubsubClientOutputBufferLimit")
    def redis_pubsub_client_output_buffer_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Set output buffer limit for pub / sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan. Example: `64`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "redis_pubsub_client_output_buffer_limit", value)

    @_builtins.property
    @pulumi.getter(name="redisSsl")
    def redis_ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Require SSL to access Redis. Default: `true`.
        """
        return pulumi.get(self, "redis_ssl")

    @redis_ssl.setter
    def redis_ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "redis_ssl", value)

    @_builtins.property
    @pulumi.getter(name="redisTimeout")
    def redis_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Redis idle connection timeout in seconds. Default: `300`.
        """
        return pulumi.get(self, "redis_timeout")

    @redis_timeout.setter
    def redis_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "redis_timeout", value)

    @_builtins.property
    @pulumi.getter(name="redisVersion")
    def redis_version(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `7.0`, and newer. Redis major version.
        """
        return pulumi.get(self, "redis_version")

    @redis_version.setter
    def redis_version(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "redis_version", value)

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

    @service_log.setter
    def service_log(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "service_log", value)

    @_builtins.property
    @pulumi.getter(name="serviceToForkFrom")
    def service_to_fork_from(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        return pulumi.get(self, "service_to_fork_from")

    @service_to_fork_from.setter
    def service_to_fork_from(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "service_to_fork_from", value)

    @_builtins.property
    @pulumi.getter(name="staticIps")
    def static_ips(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Use static public IP addresses.
        """
        return pulumi.get(self, "static_ips")

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "static_ips", value)


if not MYPY:
    class RedisRedisUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    RedisRedisUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RedisRedisUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "network", value)

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "description", value)


if not MYPY:
    class RedisRedisUserConfigMigrationArgsDict(TypedDict):
        host: pulumi.Input[_builtins.str]
        """
        Hostname or IP address of the server where to migrate data from. Example: `my.server.com`.
        """
        port: pulumi.Input[_builtins.int]
        """
        Port number of the server where to migrate data from. Example: `1234`.
        """
        dbname: NotRequired[pulumi.Input[_builtins.str]]
        """
        Database name for bootstrapping the initial connection. Example: `defaultdb`.
        """
        ignore_dbs: NotRequired[pulumi.Input[_builtins.str]]
        """
        Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
        """
        ignore_roles: NotRequired[pulumi.Input[_builtins.str]]
        """
        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
        """
        method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
        """
        password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        The server where to migrate data from is secured with SSL. Default: `true`.
        """
        username: NotRequired[pulumi.Input[_builtins.str]]
        """
        User name for authentication with the server where to migrate data from. Example: `myname`.
        """
elif False:
    RedisRedisUserConfigMigrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RedisRedisUserConfigMigrationArgs:
    def __init__(__self__, *,
                 host: pulumi.Input[_builtins.str],
                 port: pulumi.Input[_builtins.int],
                 dbname: Optional[pulumi.Input[_builtins.str]] = None,
                 ignore_dbs: Optional[pulumi.Input[_builtins.str]] = None,
                 ignore_roles: Optional[pulumi.Input[_builtins.str]] = None,
                 method: Optional[pulumi.Input[_builtins.str]] = None,
                 password: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 username: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] host: Hostname or IP address of the server where to migrate data from. Example: `my.server.com`.
        :param pulumi.Input[_builtins.int] port: Port number of the server where to migrate data from. Example: `1234`.
        :param pulumi.Input[_builtins.str] dbname: Database name for bootstrapping the initial connection. Example: `defaultdb`.
        :param pulumi.Input[_builtins.str] ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
        :param pulumi.Input[_builtins.str] ignore_roles: Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
        :param pulumi.Input[_builtins.str] method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
        :param pulumi.Input[_builtins.str] password: Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
        :param pulumi.Input[_builtins.bool] ssl: The server where to migrate data from is secured with SSL. Default: `true`.
        :param pulumi.Input[_builtins.str] username: User name for authentication with the server where to migrate data from. Example: `myname`.
        """
        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 ignore_roles is not None:
            pulumi.set(__self__, "ignore_roles", ignore_roles)
        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)

    @_builtins.property
    @pulumi.getter
    def host(self) -> pulumi.Input[_builtins.str]:
        """
        Hostname or IP address of the server where to migrate data from. Example: `my.server.com`.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> pulumi.Input[_builtins.int]:
        """
        Port number of the server where to migrate data from. Example: `1234`.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def dbname(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Database name for bootstrapping the initial connection. Example: `defaultdb`.
        """
        return pulumi.get(self, "dbname")

    @dbname.setter
    def dbname(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "dbname", value)

    @_builtins.property
    @pulumi.getter(name="ignoreDbs")
    def ignore_dbs(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
        """
        return pulumi.get(self, "ignore_dbs")

    @ignore_dbs.setter
    def ignore_dbs(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ignore_dbs", value)

    @_builtins.property
    @pulumi.getter(name="ignoreRoles")
    def ignore_roles(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
        """
        return pulumi.get(self, "ignore_roles")

    @ignore_roles.setter
    def ignore_roles(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ignore_roles", value)

    @_builtins.property
    @pulumi.getter
    def method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
        """
        return pulumi.get(self, "method")

    @method.setter
    def method(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "method", value)

    @_builtins.property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "password", value)

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        The server where to migrate data from is secured with SSL. Default: `true`.
        """
        return pulumi.get(self, "ssl")

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ssl", value)

    @_builtins.property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        User name for authentication with the server where to migrate data from. Example: `myname`.
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "username", value)


if not MYPY:
    class RedisRedisUserConfigPrivateAccessArgsDict(TypedDict):
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        redis: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to redis with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
elif False:
    RedisRedisUserConfigPrivateAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RedisRedisUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None,
                 redis: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] redis: Allow clients to connect to redis with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)
        if redis is not None:
            pulumi.set(__self__, "redis", redis)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "prometheus", value)

    @_builtins.property
    @pulumi.getter
    def redis(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to redis with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "redis")

    @redis.setter
    def redis(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "redis", value)


if not MYPY:
    class RedisRedisUserConfigPrivatelinkAccessArgsDict(TypedDict):
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable prometheus.
        """
        redis: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable redis.
        """
elif False:
    RedisRedisUserConfigPrivatelinkAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RedisRedisUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None,
                 redis: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] prometheus: Enable prometheus.
        :param pulumi.Input[_builtins.bool] redis: Enable redis.
        """
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)
        if redis is not None:
            pulumi.set(__self__, "redis", redis)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable prometheus.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "prometheus", value)

    @_builtins.property
    @pulumi.getter
    def redis(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable redis.
        """
        return pulumi.get(self, "redis")

    @redis.setter
    def redis(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "redis", value)


if not MYPY:
    class RedisRedisUserConfigPublicAccessArgsDict(TypedDict):
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        redis: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to redis from the public internet for service nodes that are in a project VPC or another type of private network.
        """
elif False:
    RedisRedisUserConfigPublicAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RedisRedisUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None,
                 redis: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] redis: Allow clients to connect to redis from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)
        if redis is not None:
            pulumi.set(__self__, "redis", redis)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "prometheus", value)

    @_builtins.property
    @pulumi.getter
    def redis(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to redis from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "redis")

    @redis.setter
    def redis(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "redis", value)


if not MYPY:
    class RedisServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration. The possible value is `read_replica`.
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    RedisServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RedisServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration. The possible value is `read_replica`.
        :param pulumi.Input[_builtins.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)

    @_builtins.property
    @pulumi.getter(name="integrationType")
    def integration_type(self) -> pulumi.Input[_builtins.str]:
        """
        Type of the service integration. The possible value is `read_replica`.
        """
        return pulumi.get(self, "integration_type")

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "integration_type", value)

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class RedisTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    RedisTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RedisTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[_builtins.str],
                 value: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] key: Service tag key
        :param pulumi.Input[_builtins.str] value: Service tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def key(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "key", value)

    @_builtins.property
    @pulumi.getter
    def value(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag value
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "value", value)


if not MYPY:
    class RedisTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    RedisTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class RedisTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

    @email.setter
    def email(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "email", value)


if not MYPY:
    class ServiceIntegrationClickhouseCredentialsUserConfigArgsDict(TypedDict):
        grants: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseCredentialsUserConfigGrantArgsDict']]]]
        """
        Grants to assign
        """
elif False:
    ServiceIntegrationClickhouseCredentialsUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationClickhouseCredentialsUserConfigArgs:
    def __init__(__self__, *,
                 grants: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseCredentialsUserConfigGrantArgs']]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseCredentialsUserConfigGrantArgs']]] grants: Grants to assign
        """
        if grants is not None:
            pulumi.set(__self__, "grants", grants)

    @_builtins.property
    @pulumi.getter
    def grants(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseCredentialsUserConfigGrantArgs']]]]:
        """
        Grants to assign
        """
        return pulumi.get(self, "grants")

    @grants.setter
    def grants(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseCredentialsUserConfigGrantArgs']]]]):
        pulumi.set(self, "grants", value)


if not MYPY:
    class ServiceIntegrationClickhouseCredentialsUserConfigGrantArgsDict(TypedDict):
        user: pulumi.Input[_builtins.str]
        """
        User or role to assign the grant to. Example: `alice`.
        """
elif False:
    ServiceIntegrationClickhouseCredentialsUserConfigGrantArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationClickhouseCredentialsUserConfigGrantArgs:
    def __init__(__self__, *,
                 user: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] user: User or role to assign the grant to. Example: `alice`.
        """
        pulumi.set(__self__, "user", user)

    @_builtins.property
    @pulumi.getter
    def user(self) -> pulumi.Input[_builtins.str]:
        """
        User or role to assign the grant to. Example: `alice`.
        """
        return pulumi.get(self, "user")

    @user.setter
    def user(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "user", value)


if not MYPY:
    class ServiceIntegrationClickhouseKafkaUserConfigArgsDict(TypedDict):
        tables: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableArgsDict']]]]
        """
        Array of table configurations that define how Kafka topics are mapped to ClickHouse tables. Each table configuration specifies the table structure, associated Kafka topics, and read/write settings
        """
elif False:
    ServiceIntegrationClickhouseKafkaUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@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: Array of table configurations that define how Kafka topics are mapped to ClickHouse tables. Each table configuration specifies the table structure, associated Kafka topics, and read/write settings
        """
        if tables is not None:
            pulumi.set(__self__, "tables", tables)

    @_builtins.property
    @pulumi.getter
    def tables(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableArgs']]]]:
        """
        Array of table configurations that define how Kafka topics are mapped to ClickHouse tables. Each table configuration specifies the table structure, associated Kafka topics, and read/write settings
        """
        return pulumi.get(self, "tables")

    @tables.setter
    def tables(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableArgs']]]]):
        pulumi.set(self, "tables", value)


if not MYPY:
    class ServiceIntegrationClickhouseKafkaUserConfigTableArgsDict(TypedDict):
        columns: pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgsDict']]]
        """
        Array of column definitions that specify the structure of the ClickHouse table. Each column maps to a field in the Kafka messages
        """
        data_format: pulumi.Input[_builtins.str]
        """
        Enum: `Avro`, `AvroConfluent`, `CSV`, `JSONAsString`, `JSONCompactEachRow`, `JSONCompactStringsEachRow`, `JSONEachRow`, `JSONStringsEachRow`, `MsgPack`, `Parquet`, `RawBLOB`, `TSKV`, `TSV`, `TabSeparated`. The format of the messages in the Kafka topics. Determines how ClickHouse parses and serializes the data (e.g., JSON, CSV, Avro). Default: `JSONEachRow`.
        """
        group_name: pulumi.Input[_builtins.str]
        """
        The Kafka consumer group name. Multiple consumers with the same group name will share the workload and maintain offset positions. Default: `clickhouse`.
        """
        name: pulumi.Input[_builtins.str]
        """
        The name of the ClickHouse table to be created. This table can consume data from and write data to the specified Kafka topics. Example: `events`.
        """
        topics: pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgsDict']]]
        """
        Array of Kafka topics that this table will read data from or write data to. Messages from all specified topics will be inserted into this table, and data inserted into this table will be published to the topics
        """
        auto_offset_reset: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `beginning`, `earliest`, `end`, `largest`, `latest`, `smallest`. Determines where to start reading from Kafka when no offset is stored or the stored offset is out of range. `earliest` starts from the beginning, `latest` starts from the end. Default: `earliest`.
        """
        date_time_input_format: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `basic`, `best_effort`, `best_effort_us`. Specifies how ClickHouse should parse DateTime values from text-based input formats. `basic` uses simple parsing, `best_effort` attempts more flexible parsing. Default: `basic`.
        """
        handle_error_mode: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `default`, `stream`. Defines how ClickHouse should handle errors when processing Kafka messages. `default` stops on errors, `stream` continues processing and logs errors. Default: `default`.
        """
        max_block_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum number of rows to collect before flushing data between Kafka and ClickHouse. Default: `0`.
        """
        max_rows_per_message: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum number of rows that can be processed from a single Kafka message for row-based formats. Useful for controlling memory usage. Default: `1`.
        """
        num_consumers: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of Kafka consumers to run per table per replica. Increasing this can improve throughput but may increase resource usage. Default: `1`.
        """
        poll_max_batch_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum number of messages to fetch in a single Kafka poll operation for reading. Default: `0`.
        """
        poll_max_timeout_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        Timeout in milliseconds for a single poll from Kafka. Takes the value of the stream*flush*interval_ms server setting by default (500ms). Default: `0`.
        """
        producer_batch_num_messages: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of messages in a batch sent to Kafka. If the number of messages exceeds this value, the batch is sent. Default: `10000`.
        """
        producer_batch_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum size in bytes of a batch of messages sent to Kafka. If the batch size is exceeded, the batch is sent.
        """
        producer_compression_codec: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. The compression codec to use when sending a batch of messages to Kafka. Default: `none`.
        """
        producer_compression_level: NotRequired[pulumi.Input[_builtins.int]]
        """
        The compression level to use when sending a batch of messages to Kafka. Usable range is algorithm-dependent: [0-9] for gzip; [0-12] for lz4; only 0 for snappy; -1 = codec-dependent default compression level. Default: `-1`.
        """
        producer_linger_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The time in milliseconds to wait for additional messages before sending a batch. If the time is exceeded, the batch is sent. Default: `5`.
        """
        producer_queue_buffering_max_kbytes: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum size of the buffer in kilobytes before sending.
        """
        producer_queue_buffering_max_messages: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum number of messages to buffer before sending. Default: `100000`.
        """
        producer_request_required_acks: NotRequired[pulumi.Input[_builtins.int]]
        """
        The number of acknowledgements the leader broker must receive from ISR brokers before responding to the request: 0=Broker does not send any response/ack to client, -1 will block until message is committed by all in sync replicas (ISRs). Default: `-1`.
        """
        skip_broken_messages: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of broken messages to skip before stopping processing when reading from Kafka. Useful for handling corrupted data without failing the entire integration. Default: `0`.
        """
        thread_per_consumer: NotRequired[pulumi.Input[_builtins.bool]]
        """
        When enabled, each consumer runs in its own thread, providing better isolation and potentially better performance for high-throughput scenarios. Default: `false`.
        """
elif False:
    ServiceIntegrationClickhouseKafkaUserConfigTableArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationClickhouseKafkaUserConfigTableArgs:
    def __init__(__self__, *,
                 columns: pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs']]],
                 data_format: pulumi.Input[_builtins.str],
                 group_name: pulumi.Input[_builtins.str],
                 name: pulumi.Input[_builtins.str],
                 topics: pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs']]],
                 auto_offset_reset: Optional[pulumi.Input[_builtins.str]] = None,
                 date_time_input_format: Optional[pulumi.Input[_builtins.str]] = None,
                 handle_error_mode: Optional[pulumi.Input[_builtins.str]] = None,
                 max_block_size: Optional[pulumi.Input[_builtins.int]] = None,
                 max_rows_per_message: Optional[pulumi.Input[_builtins.int]] = None,
                 num_consumers: Optional[pulumi.Input[_builtins.int]] = None,
                 poll_max_batch_size: Optional[pulumi.Input[_builtins.int]] = None,
                 poll_max_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_batch_num_messages: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_batch_size: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_compression_codec: Optional[pulumi.Input[_builtins.str]] = None,
                 producer_compression_level: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_linger_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_queue_buffering_max_kbytes: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_queue_buffering_max_messages: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_request_required_acks: Optional[pulumi.Input[_builtins.int]] = None,
                 skip_broken_messages: Optional[pulumi.Input[_builtins.int]] = None,
                 thread_per_consumer: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs']]] columns: Array of column definitions that specify the structure of the ClickHouse table. Each column maps to a field in the Kafka messages
        :param pulumi.Input[_builtins.str] data_format: Enum: `Avro`, `AvroConfluent`, `CSV`, `JSONAsString`, `JSONCompactEachRow`, `JSONCompactStringsEachRow`, `JSONEachRow`, `JSONStringsEachRow`, `MsgPack`, `Parquet`, `RawBLOB`, `TSKV`, `TSV`, `TabSeparated`. The format of the messages in the Kafka topics. Determines how ClickHouse parses and serializes the data (e.g., JSON, CSV, Avro). Default: `JSONEachRow`.
        :param pulumi.Input[_builtins.str] group_name: The Kafka consumer group name. Multiple consumers with the same group name will share the workload and maintain offset positions. Default: `clickhouse`.
        :param pulumi.Input[_builtins.str] name: The name of the ClickHouse table to be created. This table can consume data from and write data to the specified Kafka topics. Example: `events`.
        :param pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs']]] topics: Array of Kafka topics that this table will read data from or write data to. Messages from all specified topics will be inserted into this table, and data inserted into this table will be published to the topics
        :param pulumi.Input[_builtins.str] auto_offset_reset: Enum: `beginning`, `earliest`, `end`, `largest`, `latest`, `smallest`. Determines where to start reading from Kafka when no offset is stored or the stored offset is out of range. `earliest` starts from the beginning, `latest` starts from the end. Default: `earliest`.
        :param pulumi.Input[_builtins.str] date_time_input_format: Enum: `basic`, `best_effort`, `best_effort_us`. Specifies how ClickHouse should parse DateTime values from text-based input formats. `basic` uses simple parsing, `best_effort` attempts more flexible parsing. Default: `basic`.
        :param pulumi.Input[_builtins.str] handle_error_mode: Enum: `default`, `stream`. Defines how ClickHouse should handle errors when processing Kafka messages. `default` stops on errors, `stream` continues processing and logs errors. Default: `default`.
        :param pulumi.Input[_builtins.int] max_block_size: Maximum number of rows to collect before flushing data between Kafka and ClickHouse. Default: `0`.
        :param pulumi.Input[_builtins.int] max_rows_per_message: Maximum number of rows that can be processed from a single Kafka message for row-based formats. Useful for controlling memory usage. Default: `1`.
        :param pulumi.Input[_builtins.int] num_consumers: Number of Kafka consumers to run per table per replica. Increasing this can improve throughput but may increase resource usage. Default: `1`.
        :param pulumi.Input[_builtins.int] poll_max_batch_size: Maximum number of messages to fetch in a single Kafka poll operation for reading. Default: `0`.
        :param pulumi.Input[_builtins.int] poll_max_timeout_ms: Timeout in milliseconds for a single poll from Kafka. Takes the value of the stream*flush*interval_ms server setting by default (500ms). Default: `0`.
        :param pulumi.Input[_builtins.int] producer_batch_num_messages: The maximum number of messages in a batch sent to Kafka. If the number of messages exceeds this value, the batch is sent. Default: `10000`.
        :param pulumi.Input[_builtins.int] producer_batch_size: The maximum size in bytes of a batch of messages sent to Kafka. If the batch size is exceeded, the batch is sent.
        :param pulumi.Input[_builtins.str] producer_compression_codec: Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. The compression codec to use when sending a batch of messages to Kafka. Default: `none`.
        :param pulumi.Input[_builtins.int] producer_compression_level: The compression level to use when sending a batch of messages to Kafka. Usable range is algorithm-dependent: [0-9] for gzip; [0-12] for lz4; only 0 for snappy; -1 = codec-dependent default compression level. Default: `-1`.
        :param pulumi.Input[_builtins.int] producer_linger_ms: The time in milliseconds to wait for additional messages before sending a batch. If the time is exceeded, the batch is sent. Default: `5`.
        :param pulumi.Input[_builtins.int] producer_queue_buffering_max_kbytes: The maximum size of the buffer in kilobytes before sending.
        :param pulumi.Input[_builtins.int] producer_queue_buffering_max_messages: The maximum number of messages to buffer before sending. Default: `100000`.
        :param pulumi.Input[_builtins.int] producer_request_required_acks: The number of acknowledgements the leader broker must receive from ISR brokers before responding to the request: 0=Broker does not send any response/ack to client, -1 will block until message is committed by all in sync replicas (ISRs). Default: `-1`.
        :param pulumi.Input[_builtins.int] skip_broken_messages: Number of broken messages to skip before stopping processing when reading from Kafka. Useful for handling corrupted data without failing the entire integration. Default: `0`.
        :param pulumi.Input[_builtins.bool] thread_per_consumer: When enabled, each consumer runs in its own thread, providing better isolation and potentially better performance for high-throughput scenarios. Default: `false`.
        """
        pulumi.set(__self__, "columns", columns)
        pulumi.set(__self__, "data_format", data_format)
        pulumi.set(__self__, "group_name", group_name)
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "topics", topics)
        if auto_offset_reset is not None:
            pulumi.set(__self__, "auto_offset_reset", auto_offset_reset)
        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 poll_max_timeout_ms is not None:
            pulumi.set(__self__, "poll_max_timeout_ms", poll_max_timeout_ms)
        if producer_batch_num_messages is not None:
            pulumi.set(__self__, "producer_batch_num_messages", producer_batch_num_messages)
        if producer_batch_size is not None:
            pulumi.set(__self__, "producer_batch_size", producer_batch_size)
        if producer_compression_codec is not None:
            pulumi.set(__self__, "producer_compression_codec", producer_compression_codec)
        if producer_compression_level is not None:
            pulumi.set(__self__, "producer_compression_level", producer_compression_level)
        if producer_linger_ms is not None:
            pulumi.set(__self__, "producer_linger_ms", producer_linger_ms)
        if producer_queue_buffering_max_kbytes is not None:
            pulumi.set(__self__, "producer_queue_buffering_max_kbytes", producer_queue_buffering_max_kbytes)
        if producer_queue_buffering_max_messages is not None:
            pulumi.set(__self__, "producer_queue_buffering_max_messages", producer_queue_buffering_max_messages)
        if producer_request_required_acks is not None:
            pulumi.set(__self__, "producer_request_required_acks", producer_request_required_acks)
        if skip_broken_messages is not None:
            pulumi.set(__self__, "skip_broken_messages", skip_broken_messages)
        if thread_per_consumer is not None:
            pulumi.set(__self__, "thread_per_consumer", thread_per_consumer)

    @_builtins.property
    @pulumi.getter
    def columns(self) -> pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs']]]:
        """
        Array of column definitions that specify the structure of the ClickHouse table. Each column maps to a field in the Kafka messages
        """
        return pulumi.get(self, "columns")

    @columns.setter
    def columns(self, value: pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs']]]):
        pulumi.set(self, "columns", value)

    @_builtins.property
    @pulumi.getter(name="dataFormat")
    def data_format(self) -> pulumi.Input[_builtins.str]:
        """
        Enum: `Avro`, `AvroConfluent`, `CSV`, `JSONAsString`, `JSONCompactEachRow`, `JSONCompactStringsEachRow`, `JSONEachRow`, `JSONStringsEachRow`, `MsgPack`, `Parquet`, `RawBLOB`, `TSKV`, `TSV`, `TabSeparated`. The format of the messages in the Kafka topics. Determines how ClickHouse parses and serializes the data (e.g., JSON, CSV, Avro). Default: `JSONEachRow`.
        """
        return pulumi.get(self, "data_format")

    @data_format.setter
    def data_format(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "data_format", value)

    @_builtins.property
    @pulumi.getter(name="groupName")
    def group_name(self) -> pulumi.Input[_builtins.str]:
        """
        The Kafka consumer group name. Multiple consumers with the same group name will share the workload and maintain offset positions. Default: `clickhouse`.
        """
        return pulumi.get(self, "group_name")

    @group_name.setter
    def group_name(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "group_name", value)

    @_builtins.property
    @pulumi.getter
    def name(self) -> pulumi.Input[_builtins.str]:
        """
        The name of the ClickHouse table to be created. This table can consume data from and write data to the specified Kafka topics. Example: `events`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "name", value)

    @_builtins.property
    @pulumi.getter
    def topics(self) -> pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs']]]:
        """
        Array of Kafka topics that this table will read data from or write data to. Messages from all specified topics will be inserted into this table, and data inserted into this table will be published to the topics
        """
        return pulumi.get(self, "topics")

    @topics.setter
    def topics(self, value: pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs']]]):
        pulumi.set(self, "topics", value)

    @_builtins.property
    @pulumi.getter(name="autoOffsetReset")
    def auto_offset_reset(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `beginning`, `earliest`, `end`, `largest`, `latest`, `smallest`. Determines where to start reading from Kafka when no offset is stored or the stored offset is out of range. `earliest` starts from the beginning, `latest` starts from the end. Default: `earliest`.
        """
        return pulumi.get(self, "auto_offset_reset")

    @auto_offset_reset.setter
    def auto_offset_reset(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "auto_offset_reset", value)

    @_builtins.property
    @pulumi.getter(name="dateTimeInputFormat")
    def date_time_input_format(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `basic`, `best_effort`, `best_effort_us`. Specifies how ClickHouse should parse DateTime values from text-based input formats. `basic` uses simple parsing, `best_effort` attempts more flexible parsing. Default: `basic`.
        """
        return pulumi.get(self, "date_time_input_format")

    @date_time_input_format.setter
    def date_time_input_format(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "date_time_input_format", value)

    @_builtins.property
    @pulumi.getter(name="handleErrorMode")
    def handle_error_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `default`, `stream`. Defines how ClickHouse should handle errors when processing Kafka messages. `default` stops on errors, `stream` continues processing and logs errors. Default: `default`.
        """
        return pulumi.get(self, "handle_error_mode")

    @handle_error_mode.setter
    def handle_error_mode(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "handle_error_mode", value)

    @_builtins.property
    @pulumi.getter(name="maxBlockSize")
    def max_block_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum number of rows to collect before flushing data between Kafka and ClickHouse. Default: `0`.
        """
        return pulumi.get(self, "max_block_size")

    @max_block_size.setter
    def max_block_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_block_size", value)

    @_builtins.property
    @pulumi.getter(name="maxRowsPerMessage")
    def max_rows_per_message(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum number of rows that can be processed from a single Kafka message for row-based formats. Useful for controlling memory usage. Default: `1`.
        """
        return pulumi.get(self, "max_rows_per_message")

    @max_rows_per_message.setter
    def max_rows_per_message(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_rows_per_message", value)

    @_builtins.property
    @pulumi.getter(name="numConsumers")
    def num_consumers(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of Kafka consumers to run per table per replica. Increasing this can improve throughput but may increase resource usage. Default: `1`.
        """
        return pulumi.get(self, "num_consumers")

    @num_consumers.setter
    def num_consumers(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "num_consumers", value)

    @_builtins.property
    @pulumi.getter(name="pollMaxBatchSize")
    def poll_max_batch_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum number of messages to fetch in a single Kafka poll operation for reading. Default: `0`.
        """
        return pulumi.get(self, "poll_max_batch_size")

    @poll_max_batch_size.setter
    def poll_max_batch_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "poll_max_batch_size", value)

    @_builtins.property
    @pulumi.getter(name="pollMaxTimeoutMs")
    def poll_max_timeout_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Timeout in milliseconds for a single poll from Kafka. Takes the value of the stream*flush*interval_ms server setting by default (500ms). Default: `0`.
        """
        return pulumi.get(self, "poll_max_timeout_ms")

    @poll_max_timeout_ms.setter
    def poll_max_timeout_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "poll_max_timeout_ms", value)

    @_builtins.property
    @pulumi.getter(name="producerBatchNumMessages")
    def producer_batch_num_messages(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of messages in a batch sent to Kafka. If the number of messages exceeds this value, the batch is sent. Default: `10000`.
        """
        return pulumi.get(self, "producer_batch_num_messages")

    @producer_batch_num_messages.setter
    def producer_batch_num_messages(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "producer_batch_num_messages", value)

    @_builtins.property
    @pulumi.getter(name="producerBatchSize")
    def producer_batch_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum size in bytes of a batch of messages sent to Kafka. If the batch size is exceeded, the batch is sent.
        """
        return pulumi.get(self, "producer_batch_size")

    @producer_batch_size.setter
    def producer_batch_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "producer_batch_size", value)

    @_builtins.property
    @pulumi.getter(name="producerCompressionCodec")
    def producer_compression_codec(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. The compression codec to use when sending a batch of messages to Kafka. Default: `none`.
        """
        return pulumi.get(self, "producer_compression_codec")

    @producer_compression_codec.setter
    def producer_compression_codec(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "producer_compression_codec", value)

    @_builtins.property
    @pulumi.getter(name="producerCompressionLevel")
    def producer_compression_level(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The compression level to use when sending a batch of messages to Kafka. Usable range is algorithm-dependent: [0-9] for gzip; [0-12] for lz4; only 0 for snappy; -1 = codec-dependent default compression level. Default: `-1`.
        """
        return pulumi.get(self, "producer_compression_level")

    @producer_compression_level.setter
    def producer_compression_level(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "producer_compression_level", value)

    @_builtins.property
    @pulumi.getter(name="producerLingerMs")
    def producer_linger_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The time in milliseconds to wait for additional messages before sending a batch. If the time is exceeded, the batch is sent. Default: `5`.
        """
        return pulumi.get(self, "producer_linger_ms")

    @producer_linger_ms.setter
    def producer_linger_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "producer_linger_ms", value)

    @_builtins.property
    @pulumi.getter(name="producerQueueBufferingMaxKbytes")
    def producer_queue_buffering_max_kbytes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum size of the buffer in kilobytes before sending.
        """
        return pulumi.get(self, "producer_queue_buffering_max_kbytes")

    @producer_queue_buffering_max_kbytes.setter
    def producer_queue_buffering_max_kbytes(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "producer_queue_buffering_max_kbytes", value)

    @_builtins.property
    @pulumi.getter(name="producerQueueBufferingMaxMessages")
    def producer_queue_buffering_max_messages(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum number of messages to buffer before sending. Default: `100000`.
        """
        return pulumi.get(self, "producer_queue_buffering_max_messages")

    @producer_queue_buffering_max_messages.setter
    def producer_queue_buffering_max_messages(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "producer_queue_buffering_max_messages", value)

    @_builtins.property
    @pulumi.getter(name="producerRequestRequiredAcks")
    def producer_request_required_acks(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The number of acknowledgements the leader broker must receive from ISR brokers before responding to the request: 0=Broker does not send any response/ack to client, -1 will block until message is committed by all in sync replicas (ISRs). Default: `-1`.
        """
        return pulumi.get(self, "producer_request_required_acks")

    @producer_request_required_acks.setter
    def producer_request_required_acks(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "producer_request_required_acks", value)

    @_builtins.property
    @pulumi.getter(name="skipBrokenMessages")
    def skip_broken_messages(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of broken messages to skip before stopping processing when reading from Kafka. Useful for handling corrupted data without failing the entire integration. Default: `0`.
        """
        return pulumi.get(self, "skip_broken_messages")

    @skip_broken_messages.setter
    def skip_broken_messages(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "skip_broken_messages", value)

    @_builtins.property
    @pulumi.getter(name="threadPerConsumer")
    def thread_per_consumer(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        When enabled, each consumer runs in its own thread, providing better isolation and potentially better performance for high-throughput scenarios. Default: `false`.
        """
        return pulumi.get(self, "thread_per_consumer")

    @thread_per_consumer.setter
    def thread_per_consumer(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "thread_per_consumer", value)


if not MYPY:
    class ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgsDict(TypedDict):
        name: pulumi.Input[_builtins.str]
        """
        The name of the column in the ClickHouse table. This should match the field names in your Kafka message format. Example: `key`.
        """
        type: pulumi.Input[_builtins.str]
        """
        The ClickHouse data type for this column. Must be a valid ClickHouse data type that can handle the data format. Example: `UInt64`.
        """
elif False:
    ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationClickhouseKafkaUserConfigTableColumnArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[_builtins.str],
                 type: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] name: The name of the column in the ClickHouse table. This should match the field names in your Kafka message format. Example: `key`.
        :param pulumi.Input[_builtins.str] type: The ClickHouse data type for this column. Must be a valid ClickHouse data type that can handle the data format. Example: `UInt64`.
        """
        pulumi.set(__self__, "name", name)
        pulumi.set(__self__, "type", type)

    @_builtins.property
    @pulumi.getter
    def name(self) -> pulumi.Input[_builtins.str]:
        """
        The name of the column in the ClickHouse table. This should match the field names in your Kafka message format. Example: `key`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "name", value)

    @_builtins.property
    @pulumi.getter
    def type(self) -> pulumi.Input[_builtins.str]:
        """
        The ClickHouse data type for this column. Must be a valid ClickHouse data type that can handle the data format. Example: `UInt64`.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "type", value)


if not MYPY:
    class ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgsDict(TypedDict):
        name: pulumi.Input[_builtins.str]
        """
        The name of the Kafka topic to read messages from or write messages to. The topic must exist in the Kafka cluster. Example: `topic_name`.
        """
elif False:
    ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationClickhouseKafkaUserConfigTableTopicArgs:
    def __init__(__self__, *,
                 name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] name: The name of the Kafka topic to read messages from or write messages to. The topic must exist in the Kafka cluster. Example: `topic_name`.
        """
        pulumi.set(__self__, "name", name)

    @_builtins.property
    @pulumi.getter
    def name(self) -> pulumi.Input[_builtins.str]:
        """
        The name of the Kafka topic to read messages from or write messages to. The topic must exist in the Kafka cluster. Example: `topic_name`.
        """
        return pulumi.get(self, "name")

    @name.setter
    def name(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "name", value)


if not MYPY:
    class ServiceIntegrationClickhousePostgresqlUserConfigArgsDict(TypedDict):
        databases: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationClickhousePostgresqlUserConfigDatabaseArgsDict']]]]
        """
        Databases to expose
        """
elif False:
    ServiceIntegrationClickhousePostgresqlUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@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)

    @_builtins.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)


if not MYPY:
    class ServiceIntegrationClickhousePostgresqlUserConfigDatabaseArgsDict(TypedDict):
        database: NotRequired[pulumi.Input[_builtins.str]]
        """
        PostgreSQL database to expose. Default: `defaultdb`.
        """
        schema: NotRequired[pulumi.Input[_builtins.str]]
        """
        PostgreSQL schema to expose. Default: `public`.
        """
elif False:
    ServiceIntegrationClickhousePostgresqlUserConfigDatabaseArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationClickhousePostgresqlUserConfigDatabaseArgs:
    def __init__(__self__, *,
                 database: Optional[pulumi.Input[_builtins.str]] = None,
                 schema: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] database: PostgreSQL database to expose. Default: `defaultdb`.
        :param pulumi.Input[_builtins.str] schema: PostgreSQL schema to expose. Default: `public`.
        """
        if database is not None:
            pulumi.set(__self__, "database", database)
        if schema is not None:
            pulumi.set(__self__, "schema", schema)

    @_builtins.property
    @pulumi.getter
    def database(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PostgreSQL database to expose. Default: `defaultdb`.
        """
        return pulumi.get(self, "database")

    @database.setter
    def database(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "database", value)

    @_builtins.property
    @pulumi.getter
    def schema(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PostgreSQL schema to expose. Default: `public`.
        """
        return pulumi.get(self, "schema")

    @schema.setter
    def schema(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "schema", value)


if not MYPY:
    class ServiceIntegrationDatadogUserConfigArgsDict(TypedDict):
        datadog_dbm_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable Datadog Database Monitoring.
        """
        datadog_pgbouncer_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable Datadog PgBouncer Metric Tracking.
        """
        datadog_tags: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationDatadogUserConfigDatadogTagArgsDict']]]]
        """
        Custom tags provided by user
        """
        exclude_consumer_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        List of custom metrics.
        """
        exclude_topics: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        List of topics to exclude.
        """
        include_consumer_groups: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        List of custom metrics.
        """
        include_topics: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        List of topics to include.
        """
        kafka_custom_metrics: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        List of custom metrics.
        """
        max_jmx_metrics: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum number of JMX metrics to send. Example: `2000`.
        """
        mirrormaker_custom_metrics: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        List of custom metrics.
        """
        opensearch: NotRequired[pulumi.Input['ServiceIntegrationDatadogUserConfigOpensearchArgsDict']]
        """
        Datadog Opensearch Options
        """
        redis: NotRequired[pulumi.Input['ServiceIntegrationDatadogUserConfigRedisArgsDict']]
        """
        Datadog Redis Options
        """
elif False:
    ServiceIntegrationDatadogUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationDatadogUserConfigArgs:
    def __init__(__self__, *,
                 datadog_dbm_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 datadog_pgbouncer_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 datadog_tags: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationDatadogUserConfigDatadogTagArgs']]]] = None,
                 exclude_consumer_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 exclude_topics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 include_consumer_groups: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 include_topics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 kafka_custom_metrics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 max_jmx_metrics: Optional[pulumi.Input[_builtins.int]] = None,
                 mirrormaker_custom_metrics: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 opensearch: Optional[pulumi.Input['ServiceIntegrationDatadogUserConfigOpensearchArgs']] = None,
                 redis: Optional[pulumi.Input['ServiceIntegrationDatadogUserConfigRedisArgs']] = None):
        """
        :param pulumi.Input[_builtins.bool] datadog_dbm_enabled: Enable Datadog Database Monitoring.
        :param pulumi.Input[_builtins.bool] datadog_pgbouncer_enabled: Enable Datadog PgBouncer Metric Tracking.
        :param pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationDatadogUserConfigDatadogTagArgs']]] datadog_tags: Custom tags provided by user
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] exclude_consumer_groups: List of custom metrics.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] exclude_topics: List of topics to exclude.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] include_consumer_groups: List of custom metrics.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] include_topics: List of topics to include.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] kafka_custom_metrics: List of custom metrics.
        :param pulumi.Input[_builtins.int] max_jmx_metrics: Maximum number of JMX metrics to send. Example: `2000`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] mirrormaker_custom_metrics: List of custom metrics.
        :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_pgbouncer_enabled is not None:
            pulumi.set(__self__, "datadog_pgbouncer_enabled", datadog_pgbouncer_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 mirrormaker_custom_metrics is not None:
            pulumi.set(__self__, "mirrormaker_custom_metrics", mirrormaker_custom_metrics)
        if opensearch is not None:
            pulumi.set(__self__, "opensearch", opensearch)
        if redis is not None:
            pulumi.set(__self__, "redis", redis)

    @_builtins.property
    @pulumi.getter(name="datadogDbmEnabled")
    def datadog_dbm_enabled(self) -> Optional[pulumi.Input[_builtins.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[_builtins.bool]]):
        pulumi.set(self, "datadog_dbm_enabled", value)

    @_builtins.property
    @pulumi.getter(name="datadogPgbouncerEnabled")
    def datadog_pgbouncer_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable Datadog PgBouncer Metric Tracking.
        """
        return pulumi.get(self, "datadog_pgbouncer_enabled")

    @datadog_pgbouncer_enabled.setter
    def datadog_pgbouncer_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "datadog_pgbouncer_enabled", value)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="excludeConsumerGroups")
    def exclude_consumer_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "exclude_consumer_groups", value)

    @_builtins.property
    @pulumi.getter(name="excludeTopics")
    def exclude_topics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "exclude_topics", value)

    @_builtins.property
    @pulumi.getter(name="includeConsumerGroups")
    def include_consumer_groups(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "include_consumer_groups", value)

    @_builtins.property
    @pulumi.getter(name="includeTopics")
    def include_topics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "include_topics", value)

    @_builtins.property
    @pulumi.getter(name="kafkaCustomMetrics")
    def kafka_custom_metrics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "kafka_custom_metrics", value)

    @_builtins.property
    @pulumi.getter(name="maxJmxMetrics")
    def max_jmx_metrics(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum number of JMX metrics to send. Example: `2000`.
        """
        return pulumi.get(self, "max_jmx_metrics")

    @max_jmx_metrics.setter
    def max_jmx_metrics(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_jmx_metrics", value)

    @_builtins.property
    @pulumi.getter(name="mirrormakerCustomMetrics")
    def mirrormaker_custom_metrics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        List of custom metrics.
        """
        return pulumi.get(self, "mirrormaker_custom_metrics")

    @mirrormaker_custom_metrics.setter
    def mirrormaker_custom_metrics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "mirrormaker_custom_metrics", value)

    @_builtins.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)

    @_builtins.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)


if not MYPY:
    class ServiceIntegrationDatadogUserConfigDatadogTagArgsDict(TypedDict):
        tag: pulumi.Input[_builtins.str]
        """
        Tag format and usage are described here: https://docs.datadoghq.com/getting_started/tagging. Tags with prefix `aiven-` are reserved for Aiven. Example: `replica:primary`.
        """
        comment: NotRequired[pulumi.Input[_builtins.str]]
        """
        Optional tag explanation. Example: `Used to tag primary replica metrics`.
        """
elif False:
    ServiceIntegrationDatadogUserConfigDatadogTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationDatadogUserConfigDatadogTagArgs:
    def __init__(__self__, *,
                 tag: pulumi.Input[_builtins.str],
                 comment: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] tag: Tag format and usage are described here: https://docs.datadoghq.com/getting_started/tagging. Tags with prefix `aiven-` are reserved for Aiven. Example: `replica:primary`.
        :param pulumi.Input[_builtins.str] comment: Optional tag explanation. Example: `Used to tag primary replica metrics`.
        """
        pulumi.set(__self__, "tag", tag)
        if comment is not None:
            pulumi.set(__self__, "comment", comment)

    @_builtins.property
    @pulumi.getter
    def tag(self) -> pulumi.Input[_builtins.str]:
        """
        Tag format and usage are described here: https://docs.datadoghq.com/getting_started/tagging. Tags with prefix `aiven-` are reserved for Aiven. Example: `replica:primary`.
        """
        return pulumi.get(self, "tag")

    @tag.setter
    def tag(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "tag", value)

    @_builtins.property
    @pulumi.getter
    def comment(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Optional tag explanation. Example: `Used to tag primary replica metrics`.
        """
        return pulumi.get(self, "comment")

    @comment.setter
    def comment(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "comment", value)


if not MYPY:
    class ServiceIntegrationDatadogUserConfigOpensearchArgsDict(TypedDict):
        cluster_stats_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable Datadog Opensearch Cluster Monitoring.
        """
        index_stats_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable Datadog Opensearch Index Monitoring.
        """
        pending_task_stats_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable Datadog Opensearch Pending Task Monitoring.
        """
        pshard_stats_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable Datadog Opensearch Primary Shard Monitoring.
        """
elif False:
    ServiceIntegrationDatadogUserConfigOpensearchArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationDatadogUserConfigOpensearchArgs:
    def __init__(__self__, *,
                 cluster_stats_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 index_stats_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 pending_task_stats_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
                 pshard_stats_enabled: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] cluster_stats_enabled: Enable Datadog Opensearch Cluster Monitoring.
        :param pulumi.Input[_builtins.bool] index_stats_enabled: Enable Datadog Opensearch Index Monitoring.
        :param pulumi.Input[_builtins.bool] pending_task_stats_enabled: Enable Datadog Opensearch Pending Task Monitoring.
        :param pulumi.Input[_builtins.bool] pshard_stats_enabled: Enable Datadog Opensearch Primary Shard Monitoring.
        """
        if cluster_stats_enabled is not None:
            pulumi.set(__self__, "cluster_stats_enabled", cluster_stats_enabled)
        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)

    @_builtins.property
    @pulumi.getter(name="clusterStatsEnabled")
    def cluster_stats_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable Datadog Opensearch Cluster Monitoring.
        """
        return pulumi.get(self, "cluster_stats_enabled")

    @cluster_stats_enabled.setter
    def cluster_stats_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "cluster_stats_enabled", value)

    @_builtins.property
    @pulumi.getter(name="indexStatsEnabled")
    def index_stats_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable Datadog Opensearch Index Monitoring.
        """
        return pulumi.get(self, "index_stats_enabled")

    @index_stats_enabled.setter
    def index_stats_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "index_stats_enabled", value)

    @_builtins.property
    @pulumi.getter(name="pendingTaskStatsEnabled")
    def pending_task_stats_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable Datadog Opensearch Pending Task Monitoring.
        """
        return pulumi.get(self, "pending_task_stats_enabled")

    @pending_task_stats_enabled.setter
    def pending_task_stats_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "pending_task_stats_enabled", value)

    @_builtins.property
    @pulumi.getter(name="pshardStatsEnabled")
    def pshard_stats_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable Datadog Opensearch Primary Shard Monitoring.
        """
        return pulumi.get(self, "pshard_stats_enabled")

    @pshard_stats_enabled.setter
    def pshard_stats_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "pshard_stats_enabled", value)


if not MYPY:
    class ServiceIntegrationDatadogUserConfigRedisArgsDict(TypedDict):
        command_stats_enabled: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable command_stats option in the agent's configuration. Default: `false`.
        """
elif False:
    ServiceIntegrationDatadogUserConfigRedisArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationDatadogUserConfigRedisArgs:
    def __init__(__self__, *,
                 command_stats_enabled: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] command_stats_enabled: Enable command_stats option in the agent's configuration. Default: `false`.
        """
        if command_stats_enabled is not None:
            pulumi.set(__self__, "command_stats_enabled", command_stats_enabled)

    @_builtins.property
    @pulumi.getter(name="commandStatsEnabled")
    def command_stats_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable command_stats option in the agent's configuration. Default: `false`.
        """
        return pulumi.get(self, "command_stats_enabled")

    @command_stats_enabled.setter
    def command_stats_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "command_stats_enabled", value)


if not MYPY:
    class ServiceIntegrationEndpointAutoscalerUserConfigArgsDict(TypedDict):
        autoscalings: pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationEndpointAutoscalerUserConfigAutoscalingArgsDict']]]
        """
        Configure autoscaling thresholds for a service
        """
elif False:
    ServiceIntegrationEndpointAutoscalerUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointAutoscalerUserConfigArgs:
    def __init__(__self__, *,
                 autoscalings: pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationEndpointAutoscalerUserConfigAutoscalingArgs']]]):
        """
        :param pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationEndpointAutoscalerUserConfigAutoscalingArgs']]] autoscalings: Configure autoscaling thresholds for a service
        """
        pulumi.set(__self__, "autoscalings", autoscalings)

    @_builtins.property
    @pulumi.getter
    def autoscalings(self) -> pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationEndpointAutoscalerUserConfigAutoscalingArgs']]]:
        """
        Configure autoscaling thresholds for a service
        """
        return pulumi.get(self, "autoscalings")

    @autoscalings.setter
    def autoscalings(self, value: pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationEndpointAutoscalerUserConfigAutoscalingArgs']]]):
        pulumi.set(self, "autoscalings", value)


if not MYPY:
    class ServiceIntegrationEndpointAutoscalerUserConfigAutoscalingArgsDict(TypedDict):
        cap_gb: pulumi.Input[_builtins.int]
        """
        The maximum total disk size (in gb) to allow autoscaler to scale up to. Example: `300`.
        """
        type: pulumi.Input[_builtins.str]
        """
        Enum: `autoscale_disk`. Type of autoscale event.
        """
elif False:
    ServiceIntegrationEndpointAutoscalerUserConfigAutoscalingArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointAutoscalerUserConfigAutoscalingArgs:
    def __init__(__self__, *,
                 cap_gb: pulumi.Input[_builtins.int],
                 type: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.int] cap_gb: The maximum total disk size (in gb) to allow autoscaler to scale up to. Example: `300`.
        :param pulumi.Input[_builtins.str] type: Enum: `autoscale_disk`. Type of autoscale event.
        """
        pulumi.set(__self__, "cap_gb", cap_gb)
        pulumi.set(__self__, "type", type)

    @_builtins.property
    @pulumi.getter(name="capGb")
    def cap_gb(self) -> pulumi.Input[_builtins.int]:
        """
        The maximum total disk size (in gb) to allow autoscaler to scale up to. Example: `300`.
        """
        return pulumi.get(self, "cap_gb")

    @cap_gb.setter
    def cap_gb(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "cap_gb", value)

    @_builtins.property
    @pulumi.getter
    def type(self) -> pulumi.Input[_builtins.str]:
        """
        Enum: `autoscale_disk`. Type of autoscale event.
        """
        return pulumi.get(self, "type")

    @type.setter
    def type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "type", value)


if not MYPY:
    class ServiceIntegrationEndpointDatadogUserConfigArgsDict(TypedDict):
        datadog_api_key: pulumi.Input[_builtins.str]
        """
        Datadog API key. Example: `848f30907c15c55d601fe45487cce9b6`.
        """
        datadog_tags: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationEndpointDatadogUserConfigDatadogTagArgsDict']]]]
        """
        Custom tags provided by user
        """
        disable_consumer_stats: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Disable consumer group metrics.
        """
        extra_tags_prefix: NotRequired[pulumi.Input[_builtins.str]]
        """
        Extra tags prefix. Defaults to aiven.
        """
        kafka_consumer_check_instances: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of separate instances to fetch kafka consumer statistics with. Example: `8`.
        """
        kafka_consumer_stats_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of seconds that datadog will wait to get consumer statistics from brokers. Example: `60`.
        """
        max_partition_contexts: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum number of partition contexts to send. Example: `32000`.
        """
        site: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `ap1.datadoghq.com`, `datadoghq.com`, `datadoghq.eu`, `ddog-gov.com`, `us3.datadoghq.com`, `us5.datadoghq.com`. Datadog intake site. Defaults to datadoghq.com.
        """
elif False:
    ServiceIntegrationEndpointDatadogUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointDatadogUserConfigArgs:
    def __init__(__self__, *,
                 datadog_api_key: pulumi.Input[_builtins.str],
                 datadog_tags: Optional[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationEndpointDatadogUserConfigDatadogTagArgs']]]] = None,
                 disable_consumer_stats: Optional[pulumi.Input[_builtins.bool]] = None,
                 extra_tags_prefix: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_consumer_check_instances: Optional[pulumi.Input[_builtins.int]] = None,
                 kafka_consumer_stats_timeout: Optional[pulumi.Input[_builtins.int]] = None,
                 max_partition_contexts: Optional[pulumi.Input[_builtins.int]] = None,
                 site: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] datadog_api_key: Datadog API key. Example: `848f30907c15c55d601fe45487cce9b6`.
        :param pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationEndpointDatadogUserConfigDatadogTagArgs']]] datadog_tags: Custom tags provided by user
        :param pulumi.Input[_builtins.bool] disable_consumer_stats: Disable consumer group metrics.
        :param pulumi.Input[_builtins.str] extra_tags_prefix: Extra tags prefix. Defaults to aiven.
        :param pulumi.Input[_builtins.int] kafka_consumer_check_instances: Number of separate instances to fetch kafka consumer statistics with. Example: `8`.
        :param pulumi.Input[_builtins.int] kafka_consumer_stats_timeout: Number of seconds that datadog will wait to get consumer statistics from brokers. Example: `60`.
        :param pulumi.Input[_builtins.int] max_partition_contexts: Maximum number of partition contexts to send. Example: `32000`.
        :param pulumi.Input[_builtins.str] site: Enum: `ap1.datadoghq.com`, `datadoghq.com`, `datadoghq.eu`, `ddog-gov.com`, `us3.datadoghq.com`, `us5.datadoghq.com`. 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 extra_tags_prefix is not None:
            pulumi.set(__self__, "extra_tags_prefix", extra_tags_prefix)
        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)

    @_builtins.property
    @pulumi.getter(name="datadogApiKey")
    def datadog_api_key(self) -> pulumi.Input[_builtins.str]:
        """
        Datadog API key. Example: `848f30907c15c55d601fe45487cce9b6`.
        """
        return pulumi.get(self, "datadog_api_key")

    @datadog_api_key.setter
    def datadog_api_key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "datadog_api_key", value)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter(name="disableConsumerStats")
    def disable_consumer_stats(self) -> Optional[pulumi.Input[_builtins.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[_builtins.bool]]):
        pulumi.set(self, "disable_consumer_stats", value)

    @_builtins.property
    @pulumi.getter(name="extraTagsPrefix")
    def extra_tags_prefix(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Extra tags prefix. Defaults to aiven.
        """
        return pulumi.get(self, "extra_tags_prefix")

    @extra_tags_prefix.setter
    def extra_tags_prefix(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "extra_tags_prefix", value)

    @_builtins.property
    @pulumi.getter(name="kafkaConsumerCheckInstances")
    def kafka_consumer_check_instances(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of separate instances to fetch kafka consumer statistics with. Example: `8`.
        """
        return pulumi.get(self, "kafka_consumer_check_instances")

    @kafka_consumer_check_instances.setter
    def kafka_consumer_check_instances(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "kafka_consumer_check_instances", value)

    @_builtins.property
    @pulumi.getter(name="kafkaConsumerStatsTimeout")
    def kafka_consumer_stats_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Number of seconds that datadog will wait to get consumer statistics from brokers. Example: `60`.
        """
        return pulumi.get(self, "kafka_consumer_stats_timeout")

    @kafka_consumer_stats_timeout.setter
    def kafka_consumer_stats_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "kafka_consumer_stats_timeout", value)

    @_builtins.property
    @pulumi.getter(name="maxPartitionContexts")
    def max_partition_contexts(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum number of partition contexts to send. Example: `32000`.
        """
        return pulumi.get(self, "max_partition_contexts")

    @max_partition_contexts.setter
    def max_partition_contexts(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_partition_contexts", value)

    @_builtins.property
    @pulumi.getter
    def site(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `ap1.datadoghq.com`, `datadoghq.com`, `datadoghq.eu`, `ddog-gov.com`, `us3.datadoghq.com`, `us5.datadoghq.com`. Datadog intake site. Defaults to datadoghq.com.
        """
        return pulumi.get(self, "site")

    @site.setter
    def site(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "site", value)


if not MYPY:
    class ServiceIntegrationEndpointDatadogUserConfigDatadogTagArgsDict(TypedDict):
        tag: pulumi.Input[_builtins.str]
        """
        Tag format and usage are described here: https://docs.datadoghq.com/getting_started/tagging. Tags with prefix `aiven-` are reserved for Aiven. Example: `replica:primary`.
        """
        comment: NotRequired[pulumi.Input[_builtins.str]]
        """
        Optional tag explanation. Example: `Used to tag primary replica metrics`.
        """
elif False:
    ServiceIntegrationEndpointDatadogUserConfigDatadogTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointDatadogUserConfigDatadogTagArgs:
    def __init__(__self__, *,
                 tag: pulumi.Input[_builtins.str],
                 comment: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] tag: Tag format and usage are described here: https://docs.datadoghq.com/getting_started/tagging. Tags with prefix `aiven-` are reserved for Aiven. Example: `replica:primary`.
        :param pulumi.Input[_builtins.str] comment: Optional tag explanation. Example: `Used to tag primary replica metrics`.
        """
        pulumi.set(__self__, "tag", tag)
        if comment is not None:
            pulumi.set(__self__, "comment", comment)

    @_builtins.property
    @pulumi.getter
    def tag(self) -> pulumi.Input[_builtins.str]:
        """
        Tag format and usage are described here: https://docs.datadoghq.com/getting_started/tagging. Tags with prefix `aiven-` are reserved for Aiven. Example: `replica:primary`.
        """
        return pulumi.get(self, "tag")

    @tag.setter
    def tag(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "tag", value)

    @_builtins.property
    @pulumi.getter
    def comment(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Optional tag explanation. Example: `Used to tag primary replica metrics`.
        """
        return pulumi.get(self, "comment")

    @comment.setter
    def comment(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "comment", value)


if not MYPY:
    class ServiceIntegrationEndpointExternalAwsCloudwatchLogsUserConfigArgsDict(TypedDict):
        access_key: pulumi.Input[_builtins.str]
        """
        AWS access key. Required permissions are logs:CreateLogGroup, logs:CreateLogStream, logs:PutLogEvents and logs:DescribeLogStreams. Example: `AAAAAAAAAAAAAAAAAAAA`.
        """
        region: pulumi.Input[_builtins.str]
        """
        AWS region. Example: `us-east-1`.
        """
        secret_key: pulumi.Input[_builtins.str]
        """
        AWS secret key. Example: `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`.
        """
        log_group_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        AWS CloudWatch log group name. Example: `my-log-group`.
        """
elif False:
    ServiceIntegrationEndpointExternalAwsCloudwatchLogsUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointExternalAwsCloudwatchLogsUserConfigArgs:
    def __init__(__self__, *,
                 access_key: pulumi.Input[_builtins.str],
                 region: pulumi.Input[_builtins.str],
                 secret_key: pulumi.Input[_builtins.str],
                 log_group_name: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] access_key: AWS access key. Required permissions are logs:CreateLogGroup, logs:CreateLogStream, logs:PutLogEvents and logs:DescribeLogStreams. Example: `AAAAAAAAAAAAAAAAAAAA`.
        :param pulumi.Input[_builtins.str] region: AWS region. Example: `us-east-1`.
        :param pulumi.Input[_builtins.str] secret_key: AWS secret key. Example: `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`.
        :param pulumi.Input[_builtins.str] log_group_name: AWS CloudWatch log group name. Example: `my-log-group`.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> pulumi.Input[_builtins.str]:
        """
        AWS access key. Required permissions are logs:CreateLogGroup, logs:CreateLogStream, logs:PutLogEvents and logs:DescribeLogStreams. Example: `AAAAAAAAAAAAAAAAAAAA`.
        """
        return pulumi.get(self, "access_key")

    @access_key.setter
    def access_key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "access_key", value)

    @_builtins.property
    @pulumi.getter
    def region(self) -> pulumi.Input[_builtins.str]:
        """
        AWS region. Example: `us-east-1`.
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "region", value)

    @_builtins.property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> pulumi.Input[_builtins.str]:
        """
        AWS secret key. Example: `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`.
        """
        return pulumi.get(self, "secret_key")

    @secret_key.setter
    def secret_key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "secret_key", value)

    @_builtins.property
    @pulumi.getter(name="logGroupName")
    def log_group_name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        AWS CloudWatch log group name. Example: `my-log-group`.
        """
        return pulumi.get(self, "log_group_name")

    @log_group_name.setter
    def log_group_name(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "log_group_name", value)


if not MYPY:
    class ServiceIntegrationEndpointExternalAwsCloudwatchMetricsUserConfigArgsDict(TypedDict):
        access_key: pulumi.Input[_builtins.str]
        """
        AWS access key. Required permissions are cloudwatch:PutMetricData. Example: `AAAAAAAAAAAAAAAAAAAA`.
        """
        namespace: pulumi.Input[_builtins.str]
        """
        AWS CloudWatch Metrics Namespace. Example: `my-metrics-namespace`.
        """
        region: pulumi.Input[_builtins.str]
        """
        AWS region. Example: `us-east-1`.
        """
        secret_key: pulumi.Input[_builtins.str]
        """
        AWS secret key. Example: `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`.
        """
elif False:
    ServiceIntegrationEndpointExternalAwsCloudwatchMetricsUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointExternalAwsCloudwatchMetricsUserConfigArgs:
    def __init__(__self__, *,
                 access_key: pulumi.Input[_builtins.str],
                 namespace: pulumi.Input[_builtins.str],
                 region: pulumi.Input[_builtins.str],
                 secret_key: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] access_key: AWS access key. Required permissions are cloudwatch:PutMetricData. Example: `AAAAAAAAAAAAAAAAAAAA`.
        :param pulumi.Input[_builtins.str] namespace: AWS CloudWatch Metrics Namespace. Example: `my-metrics-namespace`.
        :param pulumi.Input[_builtins.str] region: AWS region. Example: `us-east-1`.
        :param pulumi.Input[_builtins.str] secret_key: AWS secret key. Example: `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`.
        """
        pulumi.set(__self__, "access_key", access_key)
        pulumi.set(__self__, "namespace", namespace)
        pulumi.set(__self__, "region", region)
        pulumi.set(__self__, "secret_key", secret_key)

    @_builtins.property
    @pulumi.getter(name="accessKey")
    def access_key(self) -> pulumi.Input[_builtins.str]:
        """
        AWS access key. Required permissions are cloudwatch:PutMetricData. Example: `AAAAAAAAAAAAAAAAAAAA`.
        """
        return pulumi.get(self, "access_key")

    @access_key.setter
    def access_key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "access_key", value)

    @_builtins.property
    @pulumi.getter
    def namespace(self) -> pulumi.Input[_builtins.str]:
        """
        AWS CloudWatch Metrics Namespace. Example: `my-metrics-namespace`.
        """
        return pulumi.get(self, "namespace")

    @namespace.setter
    def namespace(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "namespace", value)

    @_builtins.property
    @pulumi.getter
    def region(self) -> pulumi.Input[_builtins.str]:
        """
        AWS region. Example: `us-east-1`.
        """
        return pulumi.get(self, "region")

    @region.setter
    def region(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "region", value)

    @_builtins.property
    @pulumi.getter(name="secretKey")
    def secret_key(self) -> pulumi.Input[_builtins.str]:
        """
        AWS secret key. Example: `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`.
        """
        return pulumi.get(self, "secret_key")

    @secret_key.setter
    def secret_key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "secret_key", value)


if not MYPY:
    class ServiceIntegrationEndpointExternalAwsS3UserConfigArgsDict(TypedDict):
        access_key_id: pulumi.Input[_builtins.str]
        """
        Access Key Id. Example: `AAAAAAAAAAAAAAAAAAA`.
        """
        secret_access_key: pulumi.Input[_builtins.str]
        """
        Secret Access Key. Example: `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`.
        """
        url: pulumi.Input[_builtins.str]
        """
        S3-compatible bucket URL. Example: `https://mybucket.s3-myregion.amazonaws.com/mydataset/`.
        """
elif False:
    ServiceIntegrationEndpointExternalAwsS3UserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointExternalAwsS3UserConfigArgs:
    def __init__(__self__, *,
                 access_key_id: pulumi.Input[_builtins.str],
                 secret_access_key: pulumi.Input[_builtins.str],
                 url: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] access_key_id: Access Key Id. Example: `AAAAAAAAAAAAAAAAAAA`.
        :param pulumi.Input[_builtins.str] secret_access_key: Secret Access Key. Example: `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`.
        :param pulumi.Input[_builtins.str] url: S3-compatible bucket URL. Example: `https://mybucket.s3-myregion.amazonaws.com/mydataset/`.
        """
        pulumi.set(__self__, "access_key_id", access_key_id)
        pulumi.set(__self__, "secret_access_key", secret_access_key)
        pulumi.set(__self__, "url", url)

    @_builtins.property
    @pulumi.getter(name="accessKeyId")
    def access_key_id(self) -> pulumi.Input[_builtins.str]:
        """
        Access Key Id. Example: `AAAAAAAAAAAAAAAAAAA`.
        """
        return pulumi.get(self, "access_key_id")

    @access_key_id.setter
    def access_key_id(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "access_key_id", value)

    @_builtins.property
    @pulumi.getter(name="secretAccessKey")
    def secret_access_key(self) -> pulumi.Input[_builtins.str]:
        """
        Secret Access Key. Example: `AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA`.
        """
        return pulumi.get(self, "secret_access_key")

    @secret_access_key.setter
    def secret_access_key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "secret_access_key", value)

    @_builtins.property
    @pulumi.getter
    def url(self) -> pulumi.Input[_builtins.str]:
        """
        S3-compatible bucket URL. Example: `https://mybucket.s3-myregion.amazonaws.com/mydataset/`.
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "url", value)


if not MYPY:
    class ServiceIntegrationEndpointExternalAzureBlobStorageUserConfigArgsDict(TypedDict):
        connection_string: pulumi.Input[_builtins.str]
        """
        Azure Blob Storage connection string. Example: `AccountName=IDENT;AccountKey=SECRET`.
        """
        container: pulumi.Input[_builtins.str]
        """
        Container. Example: `container-dev`.
        """
        blob_path: NotRequired[pulumi.Input[_builtins.str]]
        """
        Blob path. Example: `path/to/blob/file.csv`.
        """
elif False:
    ServiceIntegrationEndpointExternalAzureBlobStorageUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointExternalAzureBlobStorageUserConfigArgs:
    def __init__(__self__, *,
                 connection_string: pulumi.Input[_builtins.str],
                 container: pulumi.Input[_builtins.str],
                 blob_path: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] connection_string: Azure Blob Storage connection string. Example: `AccountName=IDENT;AccountKey=SECRET`.
        :param pulumi.Input[_builtins.str] container: Container. Example: `container-dev`.
        :param pulumi.Input[_builtins.str] blob_path: Blob path. Example: `path/to/blob/file.csv`.
        """
        pulumi.set(__self__, "connection_string", connection_string)
        pulumi.set(__self__, "container", container)
        if blob_path is not None:
            pulumi.set(__self__, "blob_path", blob_path)

    @_builtins.property
    @pulumi.getter(name="connectionString")
    def connection_string(self) -> pulumi.Input[_builtins.str]:
        """
        Azure Blob Storage connection string. Example: `AccountName=IDENT;AccountKey=SECRET`.
        """
        return pulumi.get(self, "connection_string")

    @connection_string.setter
    def connection_string(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "connection_string", value)

    @_builtins.property
    @pulumi.getter
    def container(self) -> pulumi.Input[_builtins.str]:
        """
        Container. Example: `container-dev`.
        """
        return pulumi.get(self, "container")

    @container.setter
    def container(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "container", value)

    @_builtins.property
    @pulumi.getter(name="blobPath")
    def blob_path(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Blob path. Example: `path/to/blob/file.csv`.
        """
        return pulumi.get(self, "blob_path")

    @blob_path.setter
    def blob_path(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "blob_path", value)


if not MYPY:
    class ServiceIntegrationEndpointExternalClickhouseUserConfigArgsDict(TypedDict):
        host: pulumi.Input[_builtins.str]
        """
        Hostname or IP address of the server. Example: `my.server.com`.
        """
        password: pulumi.Input[_builtins.str]
        """
        Password. Example: `jjKk45Nnd`.
        """
        port: pulumi.Input[_builtins.int]
        """
        Secure TCP server port. Example: `9440`.
        """
        username: pulumi.Input[_builtins.str]
        """
        User name. Example: `default`.
        """
elif False:
    ServiceIntegrationEndpointExternalClickhouseUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointExternalClickhouseUserConfigArgs:
    def __init__(__self__, *,
                 host: pulumi.Input[_builtins.str],
                 password: pulumi.Input[_builtins.str],
                 port: pulumi.Input[_builtins.int],
                 username: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] host: Hostname or IP address of the server. Example: `my.server.com`.
        :param pulumi.Input[_builtins.str] password: Password. Example: `jjKk45Nnd`.
        :param pulumi.Input[_builtins.int] port: Secure TCP server port. Example: `9440`.
        :param pulumi.Input[_builtins.str] username: User name. Example: `default`.
        """
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "username", username)

    @_builtins.property
    @pulumi.getter
    def host(self) -> pulumi.Input[_builtins.str]:
        """
        Hostname or IP address of the server. Example: `my.server.com`.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter
    def password(self) -> pulumi.Input[_builtins.str]:
        """
        Password. Example: `jjKk45Nnd`.
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "password", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> pulumi.Input[_builtins.int]:
        """
        Secure TCP server port. Example: `9440`.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def username(self) -> pulumi.Input[_builtins.str]:
        """
        User name. Example: `default`.
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "username", value)


if not MYPY:
    class ServiceIntegrationEndpointExternalElasticsearchLogsUserConfigArgsDict(TypedDict):
        index_prefix: pulumi.Input[_builtins.str]
        """
        Elasticsearch index prefix. Default: `logs`.
        """
        url: pulumi.Input[_builtins.str]
        """
        Elasticsearch connection URL. Example: `https://user:passwd@logs.example.com/`.
        """
        ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        PEM encoded CA certificate. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        index_days_max: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum number of days of logs to keep. Default: `3`.
        """
        timeout: NotRequired[pulumi.Input[_builtins.float]]
        """
        Elasticsearch request timeout limit. Default: `10`.
        """
elif False:
    ServiceIntegrationEndpointExternalElasticsearchLogsUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointExternalElasticsearchLogsUserConfigArgs:
    def __init__(__self__, *,
                 index_prefix: pulumi.Input[_builtins.str],
                 url: pulumi.Input[_builtins.str],
                 ca: Optional[pulumi.Input[_builtins.str]] = None,
                 index_days_max: Optional[pulumi.Input[_builtins.int]] = None,
                 timeout: Optional[pulumi.Input[_builtins.float]] = None):
        """
        :param pulumi.Input[_builtins.str] index_prefix: Elasticsearch index prefix. Default: `logs`.
        :param pulumi.Input[_builtins.str] url: Elasticsearch connection URL. Example: `https://user:passwd@logs.example.com/`.
        :param pulumi.Input[_builtins.str] ca: PEM encoded CA certificate. Example: `-----BEGIN CERTIFICATE-----
               ...
               -----END CERTIFICATE-----
               `.
        :param pulumi.Input[_builtins.int] index_days_max: Maximum number of days of logs to keep. Default: `3`.
        :param pulumi.Input[_builtins.float] timeout: Elasticsearch request timeout limit. Default: `10`.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="indexPrefix")
    def index_prefix(self) -> pulumi.Input[_builtins.str]:
        """
        Elasticsearch index prefix. Default: `logs`.
        """
        return pulumi.get(self, "index_prefix")

    @index_prefix.setter
    def index_prefix(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "index_prefix", value)

    @_builtins.property
    @pulumi.getter
    def url(self) -> pulumi.Input[_builtins.str]:
        """
        Elasticsearch connection URL. Example: `https://user:passwd@logs.example.com/`.
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "url", value)

    @_builtins.property
    @pulumi.getter
    def ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PEM encoded CA certificate. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        return pulumi.get(self, "ca")

    @ca.setter
    def ca(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ca", value)

    @_builtins.property
    @pulumi.getter(name="indexDaysMax")
    def index_days_max(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum number of days of logs to keep. Default: `3`.
        """
        return pulumi.get(self, "index_days_max")

    @index_days_max.setter
    def index_days_max(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "index_days_max", value)

    @_builtins.property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        Elasticsearch request timeout limit. Default: `10`.
        """
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "timeout", value)


if not MYPY:
    class ServiceIntegrationEndpointExternalGoogleCloudBigqueryArgsDict(TypedDict):
        project_id: pulumi.Input[_builtins.str]
        """
        GCP project id. Example: `snappy-photon-12345`.
        """
        service_account_credentials: pulumi.Input[_builtins.str]
        """
        This is a JSON object with the fields documented in https://cloud.google.com/iam/docs/creating-managing-service-account-keys. Example: `{"type": "service_account", ...`.
        """
elif False:
    ServiceIntegrationEndpointExternalGoogleCloudBigqueryArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointExternalGoogleCloudBigqueryArgs:
    def __init__(__self__, *,
                 project_id: pulumi.Input[_builtins.str],
                 service_account_credentials: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] project_id: GCP project id. Example: `snappy-photon-12345`.
        :param pulumi.Input[_builtins.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. Example: `{"type": "service_account", ...`.
        """
        pulumi.set(__self__, "project_id", project_id)
        pulumi.set(__self__, "service_account_credentials", service_account_credentials)

    @_builtins.property
    @pulumi.getter(name="projectId")
    def project_id(self) -> pulumi.Input[_builtins.str]:
        """
        GCP project id. Example: `snappy-photon-12345`.
        """
        return pulumi.get(self, "project_id")

    @project_id.setter
    def project_id(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "project_id", value)

    @_builtins.property
    @pulumi.getter(name="serviceAccountCredentials")
    def service_account_credentials(self) -> pulumi.Input[_builtins.str]:
        """
        This is a JSON object with the fields documented in https://cloud.google.com/iam/docs/creating-managing-service-account-keys. Example: `{"type": "service_account", ...`.
        """
        return pulumi.get(self, "service_account_credentials")

    @service_account_credentials.setter
    def service_account_credentials(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "service_account_credentials", value)


if not MYPY:
    class ServiceIntegrationEndpointExternalGoogleCloudLoggingUserConfigArgsDict(TypedDict):
        log_id: pulumi.Input[_builtins.str]
        """
        Google Cloud Logging log id. Example: `syslog`.
        """
        project_id: pulumi.Input[_builtins.str]
        """
        GCP project id. Example: `snappy-photon-12345`.
        """
        service_account_credentials: pulumi.Input[_builtins.str]
        """
        This is a JSON object with the fields documented in https://cloud.google.com/iam/docs/creating-managing-service-account-keys. Example: `{"type": "service_account", ...`.
        """
elif False:
    ServiceIntegrationEndpointExternalGoogleCloudLoggingUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointExternalGoogleCloudLoggingUserConfigArgs:
    def __init__(__self__, *,
                 log_id: pulumi.Input[_builtins.str],
                 project_id: pulumi.Input[_builtins.str],
                 service_account_credentials: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] log_id: Google Cloud Logging log id. Example: `syslog`.
        :param pulumi.Input[_builtins.str] project_id: GCP project id. Example: `snappy-photon-12345`.
        :param pulumi.Input[_builtins.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. Example: `{"type": "service_account", ...`.
        """
        pulumi.set(__self__, "log_id", log_id)
        pulumi.set(__self__, "project_id", project_id)
        pulumi.set(__self__, "service_account_credentials", service_account_credentials)

    @_builtins.property
    @pulumi.getter(name="logId")
    def log_id(self) -> pulumi.Input[_builtins.str]:
        """
        Google Cloud Logging log id. Example: `syslog`.
        """
        return pulumi.get(self, "log_id")

    @log_id.setter
    def log_id(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "log_id", value)

    @_builtins.property
    @pulumi.getter(name="projectId")
    def project_id(self) -> pulumi.Input[_builtins.str]:
        """
        GCP project id. Example: `snappy-photon-12345`.
        """
        return pulumi.get(self, "project_id")

    @project_id.setter
    def project_id(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "project_id", value)

    @_builtins.property
    @pulumi.getter(name="serviceAccountCredentials")
    def service_account_credentials(self) -> pulumi.Input[_builtins.str]:
        """
        This is a JSON object with the fields documented in https://cloud.google.com/iam/docs/creating-managing-service-account-keys. Example: `{"type": "service_account", ...`.
        """
        return pulumi.get(self, "service_account_credentials")

    @service_account_credentials.setter
    def service_account_credentials(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "service_account_credentials", value)


if not MYPY:
    class ServiceIntegrationEndpointExternalKafkaUserConfigArgsDict(TypedDict):
        bootstrap_servers: pulumi.Input[_builtins.str]
        """
        Bootstrap servers. Example: `10.0.0.1:9092,10.0.0.2:9092`.
        """
        security_protocol: pulumi.Input[_builtins.str]
        """
        Enum: `PLAINTEXT`, `SASL_PLAINTEXT`, `SASL_SSL`, `SSL`. Security protocol.
        """
        sasl_mechanism: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `PLAIN`, `SCRAM-SHA-256`, `SCRAM-SHA-512`. SASL mechanism used for connections to the Kafka server.
        """
        sasl_plain_password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Password for SASL PLAIN mechanism in the Kafka server. Example: `admin`.
        """
        sasl_plain_username: NotRequired[pulumi.Input[_builtins.str]]
        """
        Username for SASL PLAIN mechanism in the Kafka server. Example: `admin`.
        """
        ssl_ca_cert: NotRequired[pulumi.Input[_builtins.str]]
        """
        PEM-encoded CA certificate. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        ssl_client_cert: NotRequired[pulumi.Input[_builtins.str]]
        """
        PEM-encoded client certificate. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        ssl_client_key: NotRequired[pulumi.Input[_builtins.str]]
        """
        PEM-encoded client key. Example: `-----BEGIN PRIVATE KEY-----
        ...
        -----END PRIVATE KEY-----
        `.
        """
        ssl_endpoint_identification_algorithm: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `https`. The endpoint identification algorithm to validate server hostname using server certificate.
        """
elif False:
    ServiceIntegrationEndpointExternalKafkaUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointExternalKafkaUserConfigArgs:
    def __init__(__self__, *,
                 bootstrap_servers: pulumi.Input[_builtins.str],
                 security_protocol: pulumi.Input[_builtins.str],
                 sasl_mechanism: Optional[pulumi.Input[_builtins.str]] = None,
                 sasl_plain_password: Optional[pulumi.Input[_builtins.str]] = None,
                 sasl_plain_username: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl_ca_cert: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl_client_cert: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl_client_key: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl_endpoint_identification_algorithm: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] bootstrap_servers: Bootstrap servers. Example: `10.0.0.1:9092,10.0.0.2:9092`.
        :param pulumi.Input[_builtins.str] security_protocol: Enum: `PLAINTEXT`, `SASL_PLAINTEXT`, `SASL_SSL`, `SSL`. Security protocol.
        :param pulumi.Input[_builtins.str] sasl_mechanism: Enum: `PLAIN`, `SCRAM-SHA-256`, `SCRAM-SHA-512`. SASL mechanism used for connections to the Kafka server.
        :param pulumi.Input[_builtins.str] sasl_plain_password: Password for SASL PLAIN mechanism in the Kafka server. Example: `admin`.
        :param pulumi.Input[_builtins.str] sasl_plain_username: Username for SASL PLAIN mechanism in the Kafka server. Example: `admin`.
        :param pulumi.Input[_builtins.str] ssl_ca_cert: PEM-encoded CA certificate. Example: `-----BEGIN CERTIFICATE-----
               ...
               -----END CERTIFICATE-----
               `.
        :param pulumi.Input[_builtins.str] ssl_client_cert: PEM-encoded client certificate. Example: `-----BEGIN CERTIFICATE-----
               ...
               -----END CERTIFICATE-----
               `.
        :param pulumi.Input[_builtins.str] ssl_client_key: PEM-encoded client key. Example: `-----BEGIN PRIVATE KEY-----
               ...
               -----END PRIVATE KEY-----
               `.
        :param pulumi.Input[_builtins.str] ssl_endpoint_identification_algorithm: Enum: `https`. 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)

    @_builtins.property
    @pulumi.getter(name="bootstrapServers")
    def bootstrap_servers(self) -> pulumi.Input[_builtins.str]:
        """
        Bootstrap servers. Example: `10.0.0.1:9092,10.0.0.2:9092`.
        """
        return pulumi.get(self, "bootstrap_servers")

    @bootstrap_servers.setter
    def bootstrap_servers(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "bootstrap_servers", value)

    @_builtins.property
    @pulumi.getter(name="securityProtocol")
    def security_protocol(self) -> pulumi.Input[_builtins.str]:
        """
        Enum: `PLAINTEXT`, `SASL_PLAINTEXT`, `SASL_SSL`, `SSL`. Security protocol.
        """
        return pulumi.get(self, "security_protocol")

    @security_protocol.setter
    def security_protocol(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "security_protocol", value)

    @_builtins.property
    @pulumi.getter(name="saslMechanism")
    def sasl_mechanism(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `PLAIN`, `SCRAM-SHA-256`, `SCRAM-SHA-512`. 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[_builtins.str]]):
        pulumi.set(self, "sasl_mechanism", value)

    @_builtins.property
    @pulumi.getter(name="saslPlainPassword")
    def sasl_plain_password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Password for SASL PLAIN mechanism in the Kafka server. Example: `admin`.
        """
        return pulumi.get(self, "sasl_plain_password")

    @sasl_plain_password.setter
    def sasl_plain_password(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "sasl_plain_password", value)

    @_builtins.property
    @pulumi.getter(name="saslPlainUsername")
    def sasl_plain_username(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Username for SASL PLAIN mechanism in the Kafka server. Example: `admin`.
        """
        return pulumi.get(self, "sasl_plain_username")

    @sasl_plain_username.setter
    def sasl_plain_username(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "sasl_plain_username", value)

    @_builtins.property
    @pulumi.getter(name="sslCaCert")
    def ssl_ca_cert(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PEM-encoded CA certificate. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        return pulumi.get(self, "ssl_ca_cert")

    @ssl_ca_cert.setter
    def ssl_ca_cert(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ssl_ca_cert", value)

    @_builtins.property
    @pulumi.getter(name="sslClientCert")
    def ssl_client_cert(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PEM-encoded client certificate. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        return pulumi.get(self, "ssl_client_cert")

    @ssl_client_cert.setter
    def ssl_client_cert(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ssl_client_cert", value)

    @_builtins.property
    @pulumi.getter(name="sslClientKey")
    def ssl_client_key(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PEM-encoded client key. Example: `-----BEGIN PRIVATE KEY-----
        ...
        -----END PRIVATE KEY-----
        `.
        """
        return pulumi.get(self, "ssl_client_key")

    @ssl_client_key.setter
    def ssl_client_key(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ssl_client_key", value)

    @_builtins.property
    @pulumi.getter(name="sslEndpointIdentificationAlgorithm")
    def ssl_endpoint_identification_algorithm(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `https`. 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[_builtins.str]]):
        pulumi.set(self, "ssl_endpoint_identification_algorithm", value)


if not MYPY:
    class ServiceIntegrationEndpointExternalMysqlUserConfigArgsDict(TypedDict):
        host: pulumi.Input[_builtins.str]
        """
        Hostname or IP address of the server. Example: `my.server.com`.
        """
        password: pulumi.Input[_builtins.str]
        """
        Password. Example: `jjKk45Nnd`.
        """
        port: pulumi.Input[_builtins.int]
        """
        Port number of the server. Example: `5432`.
        """
        username: pulumi.Input[_builtins.str]
        """
        User name. Example: `myname`.
        """
        ssl_mode: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `verify-full`. SSL Mode. Default: `verify-full`.
        """
        ssl_root_cert: NotRequired[pulumi.Input[_builtins.str]]
        """
        SSL Root Cert. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
elif False:
    ServiceIntegrationEndpointExternalMysqlUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointExternalMysqlUserConfigArgs:
    def __init__(__self__, *,
                 host: pulumi.Input[_builtins.str],
                 password: pulumi.Input[_builtins.str],
                 port: pulumi.Input[_builtins.int],
                 username: pulumi.Input[_builtins.str],
                 ssl_mode: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl_root_cert: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] host: Hostname or IP address of the server. Example: `my.server.com`.
        :param pulumi.Input[_builtins.str] password: Password. Example: `jjKk45Nnd`.
        :param pulumi.Input[_builtins.int] port: Port number of the server. Example: `5432`.
        :param pulumi.Input[_builtins.str] username: User name. Example: `myname`.
        :param pulumi.Input[_builtins.str] ssl_mode: Enum: `verify-full`. SSL Mode. Default: `verify-full`.
        :param pulumi.Input[_builtins.str] ssl_root_cert: SSL Root Cert. Example: `-----BEGIN CERTIFICATE-----
               ...
               -----END CERTIFICATE-----
               `.
        """
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "password", password)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "username", username)
        if ssl_mode is not None:
            pulumi.set(__self__, "ssl_mode", ssl_mode)
        if ssl_root_cert is not None:
            pulumi.set(__self__, "ssl_root_cert", ssl_root_cert)

    @_builtins.property
    @pulumi.getter
    def host(self) -> pulumi.Input[_builtins.str]:
        """
        Hostname or IP address of the server. Example: `my.server.com`.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter
    def password(self) -> pulumi.Input[_builtins.str]:
        """
        Password. Example: `jjKk45Nnd`.
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "password", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> pulumi.Input[_builtins.int]:
        """
        Port number of the server. Example: `5432`.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def username(self) -> pulumi.Input[_builtins.str]:
        """
        User name. Example: `myname`.
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "username", value)

    @_builtins.property
    @pulumi.getter(name="sslMode")
    def ssl_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `verify-full`. SSL Mode. Default: `verify-full`.
        """
        return pulumi.get(self, "ssl_mode")

    @ssl_mode.setter
    def ssl_mode(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ssl_mode", value)

    @_builtins.property
    @pulumi.getter(name="sslRootCert")
    def ssl_root_cert(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        SSL Root Cert. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        return pulumi.get(self, "ssl_root_cert")

    @ssl_root_cert.setter
    def ssl_root_cert(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ssl_root_cert", value)


if not MYPY:
    class ServiceIntegrationEndpointExternalOpensearchLogsUserConfigArgsDict(TypedDict):
        index_prefix: pulumi.Input[_builtins.str]
        """
        OpenSearch index prefix. Default: `logs`.
        """
        url: pulumi.Input[_builtins.str]
        """
        OpenSearch connection URL. Example: `https://user:passwd@logs.example.com/`.
        """
        ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        PEM encoded CA certificate. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        index_days_max: NotRequired[pulumi.Input[_builtins.int]]
        """
        Maximum number of days of logs to keep. Default: `3`.
        """
        timeout: NotRequired[pulumi.Input[_builtins.float]]
        """
        OpenSearch request timeout limit. Default: `10`.
        """
elif False:
    ServiceIntegrationEndpointExternalOpensearchLogsUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointExternalOpensearchLogsUserConfigArgs:
    def __init__(__self__, *,
                 index_prefix: pulumi.Input[_builtins.str],
                 url: pulumi.Input[_builtins.str],
                 ca: Optional[pulumi.Input[_builtins.str]] = None,
                 index_days_max: Optional[pulumi.Input[_builtins.int]] = None,
                 timeout: Optional[pulumi.Input[_builtins.float]] = None):
        """
        :param pulumi.Input[_builtins.str] index_prefix: OpenSearch index prefix. Default: `logs`.
        :param pulumi.Input[_builtins.str] url: OpenSearch connection URL. Example: `https://user:passwd@logs.example.com/`.
        :param pulumi.Input[_builtins.str] ca: PEM encoded CA certificate. Example: `-----BEGIN CERTIFICATE-----
               ...
               -----END CERTIFICATE-----
               `.
        :param pulumi.Input[_builtins.int] index_days_max: Maximum number of days of logs to keep. Default: `3`.
        :param pulumi.Input[_builtins.float] timeout: OpenSearch request timeout limit. Default: `10`.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="indexPrefix")
    def index_prefix(self) -> pulumi.Input[_builtins.str]:
        """
        OpenSearch index prefix. Default: `logs`.
        """
        return pulumi.get(self, "index_prefix")

    @index_prefix.setter
    def index_prefix(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "index_prefix", value)

    @_builtins.property
    @pulumi.getter
    def url(self) -> pulumi.Input[_builtins.str]:
        """
        OpenSearch connection URL. Example: `https://user:passwd@logs.example.com/`.
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "url", value)

    @_builtins.property
    @pulumi.getter
    def ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PEM encoded CA certificate. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        return pulumi.get(self, "ca")

    @ca.setter
    def ca(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ca", value)

    @_builtins.property
    @pulumi.getter(name="indexDaysMax")
    def index_days_max(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Maximum number of days of logs to keep. Default: `3`.
        """
        return pulumi.get(self, "index_days_max")

    @index_days_max.setter
    def index_days_max(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "index_days_max", value)

    @_builtins.property
    @pulumi.getter
    def timeout(self) -> Optional[pulumi.Input[_builtins.float]]:
        """
        OpenSearch request timeout limit. Default: `10`.
        """
        return pulumi.get(self, "timeout")

    @timeout.setter
    def timeout(self, value: Optional[pulumi.Input[_builtins.float]]):
        pulumi.set(self, "timeout", value)


if not MYPY:
    class ServiceIntegrationEndpointExternalPostgresqlArgsDict(TypedDict):
        host: pulumi.Input[_builtins.str]
        """
        Hostname or IP address of the server. Example: `my.server.com`.
        """
        port: pulumi.Input[_builtins.int]
        """
        Port number of the server. Example: `5432`.
        """
        username: pulumi.Input[_builtins.str]
        """
        User name. Example: `myname`.
        """
        default_database: NotRequired[pulumi.Input[_builtins.str]]
        """
        Default database. Example: `testdb`.
        """
        password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Password. Example: `jjKk45Nnd`.
        """
        ssl_client_certificate: NotRequired[pulumi.Input[_builtins.str]]
        """
        Client certificate. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        ssl_client_key: NotRequired[pulumi.Input[_builtins.str]]
        """
        Client key. Example: `-----BEGIN PRIVATE KEY-----
        ...
        -----END PRIVATE KEY-----`.
        """
        ssl_mode: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `allow`, `disable`, `prefer`, `require`, `verify-ca`, `verify-full`. SSL mode to use for the connection. Please note that Aiven requires TLS for all connections to external PostgreSQL services. Default: `verify-full`.
        """
        ssl_root_cert: NotRequired[pulumi.Input[_builtins.str]]
        """
        SSL Root Cert. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
elif False:
    ServiceIntegrationEndpointExternalPostgresqlArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointExternalPostgresqlArgs:
    def __init__(__self__, *,
                 host: pulumi.Input[_builtins.str],
                 port: pulumi.Input[_builtins.int],
                 username: pulumi.Input[_builtins.str],
                 default_database: Optional[pulumi.Input[_builtins.str]] = None,
                 password: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl_client_certificate: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl_client_key: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl_mode: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl_root_cert: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] host: Hostname or IP address of the server. Example: `my.server.com`.
        :param pulumi.Input[_builtins.int] port: Port number of the server. Example: `5432`.
        :param pulumi.Input[_builtins.str] username: User name. Example: `myname`.
        :param pulumi.Input[_builtins.str] default_database: Default database. Example: `testdb`.
        :param pulumi.Input[_builtins.str] password: Password. Example: `jjKk45Nnd`.
        :param pulumi.Input[_builtins.str] ssl_client_certificate: Client certificate. Example: `-----BEGIN CERTIFICATE-----
               ...
               -----END CERTIFICATE-----
               `.
        :param pulumi.Input[_builtins.str] ssl_client_key: Client key. Example: `-----BEGIN PRIVATE KEY-----
               ...
               -----END PRIVATE KEY-----`.
        :param pulumi.Input[_builtins.str] ssl_mode: Enum: `allow`, `disable`, `prefer`, `require`, `verify-ca`, `verify-full`. SSL mode to use for the connection. Please note that Aiven requires TLS for all connections to external PostgreSQL services. Default: `verify-full`.
        :param pulumi.Input[_builtins.str] ssl_root_cert: SSL Root Cert. Example: `-----BEGIN CERTIFICATE-----
               ...
               -----END CERTIFICATE-----
               `.
        """
        pulumi.set(__self__, "host", host)
        pulumi.set(__self__, "port", port)
        pulumi.set(__self__, "username", username)
        if default_database is not None:
            pulumi.set(__self__, "default_database", default_database)
        if password is not None:
            pulumi.set(__self__, "password", password)
        if ssl_client_certificate is not None:
            pulumi.set(__self__, "ssl_client_certificate", ssl_client_certificate)
        if ssl_client_key is not None:
            pulumi.set(__self__, "ssl_client_key", ssl_client_key)
        if ssl_mode is not None:
            pulumi.set(__self__, "ssl_mode", ssl_mode)
        if ssl_root_cert is not None:
            pulumi.set(__self__, "ssl_root_cert", ssl_root_cert)

    @_builtins.property
    @pulumi.getter
    def host(self) -> pulumi.Input[_builtins.str]:
        """
        Hostname or IP address of the server. Example: `my.server.com`.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> pulumi.Input[_builtins.int]:
        """
        Port number of the server. Example: `5432`.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def username(self) -> pulumi.Input[_builtins.str]:
        """
        User name. Example: `myname`.
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "username", value)

    @_builtins.property
    @pulumi.getter(name="defaultDatabase")
    def default_database(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Default database. Example: `testdb`.
        """
        return pulumi.get(self, "default_database")

    @default_database.setter
    def default_database(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "default_database", value)

    @_builtins.property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Password. Example: `jjKk45Nnd`.
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "password", value)

    @_builtins.property
    @pulumi.getter(name="sslClientCertificate")
    def ssl_client_certificate(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Client certificate. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        return pulumi.get(self, "ssl_client_certificate")

    @ssl_client_certificate.setter
    def ssl_client_certificate(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ssl_client_certificate", value)

    @_builtins.property
    @pulumi.getter(name="sslClientKey")
    def ssl_client_key(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Client key. Example: `-----BEGIN PRIVATE KEY-----
        ...
        -----END PRIVATE KEY-----`.
        """
        return pulumi.get(self, "ssl_client_key")

    @ssl_client_key.setter
    def ssl_client_key(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ssl_client_key", value)

    @_builtins.property
    @pulumi.getter(name="sslMode")
    def ssl_mode(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `allow`, `disable`, `prefer`, `require`, `verify-ca`, `verify-full`. SSL mode to use for the connection. Please note that Aiven requires TLS for all connections to external PostgreSQL services. Default: `verify-full`.
        """
        return pulumi.get(self, "ssl_mode")

    @ssl_mode.setter
    def ssl_mode(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ssl_mode", value)

    @_builtins.property
    @pulumi.getter(name="sslRootCert")
    def ssl_root_cert(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        SSL Root Cert. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        return pulumi.get(self, "ssl_root_cert")

    @ssl_root_cert.setter
    def ssl_root_cert(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ssl_root_cert", value)


if not MYPY:
    class ServiceIntegrationEndpointExternalPrometheusUserConfigArgsDict(TypedDict):
        basic_auth_password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Prometheus basic authentication password. Example: `fhyFNBjj3R`.
        """
        basic_auth_username: NotRequired[pulumi.Input[_builtins.str]]
        """
        Prometheus basic authentication username. Example: `prom4851`.
        """
        service_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Prometheus enabled write endpoint. Example: `https://write.example.com/`.
        """
elif False:
    ServiceIntegrationEndpointExternalPrometheusUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointExternalPrometheusUserConfigArgs:
    def __init__(__self__, *,
                 basic_auth_password: Optional[pulumi.Input[_builtins.str]] = None,
                 basic_auth_username: Optional[pulumi.Input[_builtins.str]] = None,
                 service_uri: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] basic_auth_password: Prometheus basic authentication password. Example: `fhyFNBjj3R`.
        :param pulumi.Input[_builtins.str] basic_auth_username: Prometheus basic authentication username. Example: `prom4851`.
        :param pulumi.Input[_builtins.str] service_uri: Prometheus enabled write endpoint. Example: `https://write.example.com/`.
        """
        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)
        if service_uri is not None:
            pulumi.set(__self__, "service_uri", service_uri)

    @_builtins.property
    @pulumi.getter(name="basicAuthPassword")
    def basic_auth_password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Prometheus basic authentication password. Example: `fhyFNBjj3R`.
        """
        return pulumi.get(self, "basic_auth_password")

    @basic_auth_password.setter
    def basic_auth_password(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "basic_auth_password", value)

    @_builtins.property
    @pulumi.getter(name="basicAuthUsername")
    def basic_auth_username(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Prometheus basic authentication username. Example: `prom4851`.
        """
        return pulumi.get(self, "basic_auth_username")

    @basic_auth_username.setter
    def basic_auth_username(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "basic_auth_username", value)

    @_builtins.property
    @pulumi.getter(name="serviceUri")
    def service_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Prometheus enabled write endpoint. Example: `https://write.example.com/`.
        """
        return pulumi.get(self, "service_uri")

    @service_uri.setter
    def service_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "service_uri", value)


if not MYPY:
    class ServiceIntegrationEndpointExternalSchemaRegistryUserConfigArgsDict(TypedDict):
        authentication: pulumi.Input[_builtins.str]
        """
        Enum: `basic`, `none`. Authentication method.
        """
        url: pulumi.Input[_builtins.str]
        """
        Schema Registry URL. Example: `https://schema-registry.kafka.company.com:28419`.
        """
        basic_auth_password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Basic authentication password. Example: `Zm9vYg==`.
        """
        basic_auth_username: NotRequired[pulumi.Input[_builtins.str]]
        """
        Basic authentication user name. Example: `avnadmin`.
        """
elif False:
    ServiceIntegrationEndpointExternalSchemaRegistryUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointExternalSchemaRegistryUserConfigArgs:
    def __init__(__self__, *,
                 authentication: pulumi.Input[_builtins.str],
                 url: pulumi.Input[_builtins.str],
                 basic_auth_password: Optional[pulumi.Input[_builtins.str]] = None,
                 basic_auth_username: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] authentication: Enum: `basic`, `none`. Authentication method.
        :param pulumi.Input[_builtins.str] url: Schema Registry URL. Example: `https://schema-registry.kafka.company.com:28419`.
        :param pulumi.Input[_builtins.str] basic_auth_password: Basic authentication password. Example: `Zm9vYg==`.
        :param pulumi.Input[_builtins.str] basic_auth_username: Basic authentication user name. Example: `avnadmin`.
        """
        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)

    @_builtins.property
    @pulumi.getter
    def authentication(self) -> pulumi.Input[_builtins.str]:
        """
        Enum: `basic`, `none`. Authentication method.
        """
        return pulumi.get(self, "authentication")

    @authentication.setter
    def authentication(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "authentication", value)

    @_builtins.property
    @pulumi.getter
    def url(self) -> pulumi.Input[_builtins.str]:
        """
        Schema Registry URL. Example: `https://schema-registry.kafka.company.com:28419`.
        """
        return pulumi.get(self, "url")

    @url.setter
    def url(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "url", value)

    @_builtins.property
    @pulumi.getter(name="basicAuthPassword")
    def basic_auth_password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Basic authentication password. Example: `Zm9vYg==`.
        """
        return pulumi.get(self, "basic_auth_password")

    @basic_auth_password.setter
    def basic_auth_password(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "basic_auth_password", value)

    @_builtins.property
    @pulumi.getter(name="basicAuthUsername")
    def basic_auth_username(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Basic authentication user name. Example: `avnadmin`.
        """
        return pulumi.get(self, "basic_auth_username")

    @basic_auth_username.setter
    def basic_auth_username(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "basic_auth_username", value)


if not MYPY:
    class ServiceIntegrationEndpointJolokiaUserConfigArgsDict(TypedDict):
        basic_auth_password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Jolokia basic authentication password. Example: `yhfBNFii4C`.
        """
        basic_auth_username: NotRequired[pulumi.Input[_builtins.str]]
        """
        Jolokia basic authentication username. Example: `jol48k51`.
        """
elif False:
    ServiceIntegrationEndpointJolokiaUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointJolokiaUserConfigArgs:
    def __init__(__self__, *,
                 basic_auth_password: Optional[pulumi.Input[_builtins.str]] = None,
                 basic_auth_username: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] basic_auth_password: Jolokia basic authentication password. Example: `yhfBNFii4C`.
        :param pulumi.Input[_builtins.str] basic_auth_username: Jolokia basic authentication username. Example: `jol48k51`.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="basicAuthPassword")
    def basic_auth_password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Jolokia basic authentication password. Example: `yhfBNFii4C`.
        """
        return pulumi.get(self, "basic_auth_password")

    @basic_auth_password.setter
    def basic_auth_password(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "basic_auth_password", value)

    @_builtins.property
    @pulumi.getter(name="basicAuthUsername")
    def basic_auth_username(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Jolokia basic authentication username. Example: `jol48k51`.
        """
        return pulumi.get(self, "basic_auth_username")

    @basic_auth_username.setter
    def basic_auth_username(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "basic_auth_username", value)


if not MYPY:
    class ServiceIntegrationEndpointPrometheusUserConfigArgsDict(TypedDict):
        basic_auth_password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Prometheus basic authentication password. Example: `fhyFNBjj3R`.
        """
        basic_auth_username: NotRequired[pulumi.Input[_builtins.str]]
        """
        Prometheus basic authentication username. Example: `prom4851`.
        """
elif False:
    ServiceIntegrationEndpointPrometheusUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointPrometheusUserConfigArgs:
    def __init__(__self__, *,
                 basic_auth_password: Optional[pulumi.Input[_builtins.str]] = None,
                 basic_auth_username: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] basic_auth_password: Prometheus basic authentication password. Example: `fhyFNBjj3R`.
        :param pulumi.Input[_builtins.str] basic_auth_username: Prometheus basic authentication username. Example: `prom4851`.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="basicAuthPassword")
    def basic_auth_password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Prometheus basic authentication password. Example: `fhyFNBjj3R`.
        """
        return pulumi.get(self, "basic_auth_password")

    @basic_auth_password.setter
    def basic_auth_password(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "basic_auth_password", value)

    @_builtins.property
    @pulumi.getter(name="basicAuthUsername")
    def basic_auth_username(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Prometheus basic authentication username. Example: `prom4851`.
        """
        return pulumi.get(self, "basic_auth_username")

    @basic_auth_username.setter
    def basic_auth_username(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "basic_auth_username", value)


if not MYPY:
    class ServiceIntegrationEndpointRsyslogUserConfigArgsDict(TypedDict):
        format: pulumi.Input[_builtins.str]
        """
        Enum: `custom`, `rfc3164`, `rfc5424`. Message format. Default: `rfc5424`.
        """
        port: pulumi.Input[_builtins.int]
        """
        Rsyslog server port. Default: `514`.
        """
        server: pulumi.Input[_builtins.str]
        """
        Rsyslog server IP address or hostname. Example: `logs.example.com`.
        """
        tls: pulumi.Input[_builtins.bool]
        """
        Require TLS. Default: `true`.
        """
        ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        PEM encoded CA certificate. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        cert: NotRequired[pulumi.Input[_builtins.str]]
        """
        PEM encoded client certificate. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        key: NotRequired[pulumi.Input[_builtins.str]]
        """
        PEM encoded client key. Example: `-----BEGIN PRIVATE KEY-----
        ...
        -----END PRIVATE KEY-----
        `.
        """
        logline: NotRequired[pulumi.Input[_builtins.str]]
        """
        Custom syslog message format. Example: `<%pri%>%timestamp:::date-rfc3339% %HOSTNAME% %app-name% %msg%`.
        """
        max_message_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        Rsyslog max message size. Default: `8192`.
        """
        sd: NotRequired[pulumi.Input[_builtins.str]]
        """
        Structured data block for log message. Example: `TOKEN tag="LiteralValue"`.
        """
elif False:
    ServiceIntegrationEndpointRsyslogUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationEndpointRsyslogUserConfigArgs:
    def __init__(__self__, *,
                 format: pulumi.Input[_builtins.str],
                 port: pulumi.Input[_builtins.int],
                 server: pulumi.Input[_builtins.str],
                 tls: pulumi.Input[_builtins.bool],
                 ca: Optional[pulumi.Input[_builtins.str]] = None,
                 cert: Optional[pulumi.Input[_builtins.str]] = None,
                 key: Optional[pulumi.Input[_builtins.str]] = None,
                 logline: Optional[pulumi.Input[_builtins.str]] = None,
                 max_message_size: Optional[pulumi.Input[_builtins.int]] = None,
                 sd: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] format: Enum: `custom`, `rfc3164`, `rfc5424`. Message format. Default: `rfc5424`.
        :param pulumi.Input[_builtins.int] port: Rsyslog server port. Default: `514`.
        :param pulumi.Input[_builtins.str] server: Rsyslog server IP address or hostname. Example: `logs.example.com`.
        :param pulumi.Input[_builtins.bool] tls: Require TLS. Default: `true`.
        :param pulumi.Input[_builtins.str] ca: PEM encoded CA certificate. Example: `-----BEGIN CERTIFICATE-----
               ...
               -----END CERTIFICATE-----
               `.
        :param pulumi.Input[_builtins.str] cert: PEM encoded client certificate. Example: `-----BEGIN CERTIFICATE-----
               ...
               -----END CERTIFICATE-----
               `.
        :param pulumi.Input[_builtins.str] key: PEM encoded client key. Example: `-----BEGIN PRIVATE KEY-----
               ...
               -----END PRIVATE KEY-----
               `.
        :param pulumi.Input[_builtins.str] logline: Custom syslog message format. Example: `<%pri%>%timestamp:::date-rfc3339% %HOSTNAME% %app-name% %msg%`.
        :param pulumi.Input[_builtins.int] max_message_size: Rsyslog max message size. Default: `8192`.
        :param pulumi.Input[_builtins.str] sd: Structured data block for log message. Example: `TOKEN tag="LiteralValue"`.
        """
        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 max_message_size is not None:
            pulumi.set(__self__, "max_message_size", max_message_size)
        if sd is not None:
            pulumi.set(__self__, "sd", sd)

    @_builtins.property
    @pulumi.getter
    def format(self) -> pulumi.Input[_builtins.str]:
        """
        Enum: `custom`, `rfc3164`, `rfc5424`. Message format. Default: `rfc5424`.
        """
        return pulumi.get(self, "format")

    @format.setter
    def format(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "format", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> pulumi.Input[_builtins.int]:
        """
        Rsyslog server port. Default: `514`.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def server(self) -> pulumi.Input[_builtins.str]:
        """
        Rsyslog server IP address or hostname. Example: `logs.example.com`.
        """
        return pulumi.get(self, "server")

    @server.setter
    def server(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "server", value)

    @_builtins.property
    @pulumi.getter
    def tls(self) -> pulumi.Input[_builtins.bool]:
        """
        Require TLS. Default: `true`.
        """
        return pulumi.get(self, "tls")

    @tls.setter
    def tls(self, value: pulumi.Input[_builtins.bool]):
        pulumi.set(self, "tls", value)

    @_builtins.property
    @pulumi.getter
    def ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PEM encoded CA certificate. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        return pulumi.get(self, "ca")

    @ca.setter
    def ca(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ca", value)

    @_builtins.property
    @pulumi.getter
    def cert(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PEM encoded client certificate. Example: `-----BEGIN CERTIFICATE-----
        ...
        -----END CERTIFICATE-----
        `.
        """
        return pulumi.get(self, "cert")

    @cert.setter
    def cert(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "cert", value)

    @_builtins.property
    @pulumi.getter
    def key(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        PEM encoded client key. Example: `-----BEGIN PRIVATE KEY-----
        ...
        -----END PRIVATE KEY-----
        `.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "key", value)

    @_builtins.property
    @pulumi.getter
    def logline(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Custom syslog message format. Example: `<%pri%>%timestamp:::date-rfc3339% %HOSTNAME% %app-name% %msg%`.
        """
        return pulumi.get(self, "logline")

    @logline.setter
    def logline(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "logline", value)

    @_builtins.property
    @pulumi.getter(name="maxMessageSize")
    def max_message_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Rsyslog max message size. Default: `8192`.
        """
        return pulumi.get(self, "max_message_size")

    @max_message_size.setter
    def max_message_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "max_message_size", value)

    @_builtins.property
    @pulumi.getter
    def sd(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Structured data block for log message. Example: `TOKEN tag="LiteralValue"`.
        """
        return pulumi.get(self, "sd")

    @sd.setter
    def sd(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "sd", value)


if not MYPY:
    class ServiceIntegrationExternalAwsCloudwatchLogsUserConfigArgsDict(TypedDict):
        selected_log_fields: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
        """
elif False:
    ServiceIntegrationExternalAwsCloudwatchLogsUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationExternalAwsCloudwatchLogsUserConfigArgs:
    def __init__(__self__, *,
                 selected_log_fields: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.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 selected_log_fields is not None:
            pulumi.set(__self__, "selected_log_fields", selected_log_fields)

    @_builtins.property
    @pulumi.getter(name="selectedLogFields")
    def selected_log_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "selected_log_fields", value)


if not MYPY:
    class ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigArgsDict(TypedDict):
        dropped_metrics: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricArgsDict']]]]
        """
        Metrics to not send to AWS CloudWatch (takes precedence over extra*metrics)
        """
        extra_metrics: NotRequired[pulumi.Input[Sequence[pulumi.Input['ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricArgsDict']]]]
        """
        Metrics to allow through to AWS CloudWatch (in addition to default metrics)
        """
elif False:
    ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@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)

    @_builtins.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)

    @_builtins.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)


if not MYPY:
    class ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricArgsDict(TypedDict):
        field: pulumi.Input[_builtins.str]
        """
        Identifier of a value in the metric. Example: `used`.
        """
        metric: pulumi.Input[_builtins.str]
        """
        Identifier of the metric. Example: `java.lang:Memory`.
        """
elif False:
    ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigDroppedMetricArgs:
    def __init__(__self__, *,
                 field: pulumi.Input[_builtins.str],
                 metric: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] field: Identifier of a value in the metric. Example: `used`.
        :param pulumi.Input[_builtins.str] metric: Identifier of the metric. Example: `java.lang:Memory`.
        """
        pulumi.set(__self__, "field", field)
        pulumi.set(__self__, "metric", metric)

    @_builtins.property
    @pulumi.getter
    def field(self) -> pulumi.Input[_builtins.str]:
        """
        Identifier of a value in the metric. Example: `used`.
        """
        return pulumi.get(self, "field")

    @field.setter
    def field(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "field", value)

    @_builtins.property
    @pulumi.getter
    def metric(self) -> pulumi.Input[_builtins.str]:
        """
        Identifier of the metric. Example: `java.lang:Memory`.
        """
        return pulumi.get(self, "metric")

    @metric.setter
    def metric(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "metric", value)


if not MYPY:
    class ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricArgsDict(TypedDict):
        field: pulumi.Input[_builtins.str]
        """
        Identifier of a value in the metric. Example: `used`.
        """
        metric: pulumi.Input[_builtins.str]
        """
        Identifier of the metric. Example: `java.lang:Memory`.
        """
elif False:
    ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationExternalAwsCloudwatchMetricsUserConfigExtraMetricArgs:
    def __init__(__self__, *,
                 field: pulumi.Input[_builtins.str],
                 metric: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] field: Identifier of a value in the metric. Example: `used`.
        :param pulumi.Input[_builtins.str] metric: Identifier of the metric. Example: `java.lang:Memory`.
        """
        pulumi.set(__self__, "field", field)
        pulumi.set(__self__, "metric", metric)

    @_builtins.property
    @pulumi.getter
    def field(self) -> pulumi.Input[_builtins.str]:
        """
        Identifier of a value in the metric. Example: `used`.
        """
        return pulumi.get(self, "field")

    @field.setter
    def field(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "field", value)

    @_builtins.property
    @pulumi.getter
    def metric(self) -> pulumi.Input[_builtins.str]:
        """
        Identifier of the metric. Example: `java.lang:Memory`.
        """
        return pulumi.get(self, "metric")

    @metric.setter
    def metric(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "metric", value)


if not MYPY:
    class ServiceIntegrationExternalElasticsearchLogsUserConfigArgsDict(TypedDict):
        selected_log_fields: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
        """
elif False:
    ServiceIntegrationExternalElasticsearchLogsUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationExternalElasticsearchLogsUserConfigArgs:
    def __init__(__self__, *,
                 selected_log_fields: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.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 selected_log_fields is not None:
            pulumi.set(__self__, "selected_log_fields", selected_log_fields)

    @_builtins.property
    @pulumi.getter(name="selectedLogFields")
    def selected_log_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "selected_log_fields", value)


if not MYPY:
    class ServiceIntegrationExternalOpensearchLogsUserConfigArgsDict(TypedDict):
        selected_log_fields: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
        """
elif False:
    ServiceIntegrationExternalOpensearchLogsUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationExternalOpensearchLogsUserConfigArgs:
    def __init__(__self__, *,
                 selected_log_fields: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.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 selected_log_fields is not None:
            pulumi.set(__self__, "selected_log_fields", selected_log_fields)

    @_builtins.property
    @pulumi.getter(name="selectedLogFields")
    def selected_log_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "selected_log_fields", value)


if not MYPY:
    class ServiceIntegrationFlinkExternalPostgresqlUserConfigArgsDict(TypedDict):
        stringtype: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `unspecified`. If stringtype is set to unspecified, parameters will be sent to the server as untyped values.
        """
elif False:
    ServiceIntegrationFlinkExternalPostgresqlUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationFlinkExternalPostgresqlUserConfigArgs:
    def __init__(__self__, *,
                 stringtype: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] stringtype: Enum: `unspecified`. If stringtype is set to unspecified, parameters will be sent to the server as untyped values.
        """
        if stringtype is not None:
            pulumi.set(__self__, "stringtype", stringtype)

    @_builtins.property
    @pulumi.getter
    def stringtype(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `unspecified`. If stringtype is set to unspecified, parameters will be sent to the server as untyped values.
        """
        return pulumi.get(self, "stringtype")

    @stringtype.setter
    def stringtype(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "stringtype", value)


if not MYPY:
    class ServiceIntegrationKafkaConnectUserConfigArgsDict(TypedDict):
        kafka_connect: NotRequired[pulumi.Input['ServiceIntegrationKafkaConnectUserConfigKafkaConnectArgsDict']]
        """
        Kafka Connect service configuration values
        """
elif False:
    ServiceIntegrationKafkaConnectUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@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)

    @_builtins.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)


if not MYPY:
    class ServiceIntegrationKafkaConnectUserConfigKafkaConnectArgsDict(TypedDict):
        config_storage_topic: NotRequired[pulumi.Input[_builtins.str]]
        """
        The name of the topic where connector and task configuration data are stored.This must be the same for all workers with the same group_id. Example: `__connect_configs`.
        """
        group_id: NotRequired[pulumi.Input[_builtins.str]]
        """
        A unique string that identifies the Connect cluster group this worker belongs to. Example: `connect`.
        """
        offset_storage_topic: NotRequired[pulumi.Input[_builtins.str]]
        """
        The name of the topic where connector and task configuration offsets are stored.This must be the same for all workers with the same group_id. Example: `__connect_offsets`.
        """
        status_storage_topic: NotRequired[pulumi.Input[_builtins.str]]
        """
        The name of the topic where connector and task configuration status updates are stored.This must be the same for all workers with the same group_id. Example: `__connect_status`.
        """
elif False:
    ServiceIntegrationKafkaConnectUserConfigKafkaConnectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationKafkaConnectUserConfigKafkaConnectArgs:
    def __init__(__self__, *,
                 config_storage_topic: Optional[pulumi.Input[_builtins.str]] = None,
                 group_id: Optional[pulumi.Input[_builtins.str]] = None,
                 offset_storage_topic: Optional[pulumi.Input[_builtins.str]] = None,
                 status_storage_topic: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] config_storage_topic: The name of the topic where connector and task configuration data are stored.This must be the same for all workers with the same group_id. Example: `__connect_configs`.
        :param pulumi.Input[_builtins.str] group_id: A unique string that identifies the Connect cluster group this worker belongs to. Example: `connect`.
        :param pulumi.Input[_builtins.str] offset_storage_topic: The name of the topic where connector and task configuration offsets are stored.This must be the same for all workers with the same group_id. Example: `__connect_offsets`.
        :param pulumi.Input[_builtins.str] status_storage_topic: The name of the topic where connector and task configuration status updates are stored.This must be the same for all workers with the same group_id. Example: `__connect_status`.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="configStorageTopic")
    def config_storage_topic(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The name of the topic where connector and task configuration data are stored.This must be the same for all workers with the same group_id. Example: `__connect_configs`.
        """
        return pulumi.get(self, "config_storage_topic")

    @config_storage_topic.setter
    def config_storage_topic(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "config_storage_topic", value)

    @_builtins.property
    @pulumi.getter(name="groupId")
    def group_id(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        A unique string that identifies the Connect cluster group this worker belongs to. Example: `connect`.
        """
        return pulumi.get(self, "group_id")

    @group_id.setter
    def group_id(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "group_id", value)

    @_builtins.property
    @pulumi.getter(name="offsetStorageTopic")
    def offset_storage_topic(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The name of the topic where connector and task configuration offsets are stored.This must be the same for all workers with the same group_id. Example: `__connect_offsets`.
        """
        return pulumi.get(self, "offset_storage_topic")

    @offset_storage_topic.setter
    def offset_storage_topic(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "offset_storage_topic", value)

    @_builtins.property
    @pulumi.getter(name="statusStorageTopic")
    def status_storage_topic(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The name of the topic where connector and task configuration status updates are stored.This must be the same for all workers with the same group_id. Example: `__connect_status`.
        """
        return pulumi.get(self, "status_storage_topic")

    @status_storage_topic.setter
    def status_storage_topic(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "status_storage_topic", value)


if not MYPY:
    class ServiceIntegrationKafkaLogsUserConfigArgsDict(TypedDict):
        kafka_topic: pulumi.Input[_builtins.str]
        """
        Topic name. Example: `mytopic`.
        """
        selected_log_fields: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
        """
elif False:
    ServiceIntegrationKafkaLogsUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationKafkaLogsUserConfigArgs:
    def __init__(__self__, *,
                 kafka_topic: pulumi.Input[_builtins.str],
                 selected_log_fields: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[_builtins.str] kafka_topic: Topic name. Example: `mytopic`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.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)

    @_builtins.property
    @pulumi.getter(name="kafkaTopic")
    def kafka_topic(self) -> pulumi.Input[_builtins.str]:
        """
        Topic name. Example: `mytopic`.
        """
        return pulumi.get(self, "kafka_topic")

    @kafka_topic.setter
    def kafka_topic(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "kafka_topic", value)

    @_builtins.property
    @pulumi.getter(name="selectedLogFields")
    def selected_log_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "selected_log_fields", value)


if not MYPY:
    class ServiceIntegrationKafkaMirrormakerUserConfigArgsDict(TypedDict):
        cluster_alias: NotRequired[pulumi.Input[_builtins.str]]
        """
        The alias under which the Kafka cluster is known to MirrorMaker. Can contain the following symbols: ASCII alphanumerics, `.`, `_`, and `-`. Example: `kafka-abc`.
        """
        kafka_mirrormaker: NotRequired[pulumi.Input['ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgsDict']]
        """
        Kafka MirrorMaker configuration values
        """
elif False:
    ServiceIntegrationKafkaMirrormakerUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationKafkaMirrormakerUserConfigArgs:
    def __init__(__self__, *,
                 cluster_alias: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_mirrormaker: Optional[pulumi.Input['ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgs']] = None):
        """
        :param pulumi.Input[_builtins.str] cluster_alias: The alias under which the Kafka cluster is known to MirrorMaker. Can contain the following symbols: ASCII alphanumerics, `.`, `_`, and `-`. Example: `kafka-abc`.
        :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)

    @_builtins.property
    @pulumi.getter(name="clusterAlias")
    def cluster_alias(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The alias under which the Kafka cluster is known to MirrorMaker. Can contain the following symbols: ASCII alphanumerics, `.`, `_`, and `-`. Example: `kafka-abc`.
        """
        return pulumi.get(self, "cluster_alias")

    @cluster_alias.setter
    def cluster_alias(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "cluster_alias", value)

    @_builtins.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)


if not MYPY:
    class ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgsDict(TypedDict):
        consumer_auto_offset_reset: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `earliest`, `latest`. Set where consumer starts to consume data. Value `earliest`: Start replication from the earliest offset. Value `latest`: Start replication from the latest offset. Default is `earliest`.
        """
        consumer_fetch_min_bytes: NotRequired[pulumi.Input[_builtins.int]]
        """
        The minimum amount of data the server should return for a fetch request. Example: `1024`.
        """
        consumer_max_poll_records: NotRequired[pulumi.Input[_builtins.int]]
        """
        Set consumer max.poll.records. The default is 500. Example: `500`.
        """
        producer_batch_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        The batch size in bytes producer will attempt to collect before publishing to broker. Example: `1024`.
        """
        producer_buffer_memory: NotRequired[pulumi.Input[_builtins.int]]
        """
        The amount of bytes producer can use for buffering data before publishing to broker.
        """
        producer_compression_type: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
        """
        producer_linger_ms: NotRequired[pulumi.Input[_builtins.int]]
        """
        The linger time (ms) for waiting new data to arrive for publishing. Example: `100`.
        """
        producer_max_request_size: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum request size in bytes.
        """
elif False:
    ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationKafkaMirrormakerUserConfigKafkaMirrormakerArgs:
    def __init__(__self__, *,
                 consumer_auto_offset_reset: Optional[pulumi.Input[_builtins.str]] = None,
                 consumer_fetch_min_bytes: Optional[pulumi.Input[_builtins.int]] = None,
                 consumer_max_poll_records: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_batch_size: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_buffer_memory: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_compression_type: Optional[pulumi.Input[_builtins.str]] = None,
                 producer_linger_ms: Optional[pulumi.Input[_builtins.int]] = None,
                 producer_max_request_size: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.str] consumer_auto_offset_reset: Enum: `earliest`, `latest`. Set where consumer starts to consume data. Value `earliest`: Start replication from the earliest offset. Value `latest`: Start replication from the latest offset. Default is `earliest`.
        :param pulumi.Input[_builtins.int] consumer_fetch_min_bytes: The minimum amount of data the server should return for a fetch request. Example: `1024`.
        :param pulumi.Input[_builtins.int] consumer_max_poll_records: Set consumer max.poll.records. The default is 500. Example: `500`.
        :param pulumi.Input[_builtins.int] producer_batch_size: The batch size in bytes producer will attempt to collect before publishing to broker. Example: `1024`.
        :param pulumi.Input[_builtins.int] producer_buffer_memory: The amount of bytes producer can use for buffering data before publishing to broker.
        :param pulumi.Input[_builtins.str] producer_compression_type: Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
        :param pulumi.Input[_builtins.int] producer_linger_ms: The linger time (ms) for waiting new data to arrive for publishing. Example: `100`.
        :param pulumi.Input[_builtins.int] producer_max_request_size: The maximum request size in bytes.
        """
        if consumer_auto_offset_reset is not None:
            pulumi.set(__self__, "consumer_auto_offset_reset", consumer_auto_offset_reset)
        if consumer_fetch_min_bytes is not None:
            pulumi.set(__self__, "consumer_fetch_min_bytes", consumer_fetch_min_bytes)
        if consumer_max_poll_records is not None:
            pulumi.set(__self__, "consumer_max_poll_records", consumer_max_poll_records)
        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)

    @_builtins.property
    @pulumi.getter(name="consumerAutoOffsetReset")
    def consumer_auto_offset_reset(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `earliest`, `latest`. Set where consumer starts to consume data. Value `earliest`: Start replication from the earliest offset. Value `latest`: Start replication from the latest offset. Default is `earliest`.
        """
        return pulumi.get(self, "consumer_auto_offset_reset")

    @consumer_auto_offset_reset.setter
    def consumer_auto_offset_reset(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "consumer_auto_offset_reset", value)

    @_builtins.property
    @pulumi.getter(name="consumerFetchMinBytes")
    def consumer_fetch_min_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The minimum amount of data the server should return for a fetch request. Example: `1024`.
        """
        return pulumi.get(self, "consumer_fetch_min_bytes")

    @consumer_fetch_min_bytes.setter
    def consumer_fetch_min_bytes(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "consumer_fetch_min_bytes", value)

    @_builtins.property
    @pulumi.getter(name="consumerMaxPollRecords")
    def consumer_max_poll_records(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Set consumer max.poll.records. The default is 500. Example: `500`.
        """
        return pulumi.get(self, "consumer_max_poll_records")

    @consumer_max_poll_records.setter
    def consumer_max_poll_records(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "consumer_max_poll_records", value)

    @_builtins.property
    @pulumi.getter(name="producerBatchSize")
    def producer_batch_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The batch size in bytes producer will attempt to collect before publishing to broker. Example: `1024`.
        """
        return pulumi.get(self, "producer_batch_size")

    @producer_batch_size.setter
    def producer_batch_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "producer_batch_size", value)

    @_builtins.property
    @pulumi.getter(name="producerBufferMemory")
    def producer_buffer_memory(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The amount of bytes producer can use for buffering data before publishing to broker.
        """
        return pulumi.get(self, "producer_buffer_memory")

    @producer_buffer_memory.setter
    def producer_buffer_memory(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "producer_buffer_memory", value)

    @_builtins.property
    @pulumi.getter(name="producerCompressionType")
    def producer_compression_type(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `gzip`, `lz4`, `none`, `snappy`, `zstd`. Specify the default compression type for producers. This configuration accepts the standard compression codecs (`gzip`, `snappy`, `lz4`, `zstd`). It additionally accepts `none` which is the default and equivalent to no compression.
        """
        return pulumi.get(self, "producer_compression_type")

    @producer_compression_type.setter
    def producer_compression_type(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "producer_compression_type", value)

    @_builtins.property
    @pulumi.getter(name="producerLingerMs")
    def producer_linger_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The linger time (ms) for waiting new data to arrive for publishing. Example: `100`.
        """
        return pulumi.get(self, "producer_linger_ms")

    @producer_linger_ms.setter
    def producer_linger_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "producer_linger_ms", value)

    @_builtins.property
    @pulumi.getter(name="producerMaxRequestSize")
    def producer_max_request_size(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum request size in bytes.
        """
        return pulumi.get(self, "producer_max_request_size")

    @producer_max_request_size.setter
    def producer_max_request_size(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "producer_max_request_size", value)


if not MYPY:
    class ServiceIntegrationLogsUserConfigArgsDict(TypedDict):
        elasticsearch_index_days_max: NotRequired[pulumi.Input[_builtins.int]]
        """
        Elasticsearch index retention limit. Default: `3`.
        """
        elasticsearch_index_prefix: NotRequired[pulumi.Input[_builtins.str]]
        """
        Elasticsearch index prefix. Default: `logs`.
        """
        selected_log_fields: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        The list of logging fields that will be sent to the integration logging service. The MESSAGE and timestamp fields are always sent.
        """
elif False:
    ServiceIntegrationLogsUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationLogsUserConfigArgs:
    def __init__(__self__, *,
                 elasticsearch_index_days_max: Optional[pulumi.Input[_builtins.int]] = None,
                 elasticsearch_index_prefix: Optional[pulumi.Input[_builtins.str]] = None,
                 selected_log_fields: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[_builtins.int] elasticsearch_index_days_max: Elasticsearch index retention limit. Default: `3`.
        :param pulumi.Input[_builtins.str] elasticsearch_index_prefix: Elasticsearch index prefix. Default: `logs`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.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)

    @_builtins.property
    @pulumi.getter(name="elasticsearchIndexDaysMax")
    def elasticsearch_index_days_max(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Elasticsearch index retention limit. Default: `3`.
        """
        return pulumi.get(self, "elasticsearch_index_days_max")

    @elasticsearch_index_days_max.setter
    def elasticsearch_index_days_max(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "elasticsearch_index_days_max", value)

    @_builtins.property
    @pulumi.getter(name="elasticsearchIndexPrefix")
    def elasticsearch_index_prefix(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Elasticsearch index prefix. Default: `logs`.
        """
        return pulumi.get(self, "elasticsearch_index_prefix")

    @elasticsearch_index_prefix.setter
    def elasticsearch_index_prefix(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "elasticsearch_index_prefix", value)

    @_builtins.property
    @pulumi.getter(name="selectedLogFields")
    def selected_log_fields(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "selected_log_fields", value)


if not MYPY:
    class ServiceIntegrationMetricsUserConfigArgsDict(TypedDict):
        database: NotRequired[pulumi.Input[_builtins.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.
        """
        retention_days: NotRequired[pulumi.Input[_builtins.int]]
        """
        Number of days to keep old metrics. Only affects PostgreSQL destinations. Set to 0 for no automatic cleanup. Defaults to 30 days.
        """
        ro_username: NotRequired[pulumi.Input[_builtins.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.
        """
        source_mysql: NotRequired[pulumi.Input['ServiceIntegrationMetricsUserConfigSourceMysqlArgsDict']]
        """
        Configuration options for metrics where source service is MySQL
        """
        username: NotRequired[pulumi.Input[_builtins.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.
        """
elif False:
    ServiceIntegrationMetricsUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationMetricsUserConfigArgs:
    def __init__(__self__, *,
                 database: Optional[pulumi.Input[_builtins.str]] = None,
                 retention_days: Optional[pulumi.Input[_builtins.int]] = None,
                 ro_username: Optional[pulumi.Input[_builtins.str]] = None,
                 source_mysql: Optional[pulumi.Input['ServiceIntegrationMetricsUserConfigSourceMysqlArgs']] = None,
                 username: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.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[_builtins.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[_builtins.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[_builtins.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)

    @_builtins.property
    @pulumi.getter
    def database(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "database", value)

    @_builtins.property
    @pulumi.getter(name="retentionDays")
    def retention_days(self) -> Optional[pulumi.Input[_builtins.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[_builtins.int]]):
        pulumi.set(self, "retention_days", value)

    @_builtins.property
    @pulumi.getter(name="roUsername")
    def ro_username(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "ro_username", value)

    @_builtins.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)

    @_builtins.property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "username", value)


if not MYPY:
    class ServiceIntegrationMetricsUserConfigSourceMysqlArgsDict(TypedDict):
        telegraf: NotRequired[pulumi.Input['ServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgsDict']]
        """
        Configuration options for Telegraf MySQL input plugin
        """
elif False:
    ServiceIntegrationMetricsUserConfigSourceMysqlArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationMetricsUserConfigSourceMysqlArgs:
    def __init__(__self__, *,
                 telegraf: Optional[pulumi.Input['ServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgs']] = None):
        """
        :param pulumi.Input['ServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgs'] telegraf: Configuration options for Telegraf MySQL input plugin
        """
        if telegraf is not None:
            pulumi.set(__self__, "telegraf", telegraf)

    @_builtins.property
    @pulumi.getter
    def telegraf(self) -> Optional[pulumi.Input['ServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgs']]:
        """
        Configuration options for Telegraf MySQL input plugin
        """
        return pulumi.get(self, "telegraf")

    @telegraf.setter
    def telegraf(self, value: Optional[pulumi.Input['ServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgs']]):
        pulumi.set(self, "telegraf", value)


if not MYPY:
    class ServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgsDict(TypedDict):
        gather_event_waits: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from PERFORMANCE*SCHEMA.EVENT*WAITS.
        """
        gather_file_events_stats: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from PERFORMANCE*SCHEMA.FILE*SUMMARY*BY*EVENT_NAME.
        """
        gather_index_io_waits: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from PERFORMANCE*SCHEMA.TABLE*IO*WAITS*SUMMARY*BY*INDEX_USAGE.
        """
        gather_info_schema_auto_inc: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather auto_increment columns and max values from information schema.
        """
        gather_innodb_metrics: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from INFORMATION*SCHEMA.INNODB*METRICS.
        """
        gather_perf_events_statements: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from PERFORMANCE*SCHEMA.EVENTS*STATEMENTS*SUMMARY*BY_DIGEST.
        """
        gather_process_list: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather thread state counts from INFORMATION_SCHEMA.PROCESSLIST.
        """
        gather_slave_status: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from SHOW SLAVE STATUS command output.
        """
        gather_table_io_waits: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from PERFORMANCE*SCHEMA.TABLE*IO*WAITS*SUMMARY*BY*TABLE.
        """
        gather_table_lock_waits: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from PERFORMANCE*SCHEMA.TABLE*LOCK_WAITS.
        """
        gather_table_schema: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from INFORMATION_SCHEMA.TABLES.
        """
        perf_events_statements_digest_text_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        Truncates digest text from perf*events*statements into this many characters. Example: `120`.
        """
        perf_events_statements_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        Limits metrics from perf*events*statements. Example: `250`.
        """
        perf_events_statements_time_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        Only include perf*events*statements whose last seen is less than this many seconds. Example: `86400`.
        """
elif False:
    ServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationMetricsUserConfigSourceMysqlTelegrafArgs:
    def __init__(__self__, *,
                 gather_event_waits: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_file_events_stats: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_index_io_waits: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_info_schema_auto_inc: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_innodb_metrics: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_perf_events_statements: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_process_list: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_slave_status: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_table_io_waits: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_table_lock_waits: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_table_schema: Optional[pulumi.Input[_builtins.bool]] = None,
                 perf_events_statements_digest_text_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 perf_events_statements_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 perf_events_statements_time_limit: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.bool] gather_event_waits: Gather metrics from PERFORMANCE*SCHEMA.EVENT*WAITS.
        :param pulumi.Input[_builtins.bool] gather_file_events_stats: Gather metrics from PERFORMANCE*SCHEMA.FILE*SUMMARY*BY*EVENT_NAME.
        :param pulumi.Input[_builtins.bool] gather_index_io_waits: Gather metrics from PERFORMANCE*SCHEMA.TABLE*IO*WAITS*SUMMARY*BY*INDEX_USAGE.
        :param pulumi.Input[_builtins.bool] gather_info_schema_auto_inc: Gather auto_increment columns and max values from information schema.
        :param pulumi.Input[_builtins.bool] gather_innodb_metrics: Gather metrics from INFORMATION*SCHEMA.INNODB*METRICS.
        :param pulumi.Input[_builtins.bool] gather_perf_events_statements: Gather metrics from PERFORMANCE*SCHEMA.EVENTS*STATEMENTS*SUMMARY*BY_DIGEST.
        :param pulumi.Input[_builtins.bool] gather_process_list: Gather thread state counts from INFORMATION_SCHEMA.PROCESSLIST.
        :param pulumi.Input[_builtins.bool] gather_slave_status: Gather metrics from SHOW SLAVE STATUS command output.
        :param pulumi.Input[_builtins.bool] gather_table_io_waits: Gather metrics from PERFORMANCE*SCHEMA.TABLE*IO*WAITS*SUMMARY*BY*TABLE.
        :param pulumi.Input[_builtins.bool] gather_table_lock_waits: Gather metrics from PERFORMANCE*SCHEMA.TABLE*LOCK_WAITS.
        :param pulumi.Input[_builtins.bool] gather_table_schema: Gather metrics from INFORMATION_SCHEMA.TABLES.
        :param pulumi.Input[_builtins.int] perf_events_statements_digest_text_limit: Truncates digest text from perf*events*statements into this many characters. Example: `120`.
        :param pulumi.Input[_builtins.int] perf_events_statements_limit: Limits metrics from perf*events*statements. Example: `250`.
        :param pulumi.Input[_builtins.int] perf_events_statements_time_limit: Only include perf*events*statements whose last seen is less than this many seconds. Example: `86400`.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="gatherEventWaits")
    def gather_event_waits(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from PERFORMANCE*SCHEMA.EVENT*WAITS.
        """
        return pulumi.get(self, "gather_event_waits")

    @gather_event_waits.setter
    def gather_event_waits(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_event_waits", value)

    @_builtins.property
    @pulumi.getter(name="gatherFileEventsStats")
    def gather_file_events_stats(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from PERFORMANCE*SCHEMA.FILE*SUMMARY*BY*EVENT_NAME.
        """
        return pulumi.get(self, "gather_file_events_stats")

    @gather_file_events_stats.setter
    def gather_file_events_stats(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_file_events_stats", value)

    @_builtins.property
    @pulumi.getter(name="gatherIndexIoWaits")
    def gather_index_io_waits(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from PERFORMANCE*SCHEMA.TABLE*IO*WAITS*SUMMARY*BY*INDEX_USAGE.
        """
        return pulumi.get(self, "gather_index_io_waits")

    @gather_index_io_waits.setter
    def gather_index_io_waits(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_index_io_waits", value)

    @_builtins.property
    @pulumi.getter(name="gatherInfoSchemaAutoInc")
    def gather_info_schema_auto_inc(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather auto_increment columns and max values from information schema.
        """
        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[_builtins.bool]]):
        pulumi.set(self, "gather_info_schema_auto_inc", value)

    @_builtins.property
    @pulumi.getter(name="gatherInnodbMetrics")
    def gather_innodb_metrics(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from INFORMATION*SCHEMA.INNODB*METRICS.
        """
        return pulumi.get(self, "gather_innodb_metrics")

    @gather_innodb_metrics.setter
    def gather_innodb_metrics(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_innodb_metrics", value)

    @_builtins.property
    @pulumi.getter(name="gatherPerfEventsStatements")
    def gather_perf_events_statements(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from PERFORMANCE*SCHEMA.EVENTS*STATEMENTS*SUMMARY*BY_DIGEST.
        """
        return pulumi.get(self, "gather_perf_events_statements")

    @gather_perf_events_statements.setter
    def gather_perf_events_statements(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_perf_events_statements", value)

    @_builtins.property
    @pulumi.getter(name="gatherProcessList")
    def gather_process_list(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather thread state counts from INFORMATION_SCHEMA.PROCESSLIST.
        """
        return pulumi.get(self, "gather_process_list")

    @gather_process_list.setter
    def gather_process_list(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_process_list", value)

    @_builtins.property
    @pulumi.getter(name="gatherSlaveStatus")
    def gather_slave_status(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from SHOW SLAVE STATUS command output.
        """
        return pulumi.get(self, "gather_slave_status")

    @gather_slave_status.setter
    def gather_slave_status(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_slave_status", value)

    @_builtins.property
    @pulumi.getter(name="gatherTableIoWaits")
    def gather_table_io_waits(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from PERFORMANCE*SCHEMA.TABLE*IO*WAITS*SUMMARY*BY*TABLE.
        """
        return pulumi.get(self, "gather_table_io_waits")

    @gather_table_io_waits.setter
    def gather_table_io_waits(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_table_io_waits", value)

    @_builtins.property
    @pulumi.getter(name="gatherTableLockWaits")
    def gather_table_lock_waits(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from PERFORMANCE*SCHEMA.TABLE*LOCK_WAITS.
        """
        return pulumi.get(self, "gather_table_lock_waits")

    @gather_table_lock_waits.setter
    def gather_table_lock_waits(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_table_lock_waits", value)

    @_builtins.property
    @pulumi.getter(name="gatherTableSchema")
    def gather_table_schema(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from INFORMATION_SCHEMA.TABLES.
        """
        return pulumi.get(self, "gather_table_schema")

    @gather_table_schema.setter
    def gather_table_schema(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_table_schema", value)

    @_builtins.property
    @pulumi.getter(name="perfEventsStatementsDigestTextLimit")
    def perf_events_statements_digest_text_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Truncates digest text from perf*events*statements into this many characters. Example: `120`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "perf_events_statements_digest_text_limit", value)

    @_builtins.property
    @pulumi.getter(name="perfEventsStatementsLimit")
    def perf_events_statements_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Limits metrics from perf*events*statements. Example: `250`.
        """
        return pulumi.get(self, "perf_events_statements_limit")

    @perf_events_statements_limit.setter
    def perf_events_statements_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "perf_events_statements_limit", value)

    @_builtins.property
    @pulumi.getter(name="perfEventsStatementsTimeLimit")
    def perf_events_statements_time_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Only include perf*events*statements whose last seen is less than this many seconds. Example: `86400`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "perf_events_statements_time_limit", value)


if not MYPY:
    class ServiceIntegrationPrometheusUserConfigArgsDict(TypedDict):
        source_mysql: NotRequired[pulumi.Input['ServiceIntegrationPrometheusUserConfigSourceMysqlArgsDict']]
        """
        Configuration options for metrics where source service is MySQL
        """
elif False:
    ServiceIntegrationPrometheusUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationPrometheusUserConfigArgs:
    def __init__(__self__, *,
                 source_mysql: Optional[pulumi.Input['ServiceIntegrationPrometheusUserConfigSourceMysqlArgs']] = None):
        """
        :param pulumi.Input['ServiceIntegrationPrometheusUserConfigSourceMysqlArgs'] source_mysql: Configuration options for metrics where source service is MySQL
        """
        if source_mysql is not None:
            pulumi.set(__self__, "source_mysql", source_mysql)

    @_builtins.property
    @pulumi.getter(name="sourceMysql")
    def source_mysql(self) -> Optional[pulumi.Input['ServiceIntegrationPrometheusUserConfigSourceMysqlArgs']]:
        """
        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['ServiceIntegrationPrometheusUserConfigSourceMysqlArgs']]):
        pulumi.set(self, "source_mysql", value)


if not MYPY:
    class ServiceIntegrationPrometheusUserConfigSourceMysqlArgsDict(TypedDict):
        telegraf: NotRequired[pulumi.Input['ServiceIntegrationPrometheusUserConfigSourceMysqlTelegrafArgsDict']]
        """
        Configuration options for Telegraf MySQL input plugin
        """
elif False:
    ServiceIntegrationPrometheusUserConfigSourceMysqlArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationPrometheusUserConfigSourceMysqlArgs:
    def __init__(__self__, *,
                 telegraf: Optional[pulumi.Input['ServiceIntegrationPrometheusUserConfigSourceMysqlTelegrafArgs']] = None):
        """
        :param pulumi.Input['ServiceIntegrationPrometheusUserConfigSourceMysqlTelegrafArgs'] telegraf: Configuration options for Telegraf MySQL input plugin
        """
        if telegraf is not None:
            pulumi.set(__self__, "telegraf", telegraf)

    @_builtins.property
    @pulumi.getter
    def telegraf(self) -> Optional[pulumi.Input['ServiceIntegrationPrometheusUserConfigSourceMysqlTelegrafArgs']]:
        """
        Configuration options for Telegraf MySQL input plugin
        """
        return pulumi.get(self, "telegraf")

    @telegraf.setter
    def telegraf(self, value: Optional[pulumi.Input['ServiceIntegrationPrometheusUserConfigSourceMysqlTelegrafArgs']]):
        pulumi.set(self, "telegraf", value)


if not MYPY:
    class ServiceIntegrationPrometheusUserConfigSourceMysqlTelegrafArgsDict(TypedDict):
        gather_event_waits: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from PERFORMANCE*SCHEMA.EVENT*WAITS.
        """
        gather_file_events_stats: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from PERFORMANCE*SCHEMA.FILE*SUMMARY*BY*EVENT_NAME.
        """
        gather_index_io_waits: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from PERFORMANCE*SCHEMA.TABLE*IO*WAITS*SUMMARY*BY*INDEX_USAGE.
        """
        gather_info_schema_auto_inc: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather auto_increment columns and max values from information schema.
        """
        gather_innodb_metrics: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from INFORMATION*SCHEMA.INNODB*METRICS.
        """
        gather_perf_events_statements: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from PERFORMANCE*SCHEMA.EVENTS*STATEMENTS*SUMMARY*BY_DIGEST.
        """
        gather_process_list: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather thread state counts from INFORMATION_SCHEMA.PROCESSLIST.
        """
        gather_slave_status: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from SHOW SLAVE STATUS command output.
        """
        gather_table_io_waits: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from PERFORMANCE*SCHEMA.TABLE*IO*WAITS*SUMMARY*BY*TABLE.
        """
        gather_table_lock_waits: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from PERFORMANCE*SCHEMA.TABLE*LOCK_WAITS.
        """
        gather_table_schema: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Gather metrics from INFORMATION_SCHEMA.TABLES.
        """
        perf_events_statements_digest_text_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        Truncates digest text from perf*events*statements into this many characters. Example: `120`.
        """
        perf_events_statements_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        Limits metrics from perf*events*statements. Example: `250`.
        """
        perf_events_statements_time_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        Only include perf*events*statements whose last seen is less than this many seconds. Example: `86400`.
        """
elif False:
    ServiceIntegrationPrometheusUserConfigSourceMysqlTelegrafArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ServiceIntegrationPrometheusUserConfigSourceMysqlTelegrafArgs:
    def __init__(__self__, *,
                 gather_event_waits: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_file_events_stats: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_index_io_waits: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_info_schema_auto_inc: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_innodb_metrics: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_perf_events_statements: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_process_list: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_slave_status: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_table_io_waits: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_table_lock_waits: Optional[pulumi.Input[_builtins.bool]] = None,
                 gather_table_schema: Optional[pulumi.Input[_builtins.bool]] = None,
                 perf_events_statements_digest_text_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 perf_events_statements_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 perf_events_statements_time_limit: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.bool] gather_event_waits: Gather metrics from PERFORMANCE*SCHEMA.EVENT*WAITS.
        :param pulumi.Input[_builtins.bool] gather_file_events_stats: Gather metrics from PERFORMANCE*SCHEMA.FILE*SUMMARY*BY*EVENT_NAME.
        :param pulumi.Input[_builtins.bool] gather_index_io_waits: Gather metrics from PERFORMANCE*SCHEMA.TABLE*IO*WAITS*SUMMARY*BY*INDEX_USAGE.
        :param pulumi.Input[_builtins.bool] gather_info_schema_auto_inc: Gather auto_increment columns and max values from information schema.
        :param pulumi.Input[_builtins.bool] gather_innodb_metrics: Gather metrics from INFORMATION*SCHEMA.INNODB*METRICS.
        :param pulumi.Input[_builtins.bool] gather_perf_events_statements: Gather metrics from PERFORMANCE*SCHEMA.EVENTS*STATEMENTS*SUMMARY*BY_DIGEST.
        :param pulumi.Input[_builtins.bool] gather_process_list: Gather thread state counts from INFORMATION_SCHEMA.PROCESSLIST.
        :param pulumi.Input[_builtins.bool] gather_slave_status: Gather metrics from SHOW SLAVE STATUS command output.
        :param pulumi.Input[_builtins.bool] gather_table_io_waits: Gather metrics from PERFORMANCE*SCHEMA.TABLE*IO*WAITS*SUMMARY*BY*TABLE.
        :param pulumi.Input[_builtins.bool] gather_table_lock_waits: Gather metrics from PERFORMANCE*SCHEMA.TABLE*LOCK_WAITS.
        :param pulumi.Input[_builtins.bool] gather_table_schema: Gather metrics from INFORMATION_SCHEMA.TABLES.
        :param pulumi.Input[_builtins.int] perf_events_statements_digest_text_limit: Truncates digest text from perf*events*statements into this many characters. Example: `120`.
        :param pulumi.Input[_builtins.int] perf_events_statements_limit: Limits metrics from perf*events*statements. Example: `250`.
        :param pulumi.Input[_builtins.int] perf_events_statements_time_limit: Only include perf*events*statements whose last seen is less than this many seconds. Example: `86400`.
        """
        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)

    @_builtins.property
    @pulumi.getter(name="gatherEventWaits")
    def gather_event_waits(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from PERFORMANCE*SCHEMA.EVENT*WAITS.
        """
        return pulumi.get(self, "gather_event_waits")

    @gather_event_waits.setter
    def gather_event_waits(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_event_waits", value)

    @_builtins.property
    @pulumi.getter(name="gatherFileEventsStats")
    def gather_file_events_stats(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from PERFORMANCE*SCHEMA.FILE*SUMMARY*BY*EVENT_NAME.
        """
        return pulumi.get(self, "gather_file_events_stats")

    @gather_file_events_stats.setter
    def gather_file_events_stats(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_file_events_stats", value)

    @_builtins.property
    @pulumi.getter(name="gatherIndexIoWaits")
    def gather_index_io_waits(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from PERFORMANCE*SCHEMA.TABLE*IO*WAITS*SUMMARY*BY*INDEX_USAGE.
        """
        return pulumi.get(self, "gather_index_io_waits")

    @gather_index_io_waits.setter
    def gather_index_io_waits(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_index_io_waits", value)

    @_builtins.property
    @pulumi.getter(name="gatherInfoSchemaAutoInc")
    def gather_info_schema_auto_inc(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather auto_increment columns and max values from information schema.
        """
        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[_builtins.bool]]):
        pulumi.set(self, "gather_info_schema_auto_inc", value)

    @_builtins.property
    @pulumi.getter(name="gatherInnodbMetrics")
    def gather_innodb_metrics(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from INFORMATION*SCHEMA.INNODB*METRICS.
        """
        return pulumi.get(self, "gather_innodb_metrics")

    @gather_innodb_metrics.setter
    def gather_innodb_metrics(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_innodb_metrics", value)

    @_builtins.property
    @pulumi.getter(name="gatherPerfEventsStatements")
    def gather_perf_events_statements(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from PERFORMANCE*SCHEMA.EVENTS*STATEMENTS*SUMMARY*BY_DIGEST.
        """
        return pulumi.get(self, "gather_perf_events_statements")

    @gather_perf_events_statements.setter
    def gather_perf_events_statements(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_perf_events_statements", value)

    @_builtins.property
    @pulumi.getter(name="gatherProcessList")
    def gather_process_list(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather thread state counts from INFORMATION_SCHEMA.PROCESSLIST.
        """
        return pulumi.get(self, "gather_process_list")

    @gather_process_list.setter
    def gather_process_list(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_process_list", value)

    @_builtins.property
    @pulumi.getter(name="gatherSlaveStatus")
    def gather_slave_status(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from SHOW SLAVE STATUS command output.
        """
        return pulumi.get(self, "gather_slave_status")

    @gather_slave_status.setter
    def gather_slave_status(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_slave_status", value)

    @_builtins.property
    @pulumi.getter(name="gatherTableIoWaits")
    def gather_table_io_waits(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from PERFORMANCE*SCHEMA.TABLE*IO*WAITS*SUMMARY*BY*TABLE.
        """
        return pulumi.get(self, "gather_table_io_waits")

    @gather_table_io_waits.setter
    def gather_table_io_waits(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_table_io_waits", value)

    @_builtins.property
    @pulumi.getter(name="gatherTableLockWaits")
    def gather_table_lock_waits(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from PERFORMANCE*SCHEMA.TABLE*LOCK_WAITS.
        """
        return pulumi.get(self, "gather_table_lock_waits")

    @gather_table_lock_waits.setter
    def gather_table_lock_waits(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_table_lock_waits", value)

    @_builtins.property
    @pulumi.getter(name="gatherTableSchema")
    def gather_table_schema(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Gather metrics from INFORMATION_SCHEMA.TABLES.
        """
        return pulumi.get(self, "gather_table_schema")

    @gather_table_schema.setter
    def gather_table_schema(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "gather_table_schema", value)

    @_builtins.property
    @pulumi.getter(name="perfEventsStatementsDigestTextLimit")
    def perf_events_statements_digest_text_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Truncates digest text from perf*events*statements into this many characters. Example: `120`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "perf_events_statements_digest_text_limit", value)

    @_builtins.property
    @pulumi.getter(name="perfEventsStatementsLimit")
    def perf_events_statements_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Limits metrics from perf*events*statements. Example: `250`.
        """
        return pulumi.get(self, "perf_events_statements_limit")

    @perf_events_statements_limit.setter
    def perf_events_statements_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "perf_events_statements_limit", value)

    @_builtins.property
    @pulumi.getter(name="perfEventsStatementsTimeLimit")
    def perf_events_statements_time_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Only include perf*events*statements whose last seen is less than this many seconds. Example: `86400`.
        """
        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[_builtins.int]]):
        pulumi.set(self, "perf_events_statements_time_limit", value)


if not MYPY:
    class ThanosComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    ThanosComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ThanosComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

    @_builtins.property
    @pulumi.getter
    def component(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Service component name
        """
        return pulumi.get(self, "component")

    @component.setter
    def component(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "component", value)

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

    @connection_uri.setter
    def connection_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "connection_uri", value)

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_authentication_method", value)

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

    @kafka_ssl_ca.setter
    def kafka_ssl_ca(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_ssl_ca", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def route(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Network access route
        """
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "route", value)

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ssl", value)

    @_builtins.property
    @pulumi.getter
    def usage(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        DNS usage name
        """
        return pulumi.get(self, "usage")

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "usage", value)


if not MYPY:
    class ThanosServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    ThanosServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ThanosServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration
        :param pulumi.Input[_builtins.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)

    @_builtins.property
    @pulumi.getter(name="integrationType")
    def integration_type(self) -> pulumi.Input[_builtins.str]:
        """
        Type of the service integration
        """
        return pulumi.get(self, "integration_type")

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "integration_type", value)

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class ThanosTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    ThanosTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ThanosTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[_builtins.str],
                 value: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] key: Service tag key
        :param pulumi.Input[_builtins.str] value: Service tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def key(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "key", value)

    @_builtins.property
    @pulumi.getter
    def value(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag value
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "value", value)


if not MYPY:
    class ThanosTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    ThanosTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ThanosTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

    @email.setter
    def email(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "email", value)


if not MYPY:
    class ThanosThanosArgsDict(TypedDict):
        query_frontend_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Query frontend URI.
        """
        query_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Query URI.
        """
        receiver_remote_write_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Receiver remote write URI.
        """
        uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Thanos server URIs.
        """
elif False:
    ThanosThanosArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ThanosThanosArgs:
    def __init__(__self__, *,
                 query_frontend_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 query_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 receiver_remote_write_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[_builtins.str] query_frontend_uri: Query frontend URI.
        :param pulumi.Input[_builtins.str] query_uri: Query URI.
        :param pulumi.Input[_builtins.str] receiver_remote_write_uri: Receiver remote write URI.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uris: Thanos server URIs.
        """
        if query_frontend_uri is not None:
            pulumi.set(__self__, "query_frontend_uri", query_frontend_uri)
        if query_uri is not None:
            pulumi.set(__self__, "query_uri", query_uri)
        if receiver_remote_write_uri is not None:
            pulumi.set(__self__, "receiver_remote_write_uri", receiver_remote_write_uri)
        if uris is not None:
            pulumi.set(__self__, "uris", uris)

    @_builtins.property
    @pulumi.getter(name="queryFrontendUri")
    def query_frontend_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Query frontend URI.
        """
        return pulumi.get(self, "query_frontend_uri")

    @query_frontend_uri.setter
    def query_frontend_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "query_frontend_uri", value)

    @_builtins.property
    @pulumi.getter(name="queryUri")
    def query_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Query URI.
        """
        return pulumi.get(self, "query_uri")

    @query_uri.setter
    def query_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "query_uri", value)

    @_builtins.property
    @pulumi.getter(name="receiverRemoteWriteUri")
    def receiver_remote_write_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Receiver remote write URI.
        """
        return pulumi.get(self, "receiver_remote_write_uri")

    @receiver_remote_write_uri.setter
    def receiver_remote_write_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "receiver_remote_write_uri", value)

    @_builtins.property
    @pulumi.getter
    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Thanos server URIs.
        """
        return pulumi.get(self, "uris")

    @uris.setter
    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "uris", value)


if not MYPY:
    class ThanosThanosUserConfigArgsDict(TypedDict):
        compactor: NotRequired[pulumi.Input['ThanosThanosUserConfigCompactorArgsDict']]
        """
        Configuration options for Thanos Compactor
        """
        env: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
        """
        Environmental variables.
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['ThanosThanosUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        object_storage_usage_alert_threshold_gb: NotRequired[pulumi.Input[_builtins.int]]
        """
        After exceeding the limit a service alert is going to be raised (0 means not set).
        """
        private_access: NotRequired[pulumi.Input['ThanosThanosUserConfigPrivateAccessArgsDict']]
        """
        Allow access to selected service ports from private networks
        """
        privatelink_access: NotRequired[pulumi.Input['ThanosThanosUserConfigPrivatelinkAccessArgsDict']]
        """
        Allow access to selected service components through Privatelink
        """
        public_access: NotRequired[pulumi.Input['ThanosThanosUserConfigPublicAccessArgsDict']]
        """
        Allow access to selected service ports from the public Internet
        """
        query: NotRequired[pulumi.Input['ThanosThanosUserConfigQueryArgsDict']]
        """
        Configuration options for Thanos Query
        """
        query_frontend: NotRequired[pulumi.Input['ThanosThanosUserConfigQueryFrontendArgsDict']]
        """
        Configuration options for Thanos Query Frontend
        """
        receiver_ingesting: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
        """
        Common configuration options for Thanos Receive.
        """
        receiver_routing: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
        """
        Configuration options for Thanos Receive Routing.
        """
        ruler: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
        """
        Configuration options for Thanos Ruler.
        """
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
        store: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]
        """
        Configuration options for Thanos Store.
        """
elif False:
    ThanosThanosUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ThanosThanosUserConfigArgs:
    def __init__(__self__, *,
                 compactor: Optional[pulumi.Input['ThanosThanosUserConfigCompactorArgs']] = None,
                 env: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['ThanosThanosUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 object_storage_usage_alert_threshold_gb: Optional[pulumi.Input[_builtins.int]] = None,
                 private_access: Optional[pulumi.Input['ThanosThanosUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['ThanosThanosUserConfigPrivatelinkAccessArgs']] = None,
                 public_access: Optional[pulumi.Input['ThanosThanosUserConfigPublicAccessArgs']] = None,
                 query: Optional[pulumi.Input['ThanosThanosUserConfigQueryArgs']] = None,
                 query_frontend: Optional[pulumi.Input['ThanosThanosUserConfigQueryFrontendArgs']] = None,
                 receiver_ingesting: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
                 receiver_routing: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
                 ruler: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None,
                 store: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input['ThanosThanosUserConfigCompactorArgs'] compactor: Configuration options for Thanos Compactor
        :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] env: Environmental variables.
        :param pulumi.Input[Sequence[pulumi.Input['ThanosThanosUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[_builtins.int] object_storage_usage_alert_threshold_gb: After exceeding the limit a service alert is going to be raised (0 means not set).
        :param pulumi.Input['ThanosThanosUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks
        :param pulumi.Input['ThanosThanosUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink
        :param pulumi.Input['ThanosThanosUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
        :param pulumi.Input['ThanosThanosUserConfigQueryArgs'] query: Configuration options for Thanos Query
        :param pulumi.Input['ThanosThanosUserConfigQueryFrontendArgs'] query_frontend: Configuration options for Thanos Query Frontend
        :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] receiver_ingesting: Common configuration options for Thanos Receive.
        :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] receiver_routing: Configuration options for Thanos Receive Routing.
        :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] ruler: Configuration options for Thanos Ruler.
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input[_builtins.bool] static_ips: Use static public IP addresses.
        :param pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]] store: Configuration options for Thanos Store.
        """
        if compactor is not None:
            pulumi.set(__self__, "compactor", compactor)
        if env is not None:
            warnings.warn("""This property is deprecated.""", DeprecationWarning)
            pulumi.log.warn("""env is deprecated: This property is deprecated.""")
        if env is not None:
            pulumi.set(__self__, "env", env)
        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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `ip_filter_string` instead.""")
        if ip_filters is not None:
            pulumi.set(__self__, "ip_filters", ip_filters)
        if object_storage_usage_alert_threshold_gb is not None:
            pulumi.set(__self__, "object_storage_usage_alert_threshold_gb", object_storage_usage_alert_threshold_gb)
        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 query is not None:
            pulumi.set(__self__, "query", query)
        if query_frontend is not None:
            pulumi.set(__self__, "query_frontend", query_frontend)
        if receiver_ingesting is not None:
            pulumi.set(__self__, "receiver_ingesting", receiver_ingesting)
        if receiver_routing is not None:
            pulumi.set(__self__, "receiver_routing", receiver_routing)
        if ruler is not None:
            pulumi.set(__self__, "ruler", ruler)
        if service_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        if static_ips is not None:
            pulumi.set(__self__, "static_ips", static_ips)
        if store is not None:
            pulumi.set(__self__, "store", store)

    @_builtins.property
    @pulumi.getter
    def compactor(self) -> Optional[pulumi.Input['ThanosThanosUserConfigCompactorArgs']]:
        """
        Configuration options for Thanos Compactor
        """
        return pulumi.get(self, "compactor")

    @compactor.setter
    def compactor(self, value: Optional[pulumi.Input['ThanosThanosUserConfigCompactorArgs']]):
        pulumi.set(self, "compactor", value)

    @_builtins.property
    @pulumi.getter
    @_utilities.deprecated("""This property is deprecated.""")
    def env(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
        """
        Environmental variables.
        """
        return pulumi.get(self, "env")

    @env.setter
    def env(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "env", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ThanosThanosUserConfigIpFilterObjectArgs']]]]:
        """
        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['ThanosThanosUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "ip_filters", value)

    @_builtins.property
    @pulumi.getter(name="objectStorageUsageAlertThresholdGb")
    def object_storage_usage_alert_threshold_gb(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        After exceeding the limit a service alert is going to be raised (0 means not set).
        """
        return pulumi.get(self, "object_storage_usage_alert_threshold_gb")

    @object_storage_usage_alert_threshold_gb.setter
    def object_storage_usage_alert_threshold_gb(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "object_storage_usage_alert_threshold_gb", value)

    @_builtins.property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['ThanosThanosUserConfigPrivateAccessArgs']]:
        """
        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['ThanosThanosUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @_builtins.property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['ThanosThanosUserConfigPrivatelinkAccessArgs']]:
        """
        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['ThanosThanosUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)

    @_builtins.property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['ThanosThanosUserConfigPublicAccessArgs']]:
        """
        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['ThanosThanosUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

    @_builtins.property
    @pulumi.getter
    def query(self) -> Optional[pulumi.Input['ThanosThanosUserConfigQueryArgs']]:
        """
        Configuration options for Thanos Query
        """
        return pulumi.get(self, "query")

    @query.setter
    def query(self, value: Optional[pulumi.Input['ThanosThanosUserConfigQueryArgs']]):
        pulumi.set(self, "query", value)

    @_builtins.property
    @pulumi.getter(name="queryFrontend")
    def query_frontend(self) -> Optional[pulumi.Input['ThanosThanosUserConfigQueryFrontendArgs']]:
        """
        Configuration options for Thanos Query Frontend
        """
        return pulumi.get(self, "query_frontend")

    @query_frontend.setter
    def query_frontend(self, value: Optional[pulumi.Input['ThanosThanosUserConfigQueryFrontendArgs']]):
        pulumi.set(self, "query_frontend", value)

    @_builtins.property
    @pulumi.getter(name="receiverIngesting")
    def receiver_ingesting(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
        """
        Common configuration options for Thanos Receive.
        """
        return pulumi.get(self, "receiver_ingesting")

    @receiver_ingesting.setter
    def receiver_ingesting(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "receiver_ingesting", value)

    @_builtins.property
    @pulumi.getter(name="receiverRouting")
    def receiver_routing(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
        """
        Configuration options for Thanos Receive Routing.
        """
        return pulumi.get(self, "receiver_routing")

    @receiver_routing.setter
    def receiver_routing(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "receiver_routing", value)

    @_builtins.property
    @pulumi.getter
    def ruler(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
        """
        Configuration options for Thanos Ruler.
        """
        return pulumi.get(self, "ruler")

    @ruler.setter
    def ruler(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "ruler", value)

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

    @service_log.setter
    def service_log(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "service_log", value)

    @_builtins.property
    @pulumi.getter(name="staticIps")
    def static_ips(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Use static public IP addresses.
        """
        return pulumi.get(self, "static_ips")

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "static_ips", value)

    @_builtins.property
    @pulumi.getter
    def store(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]:
        """
        Configuration options for Thanos Store.
        """
        return pulumi.get(self, "store")

    @store.setter
    def store(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "store", value)


if not MYPY:
    class ThanosThanosUserConfigCompactorArgsDict(TypedDict):
        retention_days: NotRequired[pulumi.Input[_builtins.int]]
        """
        Retention time for data in days for each resolution (5m, 1h, raw).
        """
elif False:
    ThanosThanosUserConfigCompactorArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ThanosThanosUserConfigCompactorArgs:
    def __init__(__self__, *,
                 retention_days: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.int] retention_days: Retention time for data in days for each resolution (5m, 1h, raw).
        """
        if retention_days is not None:
            pulumi.set(__self__, "retention_days", retention_days)

    @_builtins.property
    @pulumi.getter(name="retentionDays")
    def retention_days(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Retention time for data in days for each resolution (5m, 1h, raw).
        """
        return pulumi.get(self, "retention_days")

    @retention_days.setter
    def retention_days(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "retention_days", value)


if not MYPY:
    class ThanosThanosUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    ThanosThanosUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ThanosThanosUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "network", value)

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "description", value)


if not MYPY:
    class ThanosThanosUserConfigPrivateAccessArgsDict(TypedDict):
        query_frontend: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to query_frontend with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        receiver_routing: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to receiver_routing with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
elif False:
    ThanosThanosUserConfigPrivateAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ThanosThanosUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 query_frontend: Optional[pulumi.Input[_builtins.bool]] = None,
                 receiver_routing: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] query_frontend: Allow clients to connect to query_frontend with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] receiver_routing: Allow clients to connect to receiver_routing with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        if query_frontend is not None:
            pulumi.set(__self__, "query_frontend", query_frontend)
        if receiver_routing is not None:
            pulumi.set(__self__, "receiver_routing", receiver_routing)

    @_builtins.property
    @pulumi.getter(name="queryFrontend")
    def query_frontend(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to query_frontend with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "query_frontend")

    @query_frontend.setter
    def query_frontend(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "query_frontend", value)

    @_builtins.property
    @pulumi.getter(name="receiverRouting")
    def receiver_routing(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to receiver_routing with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "receiver_routing")

    @receiver_routing.setter
    def receiver_routing(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "receiver_routing", value)


if not MYPY:
    class ThanosThanosUserConfigPrivatelinkAccessArgsDict(TypedDict):
        query_frontend: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable query_frontend.
        """
        receiver_routing: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable receiver_routing.
        """
elif False:
    ThanosThanosUserConfigPrivatelinkAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ThanosThanosUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 query_frontend: Optional[pulumi.Input[_builtins.bool]] = None,
                 receiver_routing: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] query_frontend: Enable query_frontend.
        :param pulumi.Input[_builtins.bool] receiver_routing: Enable receiver_routing.
        """
        if query_frontend is not None:
            pulumi.set(__self__, "query_frontend", query_frontend)
        if receiver_routing is not None:
            pulumi.set(__self__, "receiver_routing", receiver_routing)

    @_builtins.property
    @pulumi.getter(name="queryFrontend")
    def query_frontend(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable query_frontend.
        """
        return pulumi.get(self, "query_frontend")

    @query_frontend.setter
    def query_frontend(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "query_frontend", value)

    @_builtins.property
    @pulumi.getter(name="receiverRouting")
    def receiver_routing(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable receiver_routing.
        """
        return pulumi.get(self, "receiver_routing")

    @receiver_routing.setter
    def receiver_routing(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "receiver_routing", value)


if not MYPY:
    class ThanosThanosUserConfigPublicAccessArgsDict(TypedDict):
        compactor: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to compactor from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        query: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to query from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        query_frontend: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to query_frontend from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        receiver_ingesting: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to receiver_ingesting from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        receiver_routing: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to receiver_routing from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        ruler: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to ruler from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        store: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to store from the public internet for service nodes that are in a project VPC or another type of private network.
        """
elif False:
    ThanosThanosUserConfigPublicAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ThanosThanosUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 compactor: Optional[pulumi.Input[_builtins.bool]] = None,
                 query: Optional[pulumi.Input[_builtins.bool]] = None,
                 query_frontend: Optional[pulumi.Input[_builtins.bool]] = None,
                 receiver_ingesting: Optional[pulumi.Input[_builtins.bool]] = None,
                 receiver_routing: Optional[pulumi.Input[_builtins.bool]] = None,
                 ruler: Optional[pulumi.Input[_builtins.bool]] = None,
                 store: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] compactor: Allow clients to connect to compactor from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] query: Allow clients to connect to query from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] query_frontend: Allow clients to connect to query_frontend from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] receiver_ingesting: Allow clients to connect to receiver_ingesting from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] receiver_routing: Allow clients to connect to receiver_routing from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] ruler: Allow clients to connect to ruler from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] store: Allow clients to connect to store from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        if compactor is not None:
            pulumi.set(__self__, "compactor", compactor)
        if query is not None:
            pulumi.set(__self__, "query", query)
        if query_frontend is not None:
            pulumi.set(__self__, "query_frontend", query_frontend)
        if receiver_ingesting is not None:
            pulumi.set(__self__, "receiver_ingesting", receiver_ingesting)
        if receiver_routing is not None:
            pulumi.set(__self__, "receiver_routing", receiver_routing)
        if ruler is not None:
            pulumi.set(__self__, "ruler", ruler)
        if store is not None:
            pulumi.set(__self__, "store", store)

    @_builtins.property
    @pulumi.getter
    def compactor(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to compactor from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "compactor")

    @compactor.setter
    def compactor(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "compactor", value)

    @_builtins.property
    @pulumi.getter
    def query(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to query from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "query")

    @query.setter
    def query(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "query", value)

    @_builtins.property
    @pulumi.getter(name="queryFrontend")
    def query_frontend(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to query_frontend from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "query_frontend")

    @query_frontend.setter
    def query_frontend(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "query_frontend", value)

    @_builtins.property
    @pulumi.getter(name="receiverIngesting")
    def receiver_ingesting(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to receiver_ingesting from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "receiver_ingesting")

    @receiver_ingesting.setter
    def receiver_ingesting(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "receiver_ingesting", value)

    @_builtins.property
    @pulumi.getter(name="receiverRouting")
    def receiver_routing(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to receiver_routing from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "receiver_routing")

    @receiver_routing.setter
    def receiver_routing(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "receiver_routing", value)

    @_builtins.property
    @pulumi.getter
    def ruler(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to ruler from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "ruler")

    @ruler.setter
    def ruler(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ruler", value)

    @_builtins.property
    @pulumi.getter
    def store(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to store from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "store")

    @store.setter
    def store(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "store", value)


if not MYPY:
    class ThanosThanosUserConfigQueryArgsDict(TypedDict):
        query_default_evaluation_interval: NotRequired[pulumi.Input[_builtins.str]]
        """
        Set the default evaluation interval for subqueries. Default: `1m`.
        """
        query_lookback_delta: NotRequired[pulumi.Input[_builtins.str]]
        """
        The maximum lookback duration for retrieving metrics during expression evaluations in PromQL. PromQL always evaluates the query for a certain timestamp, and it looks back for the given amount of time to get the latest sample. If it exceeds the maximum lookback delta, it assumes the series is stale and returns none (a gap). The lookback delta should be set to at least 2 times the slowest scrape interval. If unset, it will use the promql default of 5m. Default: `5m`.
        """
        query_metadata_default_time_range: NotRequired[pulumi.Input[_builtins.str]]
        """
        The default metadata time range duration for retrieving labels through Labels and Series API when the range parameters are not specified. The zero value means the range covers the time since the beginning. Default: `0s`.
        """
        query_timeout: NotRequired[pulumi.Input[_builtins.str]]
        """
        Maximum time to process a query by the query node. Default: `2m`.
        """
        store_limits_request_samples: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum samples allowed for a single Series request. The Series call fails if this limit is exceeded. Set to 0 for no limit. NOTE: For efficiency, the limit is internally implemented as 'chunks limit' considering each chunk contains a maximum of 120 samples. The default value is 100 * store.limits.request-series. Default: `0`.
        """
        store_limits_request_series: NotRequired[pulumi.Input[_builtins.int]]
        """
        The maximum series allowed for a single Series request. The Series call fails if this limit is exceeded. Set to 0 for no limit. The default value is 1000 * cpu_count. Default: `0`.
        """
elif False:
    ThanosThanosUserConfigQueryArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ThanosThanosUserConfigQueryArgs:
    def __init__(__self__, *,
                 query_default_evaluation_interval: Optional[pulumi.Input[_builtins.str]] = None,
                 query_lookback_delta: Optional[pulumi.Input[_builtins.str]] = None,
                 query_metadata_default_time_range: Optional[pulumi.Input[_builtins.str]] = None,
                 query_timeout: Optional[pulumi.Input[_builtins.str]] = None,
                 store_limits_request_samples: Optional[pulumi.Input[_builtins.int]] = None,
                 store_limits_request_series: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.str] query_default_evaluation_interval: Set the default evaluation interval for subqueries. Default: `1m`.
        :param pulumi.Input[_builtins.str] query_lookback_delta: The maximum lookback duration for retrieving metrics during expression evaluations in PromQL. PromQL always evaluates the query for a certain timestamp, and it looks back for the given amount of time to get the latest sample. If it exceeds the maximum lookback delta, it assumes the series is stale and returns none (a gap). The lookback delta should be set to at least 2 times the slowest scrape interval. If unset, it will use the promql default of 5m. Default: `5m`.
        :param pulumi.Input[_builtins.str] query_metadata_default_time_range: The default metadata time range duration for retrieving labels through Labels and Series API when the range parameters are not specified. The zero value means the range covers the time since the beginning. Default: `0s`.
        :param pulumi.Input[_builtins.str] query_timeout: Maximum time to process a query by the query node. Default: `2m`.
        :param pulumi.Input[_builtins.int] store_limits_request_samples: The maximum samples allowed for a single Series request. The Series call fails if this limit is exceeded. Set to 0 for no limit. NOTE: For efficiency, the limit is internally implemented as 'chunks limit' considering each chunk contains a maximum of 120 samples. The default value is 100 * store.limits.request-series. Default: `0`.
        :param pulumi.Input[_builtins.int] store_limits_request_series: The maximum series allowed for a single Series request. The Series call fails if this limit is exceeded. Set to 0 for no limit. The default value is 1000 * cpu_count. Default: `0`.
        """
        if query_default_evaluation_interval is not None:
            pulumi.set(__self__, "query_default_evaluation_interval", query_default_evaluation_interval)
        if query_lookback_delta is not None:
            pulumi.set(__self__, "query_lookback_delta", query_lookback_delta)
        if query_metadata_default_time_range is not None:
            pulumi.set(__self__, "query_metadata_default_time_range", query_metadata_default_time_range)
        if query_timeout is not None:
            pulumi.set(__self__, "query_timeout", query_timeout)
        if store_limits_request_samples is not None:
            pulumi.set(__self__, "store_limits_request_samples", store_limits_request_samples)
        if store_limits_request_series is not None:
            pulumi.set(__self__, "store_limits_request_series", store_limits_request_series)

    @_builtins.property
    @pulumi.getter(name="queryDefaultEvaluationInterval")
    def query_default_evaluation_interval(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Set the default evaluation interval for subqueries. Default: `1m`.
        """
        return pulumi.get(self, "query_default_evaluation_interval")

    @query_default_evaluation_interval.setter
    def query_default_evaluation_interval(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "query_default_evaluation_interval", value)

    @_builtins.property
    @pulumi.getter(name="queryLookbackDelta")
    def query_lookback_delta(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The maximum lookback duration for retrieving metrics during expression evaluations in PromQL. PromQL always evaluates the query for a certain timestamp, and it looks back for the given amount of time to get the latest sample. If it exceeds the maximum lookback delta, it assumes the series is stale and returns none (a gap). The lookback delta should be set to at least 2 times the slowest scrape interval. If unset, it will use the promql default of 5m. Default: `5m`.
        """
        return pulumi.get(self, "query_lookback_delta")

    @query_lookback_delta.setter
    def query_lookback_delta(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "query_lookback_delta", value)

    @_builtins.property
    @pulumi.getter(name="queryMetadataDefaultTimeRange")
    def query_metadata_default_time_range(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        The default metadata time range duration for retrieving labels through Labels and Series API when the range parameters are not specified. The zero value means the range covers the time since the beginning. Default: `0s`.
        """
        return pulumi.get(self, "query_metadata_default_time_range")

    @query_metadata_default_time_range.setter
    def query_metadata_default_time_range(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "query_metadata_default_time_range", value)

    @_builtins.property
    @pulumi.getter(name="queryTimeout")
    def query_timeout(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Maximum time to process a query by the query node. Default: `2m`.
        """
        return pulumi.get(self, "query_timeout")

    @query_timeout.setter
    def query_timeout(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "query_timeout", value)

    @_builtins.property
    @pulumi.getter(name="storeLimitsRequestSamples")
    def store_limits_request_samples(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum samples allowed for a single Series request. The Series call fails if this limit is exceeded. Set to 0 for no limit. NOTE: For efficiency, the limit is internally implemented as 'chunks limit' considering each chunk contains a maximum of 120 samples. The default value is 100 * store.limits.request-series. Default: `0`.
        """
        return pulumi.get(self, "store_limits_request_samples")

    @store_limits_request_samples.setter
    def store_limits_request_samples(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "store_limits_request_samples", value)

    @_builtins.property
    @pulumi.getter(name="storeLimitsRequestSeries")
    def store_limits_request_series(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The maximum series allowed for a single Series request. The Series call fails if this limit is exceeded. Set to 0 for no limit. The default value is 1000 * cpu_count. Default: `0`.
        """
        return pulumi.get(self, "store_limits_request_series")

    @store_limits_request_series.setter
    def store_limits_request_series(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "store_limits_request_series", value)


if not MYPY:
    class ThanosThanosUserConfigQueryFrontendArgsDict(TypedDict):
        query_range_align_range_with_step: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether to align the query range boundaries with the step. If enabled, the query range boundaries will be aligned to the step, providing more accurate results for queries with high-resolution data. Default: `true`.
        """
elif False:
    ThanosThanosUserConfigQueryFrontendArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ThanosThanosUserConfigQueryFrontendArgs:
    def __init__(__self__, *,
                 query_range_align_range_with_step: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] query_range_align_range_with_step: Whether to align the query range boundaries with the step. If enabled, the query range boundaries will be aligned to the step, providing more accurate results for queries with high-resolution data. Default: `true`.
        """
        if query_range_align_range_with_step is not None:
            pulumi.set(__self__, "query_range_align_range_with_step", query_range_align_range_with_step)

    @_builtins.property
    @pulumi.getter(name="queryRangeAlignRangeWithStep")
    def query_range_align_range_with_step(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether to align the query range boundaries with the step. If enabled, the query range boundaries will be aligned to the step, providing more accurate results for queries with high-resolution data. Default: `true`.
        """
        return pulumi.get(self, "query_range_align_range_with_step")

    @query_range_align_range_with_step.setter
    def query_range_align_range_with_step(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "query_range_align_range_with_step", value)


if not MYPY:
    class ValkeyComponentArgsDict(TypedDict):
        component: NotRequired[pulumi.Input[_builtins.str]]
        """
        Service component name
        """
        connection_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        host: NotRequired[pulumi.Input[_builtins.str]]
        """
        Host name for connecting to the service component
        """
        kafka_authentication_method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        kafka_ssl_ca: NotRequired[pulumi.Input[_builtins.str]]
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        port: NotRequired[pulumi.Input[_builtins.int]]
        """
        Port number for connecting to the service component
        """
        route: NotRequired[pulumi.Input[_builtins.str]]
        """
        Network access route
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        usage: NotRequired[pulumi.Input[_builtins.str]]
        """
        DNS usage name
        """
elif False:
    ValkeyComponentArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ValkeyComponentArgs:
    def __init__(__self__, *,
                 component: Optional[pulumi.Input[_builtins.str]] = None,
                 connection_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 host: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_authentication_method: Optional[pulumi.Input[_builtins.str]] = None,
                 kafka_ssl_ca: Optional[pulumi.Input[_builtins.str]] = None,
                 port: Optional[pulumi.Input[_builtins.int]] = None,
                 route: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 usage: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] component: Service component name
        :param pulumi.Input[_builtins.str] connection_uri: Connection info for connecting to the service component. This is a combination of host and port.
        :param pulumi.Input[_builtins.str] host: Host name for connecting to the service component
        :param pulumi.Input[_builtins.str] kafka_authentication_method: Kafka authentication method. This is a value specific to the 'kafka' service component
        :param pulumi.Input[_builtins.str] kafka_ssl_ca: Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        :param pulumi.Input[_builtins.int] port: Port number for connecting to the service component
        :param pulumi.Input[_builtins.str] route: Network access route
        :param pulumi.Input[_builtins.bool] ssl: Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        :param pulumi.Input[_builtins.str] usage: DNS usage name
        """
        if component is not None:
            pulumi.set(__self__, "component", component)
        if connection_uri is not None:
            pulumi.set(__self__, "connection_uri", connection_uri)
        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 kafka_ssl_ca is not None:
            pulumi.set(__self__, "kafka_ssl_ca", kafka_ssl_ca)
        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)

    @_builtins.property
    @pulumi.getter
    def component(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Service component name
        """
        return pulumi.get(self, "component")

    @component.setter
    def component(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "component", value)

    @_builtins.property
    @pulumi.getter(name="connectionUri")
    def connection_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Connection info for connecting to the service component. This is a combination of host and port.
        """
        return pulumi.get(self, "connection_uri")

    @connection_uri.setter
    def connection_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "connection_uri", value)

    @_builtins.property
    @pulumi.getter
    def host(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Host name for connecting to the service component
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter(name="kafkaAuthenticationMethod")
    def kafka_authentication_method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka authentication method. This is a value specific to the 'kafka' service component
        """
        return pulumi.get(self, "kafka_authentication_method")

    @kafka_authentication_method.setter
    def kafka_authentication_method(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_authentication_method", value)

    @_builtins.property
    @pulumi.getter(name="kafkaSslCa")
    def kafka_ssl_ca(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Kafka certificate used. The possible values are `letsencrypt` and `project_ca`.
        """
        return pulumi.get(self, "kafka_ssl_ca")

    @kafka_ssl_ca.setter
    def kafka_ssl_ca(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "kafka_ssl_ca", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Port number for connecting to the service component
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def route(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Network access route
        """
        return pulumi.get(self, "route")

    @route.setter
    def route(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "route", value)

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Whether the endpoint is encrypted or accepts plaintext. By default endpoints are always encrypted and this property is only included for service components they may disable encryption
        """
        return pulumi.get(self, "ssl")

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ssl", value)

    @_builtins.property
    @pulumi.getter
    def usage(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        DNS usage name
        """
        return pulumi.get(self, "usage")

    @usage.setter
    def usage(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "usage", value)


if not MYPY:
    class ValkeyServiceIntegrationArgsDict(TypedDict):
        integration_type: pulumi.Input[_builtins.str]
        """
        Type of the service integration. The possible value is `read_replica`.
        """
        source_service_name: pulumi.Input[_builtins.str]
        """
        Name of the source service
        """
elif False:
    ValkeyServiceIntegrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ValkeyServiceIntegrationArgs:
    def __init__(__self__, *,
                 integration_type: pulumi.Input[_builtins.str],
                 source_service_name: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] integration_type: Type of the service integration. The possible value is `read_replica`.
        :param pulumi.Input[_builtins.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)

    @_builtins.property
    @pulumi.getter(name="integrationType")
    def integration_type(self) -> pulumi.Input[_builtins.str]:
        """
        Type of the service integration. The possible value is `read_replica`.
        """
        return pulumi.get(self, "integration_type")

    @integration_type.setter
    def integration_type(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "integration_type", value)

    @_builtins.property
    @pulumi.getter(name="sourceServiceName")
    def source_service_name(self) -> pulumi.Input[_builtins.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[_builtins.str]):
        pulumi.set(self, "source_service_name", value)


if not MYPY:
    class ValkeyTagArgsDict(TypedDict):
        key: pulumi.Input[_builtins.str]
        """
        Service tag key
        """
        value: pulumi.Input[_builtins.str]
        """
        Service tag value
        """
elif False:
    ValkeyTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ValkeyTagArgs:
    def __init__(__self__, *,
                 key: pulumi.Input[_builtins.str],
                 value: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] key: Service tag key
        :param pulumi.Input[_builtins.str] value: Service tag value
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def key(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag key
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "key", value)

    @_builtins.property
    @pulumi.getter
    def value(self) -> pulumi.Input[_builtins.str]:
        """
        Service tag value
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "value", value)


if not MYPY:
    class ValkeyTechEmailArgsDict(TypedDict):
        email: pulumi.Input[_builtins.str]
        """
        An email address to contact for technical issues
        """
elif False:
    ValkeyTechEmailArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ValkeyTechEmailArgs:
    def __init__(__self__, *,
                 email: pulumi.Input[_builtins.str]):
        """
        :param pulumi.Input[_builtins.str] email: An email address to contact for technical issues
        """
        pulumi.set(__self__, "email", email)

    @_builtins.property
    @pulumi.getter
    def email(self) -> pulumi.Input[_builtins.str]:
        """
        An email address to contact for technical issues
        """
        return pulumi.get(self, "email")

    @email.setter
    def email(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "email", value)


if not MYPY:
    class ValkeyValkeyArgsDict(TypedDict):
        password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Valkey password.
        """
        replica_uri: NotRequired[pulumi.Input[_builtins.str]]
        """
        Valkey replica server URI.
        """
        slave_uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Valkey slave server URIs.
        """
        uris: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Valkey server URIs.
        """
elif False:
    ValkeyValkeyArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ValkeyValkeyArgs:
    def __init__(__self__, *,
                 password: Optional[pulumi.Input[_builtins.str]] = None,
                 replica_uri: Optional[pulumi.Input[_builtins.str]] = None,
                 slave_uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 uris: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
        """
        :param pulumi.Input[_builtins.str] password: Valkey password.
        :param pulumi.Input[_builtins.str] replica_uri: Valkey replica server URI.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] slave_uris: Valkey slave server URIs.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] uris: Valkey server URIs.
        """
        if password is not None:
            pulumi.set(__self__, "password", password)
        if replica_uri is not None:
            pulumi.set(__self__, "replica_uri", replica_uri)
        if slave_uris is not None:
            pulumi.set(__self__, "slave_uris", slave_uris)
        if uris is not None:
            pulumi.set(__self__, "uris", uris)

    @_builtins.property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Valkey password.
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "password", value)

    @_builtins.property
    @pulumi.getter(name="replicaUri")
    def replica_uri(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Valkey replica server URI.
        """
        return pulumi.get(self, "replica_uri")

    @replica_uri.setter
    def replica_uri(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "replica_uri", value)

    @_builtins.property
    @pulumi.getter(name="slaveUris")
    def slave_uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Valkey slave server URIs.
        """
        return pulumi.get(self, "slave_uris")

    @slave_uris.setter
    def slave_uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "slave_uris", value)

    @_builtins.property
    @pulumi.getter
    def uris(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Valkey server URIs.
        """
        return pulumi.get(self, "uris")

    @uris.setter
    def uris(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "uris", value)


if not MYPY:
    class ValkeyValkeyUserConfigArgsDict(TypedDict):
        additional_backup_regions: NotRequired[pulumi.Input[_builtins.str]]
        """
        Additional Cloud Regions for Backup Replication.
        """
        backup_hour: NotRequired[pulumi.Input[_builtins.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. Example: `3`.
        """
        backup_minute: NotRequired[pulumi.Input[_builtins.int]]
        """
        The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed. Example: `30`.
        """
        enable_ipv6: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Register AAAA DNS records for the service, and allow IPv6 packets to service ports.
        """
        frequent_snapshots: NotRequired[pulumi.Input[_builtins.bool]]
        """
        When enabled, Valkey will create frequent local RDB snapshots. When disabled, Valkey will only take RDB snapshots when a backup is created, based on the backup schedule. This setting is ignored when `valkey_persistence` is set to `off`. Default: `true`.
        """
        ip_filter_objects: NotRequired[pulumi.Input[Sequence[pulumi.Input['ValkeyValkeyUserConfigIpFilterObjectArgsDict']]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        """
        ip_filter_strings: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        ip_filters: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        migration: NotRequired[pulumi.Input['ValkeyValkeyUserConfigMigrationArgsDict']]
        """
        Migrate data from existing server
        """
        private_access: NotRequired[pulumi.Input['ValkeyValkeyUserConfigPrivateAccessArgsDict']]
        """
        Allow access to selected service ports from private networks
        """
        privatelink_access: NotRequired[pulumi.Input['ValkeyValkeyUserConfigPrivatelinkAccessArgsDict']]
        """
        Allow access to selected service components through Privatelink
        """
        project_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        public_access: NotRequired[pulumi.Input['ValkeyValkeyUserConfigPublicAccessArgsDict']]
        """
        Allow access to selected service ports from the public Internet
        """
        recovery_basebackup_name: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of the basebackup to restore in forked service. Example: `backup-20191112t091354293891z`.
        """
        service_log: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        service_to_fork_from: NotRequired[pulumi.Input[_builtins.str]]
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        static_ips: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Use static public IP addresses.
        """
        valkey_acl_channels_default: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `allchannels`, `resetchannels`. Determines default pub/sub channels' ACL for new users if ACL is not supplied. When this option is not defined, all_channels is assumed to keep backward compatibility. This option doesn't affect Valkey configuration acl-pubsub-default.
        """
        valkey_active_expire_effort: NotRequired[pulumi.Input[_builtins.int]]
        """
        Valkey reclaims expired keys both when accessed and in the background. The background process scans for expired keys to free memory. Increasing the active-expire-effort setting (default 1, max 10) uses more CPU to reclaim expired keys faster, reducing memory usage but potentially increasing latency. Default: `1`.
        """
        valkey_io_threads: NotRequired[pulumi.Input[_builtins.int]]
        """
        Set Valkey IO thread count. Changing this will cause a restart of the Valkey service. Example: `1`.
        """
        valkey_lfu_decay_time: NotRequired[pulumi.Input[_builtins.int]]
        """
        LFU maxmemory-policy counter decay time in minutes. Default: `1`.
        """
        valkey_lfu_log_factor: NotRequired[pulumi.Input[_builtins.int]]
        """
        Counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory-policies. Default: `10`.
        """
        valkey_maxmemory_policy: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `allkeys-lfu`, `allkeys-lru`, `allkeys-random`, `noeviction`, `volatile-lfu`, `volatile-lru`, `volatile-random`, `volatile-ttl`. Valkey maxmemory-policy. Default: `noeviction`.
        """
        valkey_notify_keyspace_events: NotRequired[pulumi.Input[_builtins.str]]
        """
        Set notify-keyspace-events option.
        """
        valkey_number_of_databases: NotRequired[pulumi.Input[_builtins.int]]
        """
        Set number of Valkey databases. Changing this will cause a restart of the Valkey service. Example: `16`.
        """
        valkey_persistence: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `off`, `rdb`. When persistence is `rdb`, Valkey does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
        """
        valkey_pubsub_client_output_buffer_limit: NotRequired[pulumi.Input[_builtins.int]]
        """
        Set output buffer limit for pub / sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan. Example: `64`.
        """
        valkey_ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Require SSL to access Valkey. Default: `true`.
        """
        valkey_timeout: NotRequired[pulumi.Input[_builtins.int]]
        """
        Valkey idle connection timeout in seconds. Default: `300`.
        """
elif False:
    ValkeyValkeyUserConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ValkeyValkeyUserConfigArgs:
    def __init__(__self__, *,
                 additional_backup_regions: Optional[pulumi.Input[_builtins.str]] = None,
                 backup_hour: Optional[pulumi.Input[_builtins.int]] = None,
                 backup_minute: Optional[pulumi.Input[_builtins.int]] = None,
                 enable_ipv6: Optional[pulumi.Input[_builtins.bool]] = None,
                 frequent_snapshots: Optional[pulumi.Input[_builtins.bool]] = None,
                 ip_filter_objects: Optional[pulumi.Input[Sequence[pulumi.Input['ValkeyValkeyUserConfigIpFilterObjectArgs']]]] = None,
                 ip_filter_strings: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 ip_filters: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
                 migration: Optional[pulumi.Input['ValkeyValkeyUserConfigMigrationArgs']] = None,
                 private_access: Optional[pulumi.Input['ValkeyValkeyUserConfigPrivateAccessArgs']] = None,
                 privatelink_access: Optional[pulumi.Input['ValkeyValkeyUserConfigPrivatelinkAccessArgs']] = None,
                 project_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 public_access: Optional[pulumi.Input['ValkeyValkeyUserConfigPublicAccessArgs']] = None,
                 recovery_basebackup_name: Optional[pulumi.Input[_builtins.str]] = None,
                 service_log: Optional[pulumi.Input[_builtins.bool]] = None,
                 service_to_fork_from: Optional[pulumi.Input[_builtins.str]] = None,
                 static_ips: Optional[pulumi.Input[_builtins.bool]] = None,
                 valkey_acl_channels_default: Optional[pulumi.Input[_builtins.str]] = None,
                 valkey_active_expire_effort: Optional[pulumi.Input[_builtins.int]] = None,
                 valkey_io_threads: Optional[pulumi.Input[_builtins.int]] = None,
                 valkey_lfu_decay_time: Optional[pulumi.Input[_builtins.int]] = None,
                 valkey_lfu_log_factor: Optional[pulumi.Input[_builtins.int]] = None,
                 valkey_maxmemory_policy: Optional[pulumi.Input[_builtins.str]] = None,
                 valkey_notify_keyspace_events: Optional[pulumi.Input[_builtins.str]] = None,
                 valkey_number_of_databases: Optional[pulumi.Input[_builtins.int]] = None,
                 valkey_persistence: Optional[pulumi.Input[_builtins.str]] = None,
                 valkey_pubsub_client_output_buffer_limit: Optional[pulumi.Input[_builtins.int]] = None,
                 valkey_ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 valkey_timeout: Optional[pulumi.Input[_builtins.int]] = None):
        """
        :param pulumi.Input[_builtins.str] additional_backup_regions: Additional Cloud Regions for Backup Replication.
        :param pulumi.Input[_builtins.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. Example: `3`.
        :param pulumi.Input[_builtins.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. Example: `30`.
        :param pulumi.Input[_builtins.bool] enable_ipv6: Register AAAA DNS records for the service, and allow IPv6 packets to service ports.
        :param pulumi.Input[_builtins.bool] frequent_snapshots: When enabled, Valkey will create frequent local RDB snapshots. When disabled, Valkey will only take RDB snapshots when a backup is created, based on the backup schedule. This setting is ignored when `valkey_persistence` is set to `off`. Default: `true`.
        :param pulumi.Input[Sequence[pulumi.Input['ValkeyValkeyUserConfigIpFilterObjectArgs']]] ip_filter_objects: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filter_strings: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] ip_filters: Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        :param pulumi.Input['ValkeyValkeyUserConfigMigrationArgs'] migration: Migrate data from existing server
        :param pulumi.Input['ValkeyValkeyUserConfigPrivateAccessArgs'] private_access: Allow access to selected service ports from private networks
        :param pulumi.Input['ValkeyValkeyUserConfigPrivatelinkAccessArgs'] privatelink_access: Allow access to selected service components through Privatelink
        :param pulumi.Input[_builtins.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. Example: `anotherprojectname`.
        :param pulumi.Input['ValkeyValkeyUserConfigPublicAccessArgs'] public_access: Allow access to selected service ports from the public Internet
        :param pulumi.Input[_builtins.str] recovery_basebackup_name: Name of the basebackup to restore in forked service. Example: `backup-20191112t091354293891z`.
        :param pulumi.Input[_builtins.bool] service_log: Store logs for the service so that they are available in the HTTP API and console.
        :param pulumi.Input[_builtins.str] service_to_fork_from: Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        :param pulumi.Input[_builtins.bool] static_ips: Use static public IP addresses.
        :param pulumi.Input[_builtins.str] valkey_acl_channels_default: Enum: `allchannels`, `resetchannels`. Determines default pub/sub channels' ACL for new users if ACL is not supplied. When this option is not defined, all_channels is assumed to keep backward compatibility. This option doesn't affect Valkey configuration acl-pubsub-default.
        :param pulumi.Input[_builtins.int] valkey_active_expire_effort: Valkey reclaims expired keys both when accessed and in the background. The background process scans for expired keys to free memory. Increasing the active-expire-effort setting (default 1, max 10) uses more CPU to reclaim expired keys faster, reducing memory usage but potentially increasing latency. Default: `1`.
        :param pulumi.Input[_builtins.int] valkey_io_threads: Set Valkey IO thread count. Changing this will cause a restart of the Valkey service. Example: `1`.
        :param pulumi.Input[_builtins.int] valkey_lfu_decay_time: LFU maxmemory-policy counter decay time in minutes. Default: `1`.
        :param pulumi.Input[_builtins.int] valkey_lfu_log_factor: Counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory-policies. Default: `10`.
        :param pulumi.Input[_builtins.str] valkey_maxmemory_policy: Enum: `allkeys-lfu`, `allkeys-lru`, `allkeys-random`, `noeviction`, `volatile-lfu`, `volatile-lru`, `volatile-random`, `volatile-ttl`. Valkey maxmemory-policy. Default: `noeviction`.
        :param pulumi.Input[_builtins.str] valkey_notify_keyspace_events: Set notify-keyspace-events option.
        :param pulumi.Input[_builtins.int] valkey_number_of_databases: Set number of Valkey databases. Changing this will cause a restart of the Valkey service. Example: `16`.
        :param pulumi.Input[_builtins.str] valkey_persistence: Enum: `off`, `rdb`. When persistence is `rdb`, Valkey does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
        :param pulumi.Input[_builtins.int] valkey_pubsub_client_output_buffer_limit: Set output buffer limit for pub / sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan. Example: `64`.
        :param pulumi.Input[_builtins.bool] valkey_ssl: Require SSL to access Valkey. Default: `true`.
        :param pulumi.Input[_builtins.int] valkey_timeout: Valkey idle connection timeout in seconds. Default: `300`.
        """
        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 enable_ipv6 is not None:
            pulumi.set(__self__, "enable_ipv6", enable_ipv6)
        if frequent_snapshots is not None:
            pulumi.set(__self__, "frequent_snapshots", frequent_snapshots)
        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("""Deprecated. Use `ip_filter_string` instead.""", DeprecationWarning)
            pulumi.log.warn("""ip_filters is deprecated: Deprecated. Use `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 service_log is not None:
            pulumi.set(__self__, "service_log", service_log)
        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)
        if valkey_acl_channels_default is not None:
            pulumi.set(__self__, "valkey_acl_channels_default", valkey_acl_channels_default)
        if valkey_active_expire_effort is not None:
            pulumi.set(__self__, "valkey_active_expire_effort", valkey_active_expire_effort)
        if valkey_io_threads is not None:
            pulumi.set(__self__, "valkey_io_threads", valkey_io_threads)
        if valkey_lfu_decay_time is not None:
            pulumi.set(__self__, "valkey_lfu_decay_time", valkey_lfu_decay_time)
        if valkey_lfu_log_factor is not None:
            pulumi.set(__self__, "valkey_lfu_log_factor", valkey_lfu_log_factor)
        if valkey_maxmemory_policy is not None:
            pulumi.set(__self__, "valkey_maxmemory_policy", valkey_maxmemory_policy)
        if valkey_notify_keyspace_events is not None:
            pulumi.set(__self__, "valkey_notify_keyspace_events", valkey_notify_keyspace_events)
        if valkey_number_of_databases is not None:
            pulumi.set(__self__, "valkey_number_of_databases", valkey_number_of_databases)
        if valkey_persistence is not None:
            pulumi.set(__self__, "valkey_persistence", valkey_persistence)
        if valkey_pubsub_client_output_buffer_limit is not None:
            pulumi.set(__self__, "valkey_pubsub_client_output_buffer_limit", valkey_pubsub_client_output_buffer_limit)
        if valkey_ssl is not None:
            pulumi.set(__self__, "valkey_ssl", valkey_ssl)
        if valkey_timeout is not None:
            pulumi.set(__self__, "valkey_timeout", valkey_timeout)

    @_builtins.property
    @pulumi.getter(name="additionalBackupRegions")
    def additional_backup_regions(self) -> Optional[pulumi.Input[_builtins.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[_builtins.str]]):
        pulumi.set(self, "additional_backup_regions", value)

    @_builtins.property
    @pulumi.getter(name="backupHour")
    def backup_hour(self) -> Optional[pulumi.Input[_builtins.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. Example: `3`.
        """
        return pulumi.get(self, "backup_hour")

    @backup_hour.setter
    def backup_hour(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "backup_hour", value)

    @_builtins.property
    @pulumi.getter(name="backupMinute")
    def backup_minute(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        The minute of an hour when backup for the service is started. New backup is only started if previous backup has already completed. Example: `30`.
        """
        return pulumi.get(self, "backup_minute")

    @backup_minute.setter
    def backup_minute(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "backup_minute", value)

    @_builtins.property
    @pulumi.getter(name="enableIpv6")
    def enable_ipv6(self) -> Optional[pulumi.Input[_builtins.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[_builtins.bool]]):
        pulumi.set(self, "enable_ipv6", value)

    @_builtins.property
    @pulumi.getter(name="frequentSnapshots")
    def frequent_snapshots(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        When enabled, Valkey will create frequent local RDB snapshots. When disabled, Valkey will only take RDB snapshots when a backup is created, based on the backup schedule. This setting is ignored when `valkey_persistence` is set to `off`. Default: `true`.
        """
        return pulumi.get(self, "frequent_snapshots")

    @frequent_snapshots.setter
    def frequent_snapshots(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "frequent_snapshots", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterObjects")
    def ip_filter_objects(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ValkeyValkeyUserConfigIpFilterObjectArgs']]]]:
        """
        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['ValkeyValkeyUserConfigIpFilterObjectArgs']]]]):
        pulumi.set(self, "ip_filter_objects", value)

    @_builtins.property
    @pulumi.getter(name="ipFilterStrings")
    def ip_filter_strings(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.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[_builtins.str]]]]):
        pulumi.set(self, "ip_filter_strings", value)

    @_builtins.property
    @pulumi.getter(name="ipFilters")
    @_utilities.deprecated("""Deprecated. Use `ip_filter_string` instead.""")
    def ip_filters(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
        """
        Allow incoming connections from CIDR address block, e.g. `10.20.0.0/16`.
        """
        return pulumi.get(self, "ip_filters")

    @ip_filters.setter
    def ip_filters(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
        pulumi.set(self, "ip_filters", value)

    @_builtins.property
    @pulumi.getter
    def migration(self) -> Optional[pulumi.Input['ValkeyValkeyUserConfigMigrationArgs']]:
        """
        Migrate data from existing server
        """
        return pulumi.get(self, "migration")

    @migration.setter
    def migration(self, value: Optional[pulumi.Input['ValkeyValkeyUserConfigMigrationArgs']]):
        pulumi.set(self, "migration", value)

    @_builtins.property
    @pulumi.getter(name="privateAccess")
    def private_access(self) -> Optional[pulumi.Input['ValkeyValkeyUserConfigPrivateAccessArgs']]:
        """
        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['ValkeyValkeyUserConfigPrivateAccessArgs']]):
        pulumi.set(self, "private_access", value)

    @_builtins.property
    @pulumi.getter(name="privatelinkAccess")
    def privatelink_access(self) -> Optional[pulumi.Input['ValkeyValkeyUserConfigPrivatelinkAccessArgs']]:
        """
        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['ValkeyValkeyUserConfigPrivatelinkAccessArgs']]):
        pulumi.set(self, "privatelink_access", value)

    @_builtins.property
    @pulumi.getter(name="projectToForkFrom")
    def project_to_fork_from(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of another project to fork a service from. This has effect only when a new service is being created. Example: `anotherprojectname`.
        """
        return pulumi.get(self, "project_to_fork_from")

    @project_to_fork_from.setter
    def project_to_fork_from(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "project_to_fork_from", value)

    @_builtins.property
    @pulumi.getter(name="publicAccess")
    def public_access(self) -> Optional[pulumi.Input['ValkeyValkeyUserConfigPublicAccessArgs']]:
        """
        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['ValkeyValkeyUserConfigPublicAccessArgs']]):
        pulumi.set(self, "public_access", value)

    @_builtins.property
    @pulumi.getter(name="recoveryBasebackupName")
    def recovery_basebackup_name(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of the basebackup to restore in forked service. Example: `backup-20191112t091354293891z`.
        """
        return pulumi.get(self, "recovery_basebackup_name")

    @recovery_basebackup_name.setter
    def recovery_basebackup_name(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "recovery_basebackup_name", value)

    @_builtins.property
    @pulumi.getter(name="serviceLog")
    def service_log(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Store logs for the service so that they are available in the HTTP API and console.
        """
        return pulumi.get(self, "service_log")

    @service_log.setter
    def service_log(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "service_log", value)

    @_builtins.property
    @pulumi.getter(name="serviceToForkFrom")
    def service_to_fork_from(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Name of another service to fork from. This has effect only when a new service is being created. Example: `anotherservicename`.
        """
        return pulumi.get(self, "service_to_fork_from")

    @service_to_fork_from.setter
    def service_to_fork_from(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "service_to_fork_from", value)

    @_builtins.property
    @pulumi.getter(name="staticIps")
    def static_ips(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Use static public IP addresses.
        """
        return pulumi.get(self, "static_ips")

    @static_ips.setter
    def static_ips(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "static_ips", value)

    @_builtins.property
    @pulumi.getter(name="valkeyAclChannelsDefault")
    def valkey_acl_channels_default(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `allchannels`, `resetchannels`. Determines default pub/sub channels' ACL for new users if ACL is not supplied. When this option is not defined, all_channels is assumed to keep backward compatibility. This option doesn't affect Valkey configuration acl-pubsub-default.
        """
        return pulumi.get(self, "valkey_acl_channels_default")

    @valkey_acl_channels_default.setter
    def valkey_acl_channels_default(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "valkey_acl_channels_default", value)

    @_builtins.property
    @pulumi.getter(name="valkeyActiveExpireEffort")
    def valkey_active_expire_effort(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Valkey reclaims expired keys both when accessed and in the background. The background process scans for expired keys to free memory. Increasing the active-expire-effort setting (default 1, max 10) uses more CPU to reclaim expired keys faster, reducing memory usage but potentially increasing latency. Default: `1`.
        """
        return pulumi.get(self, "valkey_active_expire_effort")

    @valkey_active_expire_effort.setter
    def valkey_active_expire_effort(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "valkey_active_expire_effort", value)

    @_builtins.property
    @pulumi.getter(name="valkeyIoThreads")
    def valkey_io_threads(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Set Valkey IO thread count. Changing this will cause a restart of the Valkey service. Example: `1`.
        """
        return pulumi.get(self, "valkey_io_threads")

    @valkey_io_threads.setter
    def valkey_io_threads(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "valkey_io_threads", value)

    @_builtins.property
    @pulumi.getter(name="valkeyLfuDecayTime")
    def valkey_lfu_decay_time(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        LFU maxmemory-policy counter decay time in minutes. Default: `1`.
        """
        return pulumi.get(self, "valkey_lfu_decay_time")

    @valkey_lfu_decay_time.setter
    def valkey_lfu_decay_time(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "valkey_lfu_decay_time", value)

    @_builtins.property
    @pulumi.getter(name="valkeyLfuLogFactor")
    def valkey_lfu_log_factor(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Counter logarithm factor for volatile-lfu and allkeys-lfu maxmemory-policies. Default: `10`.
        """
        return pulumi.get(self, "valkey_lfu_log_factor")

    @valkey_lfu_log_factor.setter
    def valkey_lfu_log_factor(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "valkey_lfu_log_factor", value)

    @_builtins.property
    @pulumi.getter(name="valkeyMaxmemoryPolicy")
    def valkey_maxmemory_policy(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `allkeys-lfu`, `allkeys-lru`, `allkeys-random`, `noeviction`, `volatile-lfu`, `volatile-lru`, `volatile-random`, `volatile-ttl`. Valkey maxmemory-policy. Default: `noeviction`.
        """
        return pulumi.get(self, "valkey_maxmemory_policy")

    @valkey_maxmemory_policy.setter
    def valkey_maxmemory_policy(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "valkey_maxmemory_policy", value)

    @_builtins.property
    @pulumi.getter(name="valkeyNotifyKeyspaceEvents")
    def valkey_notify_keyspace_events(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Set notify-keyspace-events option.
        """
        return pulumi.get(self, "valkey_notify_keyspace_events")

    @valkey_notify_keyspace_events.setter
    def valkey_notify_keyspace_events(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "valkey_notify_keyspace_events", value)

    @_builtins.property
    @pulumi.getter(name="valkeyNumberOfDatabases")
    def valkey_number_of_databases(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Set number of Valkey databases. Changing this will cause a restart of the Valkey service. Example: `16`.
        """
        return pulumi.get(self, "valkey_number_of_databases")

    @valkey_number_of_databases.setter
    def valkey_number_of_databases(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "valkey_number_of_databases", value)

    @_builtins.property
    @pulumi.getter(name="valkeyPersistence")
    def valkey_persistence(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `off`, `rdb`. When persistence is `rdb`, Valkey does RDB dumps each 10 minutes if any key is changed. Also RDB dumps are done according to backup schedule for backup purposes. When persistence is `off`, no RDB dumps and backups are done, so data can be lost at any moment if service is restarted for any reason, or if service is powered off. Also service can't be forked.
        """
        return pulumi.get(self, "valkey_persistence")

    @valkey_persistence.setter
    def valkey_persistence(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "valkey_persistence", value)

    @_builtins.property
    @pulumi.getter(name="valkeyPubsubClientOutputBufferLimit")
    def valkey_pubsub_client_output_buffer_limit(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Set output buffer limit for pub / sub clients in MB. The value is the hard limit, the soft limit is 1/4 of the hard limit. When setting the limit, be mindful of the available memory in the selected service plan. Example: `64`.
        """
        return pulumi.get(self, "valkey_pubsub_client_output_buffer_limit")

    @valkey_pubsub_client_output_buffer_limit.setter
    def valkey_pubsub_client_output_buffer_limit(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "valkey_pubsub_client_output_buffer_limit", value)

    @_builtins.property
    @pulumi.getter(name="valkeySsl")
    def valkey_ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Require SSL to access Valkey. Default: `true`.
        """
        return pulumi.get(self, "valkey_ssl")

    @valkey_ssl.setter
    def valkey_ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "valkey_ssl", value)

    @_builtins.property
    @pulumi.getter(name="valkeyTimeout")
    def valkey_timeout(self) -> Optional[pulumi.Input[_builtins.int]]:
        """
        Valkey idle connection timeout in seconds. Default: `300`.
        """
        return pulumi.get(self, "valkey_timeout")

    @valkey_timeout.setter
    def valkey_timeout(self, value: Optional[pulumi.Input[_builtins.int]]):
        pulumi.set(self, "valkey_timeout", value)


if not MYPY:
    class ValkeyValkeyUserConfigIpFilterObjectArgsDict(TypedDict):
        network: pulumi.Input[_builtins.str]
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        description: NotRequired[pulumi.Input[_builtins.str]]
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
elif False:
    ValkeyValkeyUserConfigIpFilterObjectArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ValkeyValkeyUserConfigIpFilterObjectArgs:
    def __init__(__self__, *,
                 network: pulumi.Input[_builtins.str],
                 description: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] network: CIDR address block. Example: `10.20.0.0/16`.
        :param pulumi.Input[_builtins.str] description: Description for IP filter list entry. Example: `Production service IP range`.
        """
        pulumi.set(__self__, "network", network)
        if description is not None:
            pulumi.set(__self__, "description", description)

    @_builtins.property
    @pulumi.getter
    def network(self) -> pulumi.Input[_builtins.str]:
        """
        CIDR address block. Example: `10.20.0.0/16`.
        """
        return pulumi.get(self, "network")

    @network.setter
    def network(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "network", value)

    @_builtins.property
    @pulumi.getter
    def description(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Description for IP filter list entry. Example: `Production service IP range`.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "description", value)


if not MYPY:
    class ValkeyValkeyUserConfigMigrationArgsDict(TypedDict):
        host: pulumi.Input[_builtins.str]
        """
        Hostname or IP address of the server where to migrate data from. Example: `my.server.com`.
        """
        port: pulumi.Input[_builtins.int]
        """
        Port number of the server where to migrate data from. Example: `1234`.
        """
        dbname: NotRequired[pulumi.Input[_builtins.str]]
        """
        Database name for bootstrapping the initial connection. Example: `defaultdb`.
        """
        ignore_dbs: NotRequired[pulumi.Input[_builtins.str]]
        """
        Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
        """
        ignore_roles: NotRequired[pulumi.Input[_builtins.str]]
        """
        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
        """
        method: NotRequired[pulumi.Input[_builtins.str]]
        """
        Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
        """
        password: NotRequired[pulumi.Input[_builtins.str]]
        """
        Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
        """
        ssl: NotRequired[pulumi.Input[_builtins.bool]]
        """
        The server where to migrate data from is secured with SSL. Default: `true`.
        """
        username: NotRequired[pulumi.Input[_builtins.str]]
        """
        User name for authentication with the server where to migrate data from. Example: `myname`.
        """
elif False:
    ValkeyValkeyUserConfigMigrationArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ValkeyValkeyUserConfigMigrationArgs:
    def __init__(__self__, *,
                 host: pulumi.Input[_builtins.str],
                 port: pulumi.Input[_builtins.int],
                 dbname: Optional[pulumi.Input[_builtins.str]] = None,
                 ignore_dbs: Optional[pulumi.Input[_builtins.str]] = None,
                 ignore_roles: Optional[pulumi.Input[_builtins.str]] = None,
                 method: Optional[pulumi.Input[_builtins.str]] = None,
                 password: Optional[pulumi.Input[_builtins.str]] = None,
                 ssl: Optional[pulumi.Input[_builtins.bool]] = None,
                 username: Optional[pulumi.Input[_builtins.str]] = None):
        """
        :param pulumi.Input[_builtins.str] host: Hostname or IP address of the server where to migrate data from. Example: `my.server.com`.
        :param pulumi.Input[_builtins.int] port: Port number of the server where to migrate data from. Example: `1234`.
        :param pulumi.Input[_builtins.str] dbname: Database name for bootstrapping the initial connection. Example: `defaultdb`.
        :param pulumi.Input[_builtins.str] ignore_dbs: Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
        :param pulumi.Input[_builtins.str] ignore_roles: Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
        :param pulumi.Input[_builtins.str] method: Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
        :param pulumi.Input[_builtins.str] password: Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
        :param pulumi.Input[_builtins.bool] ssl: The server where to migrate data from is secured with SSL. Default: `true`.
        :param pulumi.Input[_builtins.str] username: User name for authentication with the server where to migrate data from. Example: `myname`.
        """
        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 ignore_roles is not None:
            pulumi.set(__self__, "ignore_roles", ignore_roles)
        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)

    @_builtins.property
    @pulumi.getter
    def host(self) -> pulumi.Input[_builtins.str]:
        """
        Hostname or IP address of the server where to migrate data from. Example: `my.server.com`.
        """
        return pulumi.get(self, "host")

    @host.setter
    def host(self, value: pulumi.Input[_builtins.str]):
        pulumi.set(self, "host", value)

    @_builtins.property
    @pulumi.getter
    def port(self) -> pulumi.Input[_builtins.int]:
        """
        Port number of the server where to migrate data from. Example: `1234`.
        """
        return pulumi.get(self, "port")

    @port.setter
    def port(self, value: pulumi.Input[_builtins.int]):
        pulumi.set(self, "port", value)

    @_builtins.property
    @pulumi.getter
    def dbname(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Database name for bootstrapping the initial connection. Example: `defaultdb`.
        """
        return pulumi.get(self, "dbname")

    @dbname.setter
    def dbname(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "dbname", value)

    @_builtins.property
    @pulumi.getter(name="ignoreDbs")
    def ignore_dbs(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Comma-separated list of databases, which should be ignored during migration (supported by MySQL and PostgreSQL only at the moment). Example: `db1,db2`.
        """
        return pulumi.get(self, "ignore_dbs")

    @ignore_dbs.setter
    def ignore_dbs(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ignore_dbs", value)

    @_builtins.property
    @pulumi.getter(name="ignoreRoles")
    def ignore_roles(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Comma-separated list of database roles, which should be ignored during migration (supported by PostgreSQL only at the moment). Example: `role1,role2`.
        """
        return pulumi.get(self, "ignore_roles")

    @ignore_roles.setter
    def ignore_roles(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "ignore_roles", value)

    @_builtins.property
    @pulumi.getter
    def method(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Enum: `dump`, `replication`. The migration method to be used (currently supported only by Redis, Dragonfly, MySQL and PostgreSQL service types).
        """
        return pulumi.get(self, "method")

    @method.setter
    def method(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "method", value)

    @_builtins.property
    @pulumi.getter
    def password(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        Password for authentication with the server where to migrate data from. Example: `jjKk45Nnd`.
        """
        return pulumi.get(self, "password")

    @password.setter
    def password(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "password", value)

    @_builtins.property
    @pulumi.getter
    def ssl(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        The server where to migrate data from is secured with SSL. Default: `true`.
        """
        return pulumi.get(self, "ssl")

    @ssl.setter
    def ssl(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "ssl", value)

    @_builtins.property
    @pulumi.getter
    def username(self) -> Optional[pulumi.Input[_builtins.str]]:
        """
        User name for authentication with the server where to migrate data from. Example: `myname`.
        """
        return pulumi.get(self, "username")

    @username.setter
    def username(self, value: Optional[pulumi.Input[_builtins.str]]):
        pulumi.set(self, "username", value)


if not MYPY:
    class ValkeyValkeyUserConfigPrivateAccessArgsDict(TypedDict):
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        valkey: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to valkey with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
elif False:
    ValkeyValkeyUserConfigPrivateAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ValkeyValkeyUserConfigPrivateAccessArgs:
    def __init__(__self__, *,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None,
                 valkey: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        :param pulumi.Input[_builtins.bool] valkey: Allow clients to connect to valkey with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)
        if valkey is not None:
            pulumi.set(__self__, "valkey", valkey)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "prometheus", value)

    @_builtins.property
    @pulumi.getter
    def valkey(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to valkey with a DNS name that always resolves to the service's private IP addresses. Only available in certain network locations.
        """
        return pulumi.get(self, "valkey")

    @valkey.setter
    def valkey(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "valkey", value)


if not MYPY:
    class ValkeyValkeyUserConfigPrivatelinkAccessArgsDict(TypedDict):
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable prometheus.
        """
        valkey: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Enable valkey.
        """
elif False:
    ValkeyValkeyUserConfigPrivatelinkAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ValkeyValkeyUserConfigPrivatelinkAccessArgs:
    def __init__(__self__, *,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None,
                 valkey: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] prometheus: Enable prometheus.
        :param pulumi.Input[_builtins.bool] valkey: Enable valkey.
        """
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)
        if valkey is not None:
            pulumi.set(__self__, "valkey", valkey)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable prometheus.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "prometheus", value)

    @_builtins.property
    @pulumi.getter
    def valkey(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Enable valkey.
        """
        return pulumi.get(self, "valkey")

    @valkey.setter
    def valkey(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "valkey", value)


if not MYPY:
    class ValkeyValkeyUserConfigPublicAccessArgsDict(TypedDict):
        prometheus: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        valkey: NotRequired[pulumi.Input[_builtins.bool]]
        """
        Allow clients to connect to valkey from the public internet for service nodes that are in a project VPC or another type of private network.
        """
elif False:
    ValkeyValkeyUserConfigPublicAccessArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class ValkeyValkeyUserConfigPublicAccessArgs:
    def __init__(__self__, *,
                 prometheus: Optional[pulumi.Input[_builtins.bool]] = None,
                 valkey: Optional[pulumi.Input[_builtins.bool]] = None):
        """
        :param pulumi.Input[_builtins.bool] prometheus: Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        :param pulumi.Input[_builtins.bool] valkey: Allow clients to connect to valkey from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        if prometheus is not None:
            pulumi.set(__self__, "prometheus", prometheus)
        if valkey is not None:
            pulumi.set(__self__, "valkey", valkey)

    @_builtins.property
    @pulumi.getter
    def prometheus(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to prometheus from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "prometheus")

    @prometheus.setter
    def prometheus(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "prometheus", value)

    @_builtins.property
    @pulumi.getter
    def valkey(self) -> Optional[pulumi.Input[_builtins.bool]]:
        """
        Allow clients to connect to valkey from the public internet for service nodes that are in a project VPC or another type of private network.
        """
        return pulumi.get(self, "valkey")

    @valkey.setter
    def valkey(self, value: Optional[pulumi.Input[_builtins.bool]]):
        pulumi.set(self, "valkey", value)


if not MYPY:
    class GetBillingGroupTimeoutsArgsDict(TypedDict):
        read: NotRequired[_builtins.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).
        """
elif False:
    GetBillingGroupTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetBillingGroupTimeoutsArgs:
    def __init__(__self__, *,
                 read: Optional[_builtins.str] = None):
        """
        :param _builtins.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).
        """
        if read is not None:
            pulumi.set(__self__, "read", read)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[_builtins.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, "read")

    @read.setter
    def read(self, value: Optional[_builtins.str]):
        pulumi.set(self, "read", value)


if not MYPY:
    class GetMysqlDatabaseTimeoutsArgsDict(TypedDict):
        read: NotRequired[_builtins.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).
        """
elif False:
    GetMysqlDatabaseTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetMysqlDatabaseTimeoutsArgs:
    def __init__(__self__, *,
                 read: Optional[_builtins.str] = None):
        """
        :param _builtins.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).
        """
        if read is not None:
            pulumi.set(__self__, "read", read)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[_builtins.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, "read")

    @read.setter
    def read(self, value: Optional[_builtins.str]):
        pulumi.set(self, "read", value)


if not MYPY:
    class GetMysqlUserTimeoutsArgsDict(TypedDict):
        read: NotRequired[_builtins.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).
        """
elif False:
    GetMysqlUserTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetMysqlUserTimeoutsArgs:
    def __init__(__self__, *,
                 read: Optional[_builtins.str] = None):
        """
        :param _builtins.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).
        """
        if read is not None:
            pulumi.set(__self__, "read", read)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[_builtins.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, "read")

    @read.setter
    def read(self, value: Optional[_builtins.str]):
        pulumi.set(self, "read", value)


if not MYPY:
    class GetOrganizationAddressTimeoutsArgsDict(TypedDict):
        read: NotRequired[_builtins.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).
        """
elif False:
    GetOrganizationAddressTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetOrganizationAddressTimeoutsArgs:
    def __init__(__self__, *,
                 read: Optional[_builtins.str] = None):
        """
        :param _builtins.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).
        """
        if read is not None:
            pulumi.set(__self__, "read", read)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[_builtins.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, "read")

    @read.setter
    def read(self, value: Optional[_builtins.str]):
        pulumi.set(self, "read", value)


if not MYPY:
    class GetOrganizationApplicationUserTimeoutsArgsDict(TypedDict):
        read: NotRequired[_builtins.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).
        """
elif False:
    GetOrganizationApplicationUserTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetOrganizationApplicationUserTimeoutsArgs:
    def __init__(__self__, *,
                 read: Optional[_builtins.str] = None):
        """
        :param _builtins.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).
        """
        if read is not None:
            pulumi.set(__self__, "read", read)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[_builtins.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, "read")

    @read.setter
    def read(self, value: Optional[_builtins.str]):
        pulumi.set(self, "read", value)


if not MYPY:
    class GetOrganizationBillingGroupListBillingGroupArgsDict(TypedDict):
        billing_address_id: _builtins.str
        """
        Billing address ID.
        """
        billing_contact_emails: Sequence[_builtins.str]
        """
        List of billing contact emails.
        """
        billing_emails: Sequence[_builtins.str]
        """
        List of billing contact emails.
        """
        billing_group_id: _builtins.str
        """
        Billing group ID.
        """
        billing_group_name: _builtins.str
        """
        Billing Group Name.
        """
        currency: _builtins.str
        """
        Acceptable currencies for a billing group. The possible values are `AUD`, `CAD`, `CHF`, `DKK`, `EUR`, `GBP`, `JPY`, `NOK`, `NZD`, `SEK`, `SGD` and `USD`.
        """
        custom_invoice_text: _builtins.str
        """
        Extra billing text.
        """
        organization_id: _builtins.str
        """
        Organization ID.
        """
        payment_method_id: _builtins.str
        """
        Payment method ID.
        """
        shipping_address_id: _builtins.str
        """
        Shipping address ID.
        """
        vat_id: _builtins.str
        """
        VAT ID.
        """
elif False:
    GetOrganizationBillingGroupListBillingGroupArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetOrganizationBillingGroupListBillingGroupArgs:
    def __init__(__self__, *,
                 billing_address_id: _builtins.str,
                 billing_contact_emails: Sequence[_builtins.str],
                 billing_emails: Sequence[_builtins.str],
                 billing_group_id: _builtins.str,
                 billing_group_name: _builtins.str,
                 currency: _builtins.str,
                 custom_invoice_text: _builtins.str,
                 organization_id: _builtins.str,
                 payment_method_id: _builtins.str,
                 shipping_address_id: _builtins.str,
                 vat_id: _builtins.str):
        """
        :param _builtins.str billing_address_id: Billing address ID.
        :param Sequence[_builtins.str] billing_contact_emails: List of billing contact emails.
        :param Sequence[_builtins.str] billing_emails: List of billing contact emails.
        :param _builtins.str billing_group_id: Billing group ID.
        :param _builtins.str billing_group_name: Billing Group Name.
        :param _builtins.str currency: Acceptable currencies for a billing group. The possible values are `AUD`, `CAD`, `CHF`, `DKK`, `EUR`, `GBP`, `JPY`, `NOK`, `NZD`, `SEK`, `SGD` and `USD`.
        :param _builtins.str custom_invoice_text: Extra billing text.
        :param _builtins.str organization_id: Organization ID.
        :param _builtins.str payment_method_id: Payment method ID.
        :param _builtins.str shipping_address_id: Shipping address ID.
        :param _builtins.str vat_id: VAT ID.
        """
        pulumi.set(__self__, "billing_address_id", billing_address_id)
        pulumi.set(__self__, "billing_contact_emails", billing_contact_emails)
        pulumi.set(__self__, "billing_emails", billing_emails)
        pulumi.set(__self__, "billing_group_id", billing_group_id)
        pulumi.set(__self__, "billing_group_name", billing_group_name)
        pulumi.set(__self__, "currency", currency)
        pulumi.set(__self__, "custom_invoice_text", custom_invoice_text)
        pulumi.set(__self__, "organization_id", organization_id)
        pulumi.set(__self__, "payment_method_id", payment_method_id)
        pulumi.set(__self__, "shipping_address_id", shipping_address_id)
        pulumi.set(__self__, "vat_id", vat_id)

    @_builtins.property
    @pulumi.getter(name="billingAddressId")
    def billing_address_id(self) -> _builtins.str:
        """
        Billing address ID.
        """
        return pulumi.get(self, "billing_address_id")

    @billing_address_id.setter
    def billing_address_id(self, value: _builtins.str):
        pulumi.set(self, "billing_address_id", value)

    @_builtins.property
    @pulumi.getter(name="billingContactEmails")
    def billing_contact_emails(self) -> Sequence[_builtins.str]:
        """
        List of billing contact emails.
        """
        return pulumi.get(self, "billing_contact_emails")

    @billing_contact_emails.setter
    def billing_contact_emails(self, value: Sequence[_builtins.str]):
        pulumi.set(self, "billing_contact_emails", value)

    @_builtins.property
    @pulumi.getter(name="billingEmails")
    def billing_emails(self) -> Sequence[_builtins.str]:
        """
        List of billing contact emails.
        """
        return pulumi.get(self, "billing_emails")

    @billing_emails.setter
    def billing_emails(self, value: Sequence[_builtins.str]):
        pulumi.set(self, "billing_emails", value)

    @_builtins.property
    @pulumi.getter(name="billingGroupId")
    def billing_group_id(self) -> _builtins.str:
        """
        Billing group ID.
        """
        return pulumi.get(self, "billing_group_id")

    @billing_group_id.setter
    def billing_group_id(self, value: _builtins.str):
        pulumi.set(self, "billing_group_id", value)

    @_builtins.property
    @pulumi.getter(name="billingGroupName")
    def billing_group_name(self) -> _builtins.str:
        """
        Billing Group Name.
        """
        return pulumi.get(self, "billing_group_name")

    @billing_group_name.setter
    def billing_group_name(self, value: _builtins.str):
        pulumi.set(self, "billing_group_name", value)

    @_builtins.property
    @pulumi.getter
    def currency(self) -> _builtins.str:
        """
        Acceptable currencies for a billing group. The possible values are `AUD`, `CAD`, `CHF`, `DKK`, `EUR`, `GBP`, `JPY`, `NOK`, `NZD`, `SEK`, `SGD` and `USD`.
        """
        return pulumi.get(self, "currency")

    @currency.setter
    def currency(self, value: _builtins.str):
        pulumi.set(self, "currency", value)

    @_builtins.property
    @pulumi.getter(name="customInvoiceText")
    def custom_invoice_text(self) -> _builtins.str:
        """
        Extra billing text.
        """
        return pulumi.get(self, "custom_invoice_text")

    @custom_invoice_text.setter
    def custom_invoice_text(self, value: _builtins.str):
        pulumi.set(self, "custom_invoice_text", value)

    @_builtins.property
    @pulumi.getter(name="organizationId")
    def organization_id(self) -> _builtins.str:
        """
        Organization ID.
        """
        return pulumi.get(self, "organization_id")

    @organization_id.setter
    def organization_id(self, value: _builtins.str):
        pulumi.set(self, "organization_id", value)

    @_builtins.property
    @pulumi.getter(name="paymentMethodId")
    def payment_method_id(self) -> _builtins.str:
        """
        Payment method ID.
        """
        return pulumi.get(self, "payment_method_id")

    @payment_method_id.setter
    def payment_method_id(self, value: _builtins.str):
        pulumi.set(self, "payment_method_id", value)

    @_builtins.property
    @pulumi.getter(name="shippingAddressId")
    def shipping_address_id(self) -> _builtins.str:
        """
        Shipping address ID.
        """
        return pulumi.get(self, "shipping_address_id")

    @shipping_address_id.setter
    def shipping_address_id(self, value: _builtins.str):
        pulumi.set(self, "shipping_address_id", value)

    @_builtins.property
    @pulumi.getter(name="vatId")
    def vat_id(self) -> _builtins.str:
        """
        VAT ID.
        """
        return pulumi.get(self, "vat_id")

    @vat_id.setter
    def vat_id(self, value: _builtins.str):
        pulumi.set(self, "vat_id", value)


if not MYPY:
    class GetOrganizationBillingGroupListTimeoutsArgsDict(TypedDict):
        read: NotRequired[_builtins.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).
        """
elif False:
    GetOrganizationBillingGroupListTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetOrganizationBillingGroupListTimeoutsArgs:
    def __init__(__self__, *,
                 read: Optional[_builtins.str] = None):
        """
        :param _builtins.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).
        """
        if read is not None:
            pulumi.set(__self__, "read", read)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[_builtins.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, "read")

    @read.setter
    def read(self, value: Optional[_builtins.str]):
        pulumi.set(self, "read", value)


if not MYPY:
    class GetOrganizationBillingGroupTimeoutsArgsDict(TypedDict):
        read: NotRequired[_builtins.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).
        """
elif False:
    GetOrganizationBillingGroupTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetOrganizationBillingGroupTimeoutsArgs:
    def __init__(__self__, *,
                 read: Optional[_builtins.str] = None):
        """
        :param _builtins.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).
        """
        if read is not None:
            pulumi.set(__self__, "read", read)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[_builtins.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, "read")

    @read.setter
    def read(self, value: Optional[_builtins.str]):
        pulumi.set(self, "read", value)


if not MYPY:
    class GetOrganizationProjectTagArgsDict(TypedDict):
        key: _builtins.str
        """
        Project tag key.
        """
        value: _builtins.str
        """
        Project tag value.
        """
elif False:
    GetOrganizationProjectTagArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetOrganizationProjectTagArgs:
    def __init__(__self__, *,
                 key: _builtins.str,
                 value: _builtins.str):
        """
        :param _builtins.str key: Project tag key.
        :param _builtins.str value: Project tag value.
        """
        pulumi.set(__self__, "key", key)
        pulumi.set(__self__, "value", value)

    @_builtins.property
    @pulumi.getter
    def key(self) -> _builtins.str:
        """
        Project tag key.
        """
        return pulumi.get(self, "key")

    @key.setter
    def key(self, value: _builtins.str):
        pulumi.set(self, "key", value)

    @_builtins.property
    @pulumi.getter
    def value(self) -> _builtins.str:
        """
        Project tag value.
        """
        return pulumi.get(self, "value")

    @value.setter
    def value(self, value: _builtins.str):
        pulumi.set(self, "value", value)


if not MYPY:
    class GetOrganizationProjectTimeoutsArgsDict(TypedDict):
        read: NotRequired[_builtins.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).
        """
elif False:
    GetOrganizationProjectTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetOrganizationProjectTimeoutsArgs:
    def __init__(__self__, *,
                 read: Optional[_builtins.str] = None):
        """
        :param _builtins.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).
        """
        if read is not None:
            pulumi.set(__self__, "read", read)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[_builtins.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, "read")

    @read.setter
    def read(self, value: Optional[_builtins.str]):
        pulumi.set(self, "read", value)


if not MYPY:
    class GetOrganizationTimeoutsArgsDict(TypedDict):
        read: NotRequired[_builtins.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).
        """
elif False:
    GetOrganizationTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetOrganizationTimeoutsArgs:
    def __init__(__self__, *,
                 read: Optional[_builtins.str] = None):
        """
        :param _builtins.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).
        """
        if read is not None:
            pulumi.set(__self__, "read", read)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[_builtins.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, "read")

    @read.setter
    def read(self, value: Optional[_builtins.str]):
        pulumi.set(self, "read", value)


if not MYPY:
    class GetOrganizationUserGroupListTimeoutsArgsDict(TypedDict):
        read: NotRequired[_builtins.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).
        """
elif False:
    GetOrganizationUserGroupListTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetOrganizationUserGroupListTimeoutsArgs:
    def __init__(__self__, *,
                 read: Optional[_builtins.str] = None):
        """
        :param _builtins.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).
        """
        if read is not None:
            pulumi.set(__self__, "read", read)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[_builtins.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, "read")

    @read.setter
    def read(self, value: Optional[_builtins.str]):
        pulumi.set(self, "read", value)


if not MYPY:
    class GetOrganizationUserGroupListUserGroupArgsDict(TypedDict):
        create_time: _builtins.str
        """
        User group creation time.
        """
        description: _builtins.str
        """
        Description.
        """
        managed_by_scim: _builtins.bool
        """
        Managed By Scim.
        """
        member_count: _builtins.int
        """
        Member Count.
        """
        update_time: _builtins.str
        """
        User group last update time.
        """
        user_group_id: _builtins.str
        """
        User Group ID.
        """
        user_group_name: _builtins.str
        """
        User Group Name.
        """
elif False:
    GetOrganizationUserGroupListUserGroupArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetOrganizationUserGroupListUserGroupArgs:
    def __init__(__self__, *,
                 create_time: _builtins.str,
                 description: _builtins.str,
                 managed_by_scim: _builtins.bool,
                 member_count: _builtins.int,
                 update_time: _builtins.str,
                 user_group_id: _builtins.str,
                 user_group_name: _builtins.str):
        """
        :param _builtins.str create_time: User group creation time.
        :param _builtins.str description: Description.
        :param _builtins.bool managed_by_scim: Managed By Scim.
        :param _builtins.int member_count: Member Count.
        :param _builtins.str update_time: User group last update time.
        :param _builtins.str user_group_id: User Group ID.
        :param _builtins.str user_group_name: User Group Name.
        """
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "description", description)
        pulumi.set(__self__, "managed_by_scim", managed_by_scim)
        pulumi.set(__self__, "member_count", member_count)
        pulumi.set(__self__, "update_time", update_time)
        pulumi.set(__self__, "user_group_id", user_group_id)
        pulumi.set(__self__, "user_group_name", user_group_name)

    @_builtins.property
    @pulumi.getter(name="createTime")
    def create_time(self) -> _builtins.str:
        """
        User group creation time.
        """
        return pulumi.get(self, "create_time")

    @create_time.setter
    def create_time(self, value: _builtins.str):
        pulumi.set(self, "create_time", value)

    @_builtins.property
    @pulumi.getter
    def description(self) -> _builtins.str:
        """
        Description.
        """
        return pulumi.get(self, "description")

    @description.setter
    def description(self, value: _builtins.str):
        pulumi.set(self, "description", value)

    @_builtins.property
    @pulumi.getter(name="managedByScim")
    def managed_by_scim(self) -> _builtins.bool:
        """
        Managed By Scim.
        """
        return pulumi.get(self, "managed_by_scim")

    @managed_by_scim.setter
    def managed_by_scim(self, value: _builtins.bool):
        pulumi.set(self, "managed_by_scim", value)

    @_builtins.property
    @pulumi.getter(name="memberCount")
    def member_count(self) -> _builtins.int:
        """
        Member Count.
        """
        return pulumi.get(self, "member_count")

    @member_count.setter
    def member_count(self, value: _builtins.int):
        pulumi.set(self, "member_count", value)

    @_builtins.property
    @pulumi.getter(name="updateTime")
    def update_time(self) -> _builtins.str:
        """
        User group last update time.
        """
        return pulumi.get(self, "update_time")

    @update_time.setter
    def update_time(self, value: _builtins.str):
        pulumi.set(self, "update_time", value)

    @_builtins.property
    @pulumi.getter(name="userGroupId")
    def user_group_id(self) -> _builtins.str:
        """
        User Group ID.
        """
        return pulumi.get(self, "user_group_id")

    @user_group_id.setter
    def user_group_id(self, value: _builtins.str):
        pulumi.set(self, "user_group_id", value)

    @_builtins.property
    @pulumi.getter(name="userGroupName")
    def user_group_name(self) -> _builtins.str:
        """
        User Group Name.
        """
        return pulumi.get(self, "user_group_name")

    @user_group_name.setter
    def user_group_name(self, value: _builtins.str):
        pulumi.set(self, "user_group_name", value)


if not MYPY:
    class GetOrganizationUserGroupMemberListMemberArgsDict(TypedDict):
        last_activity_time: _builtins.str
        """
        Last Activity Time.
        """
        user_id: _builtins.str
        """
        User ID.
        """
        user_infos: NotRequired[Sequence['GetOrganizationUserGroupMemberListMemberUserInfoArgsDict']]
        """
        OrganizationUserInfo.
        """
elif False:
    GetOrganizationUserGroupMemberListMemberArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetOrganizationUserGroupMemberListMemberArgs:
    def __init__(__self__, *,
                 last_activity_time: _builtins.str,
                 user_id: _builtins.str,
                 user_infos: Optional[Sequence['GetOrganizationUserGroupMemberListMemberUserInfoArgs']] = None):
        """
        :param _builtins.str last_activity_time: Last Activity Time.
        :param _builtins.str user_id: User ID.
        :param Sequence['GetOrganizationUserGroupMemberListMemberUserInfoArgs'] user_infos: OrganizationUserInfo.
        """
        pulumi.set(__self__, "last_activity_time", last_activity_time)
        pulumi.set(__self__, "user_id", user_id)
        if user_infos is not None:
            pulumi.set(__self__, "user_infos", user_infos)

    @_builtins.property
    @pulumi.getter(name="lastActivityTime")
    def last_activity_time(self) -> _builtins.str:
        """
        Last Activity Time.
        """
        return pulumi.get(self, "last_activity_time")

    @last_activity_time.setter
    def last_activity_time(self, value: _builtins.str):
        pulumi.set(self, "last_activity_time", value)

    @_builtins.property
    @pulumi.getter(name="userId")
    def user_id(self) -> _builtins.str:
        """
        User ID.
        """
        return pulumi.get(self, "user_id")

    @user_id.setter
    def user_id(self, value: _builtins.str):
        pulumi.set(self, "user_id", value)

    @_builtins.property
    @pulumi.getter(name="userInfos")
    def user_infos(self) -> Optional[Sequence['GetOrganizationUserGroupMemberListMemberUserInfoArgs']]:
        """
        OrganizationUserInfo.
        """
        return pulumi.get(self, "user_infos")

    @user_infos.setter
    def user_infos(self, value: Optional[Sequence['GetOrganizationUserGroupMemberListMemberUserInfoArgs']]):
        pulumi.set(self, "user_infos", value)


if not MYPY:
    class GetOrganizationUserGroupMemberListMemberUserInfoArgsDict(TypedDict):
        city: _builtins.str
        """
        City.
        """
        country: _builtins.str
        """
        Country.
        """
        create_time: _builtins.str
        """
        Creation time.
        """
        department: _builtins.str
        """
        Department.
        """
        is_application_user: _builtins.bool
        """
        Is Application User.
        """
        job_title: _builtins.str
        """
        Job Title.
        """
        managed_by_scim: _builtins.bool
        """
        Managed By Scim.
        """
        managing_organization_id: _builtins.str
        """
        Managing Organization ID.
        """
        real_name: _builtins.str
        """
        Real Name.
        """
        state: _builtins.str
        """
        State.
        """
        user_email: _builtins.str
        """
        User Email.
        """
elif False:
    GetOrganizationUserGroupMemberListMemberUserInfoArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetOrganizationUserGroupMemberListMemberUserInfoArgs:
    def __init__(__self__, *,
                 city: _builtins.str,
                 country: _builtins.str,
                 create_time: _builtins.str,
                 department: _builtins.str,
                 is_application_user: _builtins.bool,
                 job_title: _builtins.str,
                 managed_by_scim: _builtins.bool,
                 managing_organization_id: _builtins.str,
                 real_name: _builtins.str,
                 state: _builtins.str,
                 user_email: _builtins.str):
        """
        :param _builtins.str city: City.
        :param _builtins.str country: Country.
        :param _builtins.str create_time: Creation time.
        :param _builtins.str department: Department.
        :param _builtins.bool is_application_user: Is Application User.
        :param _builtins.str job_title: Job Title.
        :param _builtins.bool managed_by_scim: Managed By Scim.
        :param _builtins.str managing_organization_id: Managing Organization ID.
        :param _builtins.str real_name: Real Name.
        :param _builtins.str state: State.
        :param _builtins.str user_email: User Email.
        """
        pulumi.set(__self__, "city", city)
        pulumi.set(__self__, "country", country)
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "department", department)
        pulumi.set(__self__, "is_application_user", is_application_user)
        pulumi.set(__self__, "job_title", job_title)
        pulumi.set(__self__, "managed_by_scim", managed_by_scim)
        pulumi.set(__self__, "managing_organization_id", managing_organization_id)
        pulumi.set(__self__, "real_name", real_name)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "user_email", user_email)

    @_builtins.property
    @pulumi.getter
    def city(self) -> _builtins.str:
        """
        City.
        """
        return pulumi.get(self, "city")

    @city.setter
    def city(self, value: _builtins.str):
        pulumi.set(self, "city", value)

    @_builtins.property
    @pulumi.getter
    def country(self) -> _builtins.str:
        """
        Country.
        """
        return pulumi.get(self, "country")

    @country.setter
    def country(self, value: _builtins.str):
        pulumi.set(self, "country", value)

    @_builtins.property
    @pulumi.getter(name="createTime")
    def create_time(self) -> _builtins.str:
        """
        Creation time.
        """
        return pulumi.get(self, "create_time")

    @create_time.setter
    def create_time(self, value: _builtins.str):
        pulumi.set(self, "create_time", value)

    @_builtins.property
    @pulumi.getter
    def department(self) -> _builtins.str:
        """
        Department.
        """
        return pulumi.get(self, "department")

    @department.setter
    def department(self, value: _builtins.str):
        pulumi.set(self, "department", value)

    @_builtins.property
    @pulumi.getter(name="isApplicationUser")
    def is_application_user(self) -> _builtins.bool:
        """
        Is Application User.
        """
        return pulumi.get(self, "is_application_user")

    @is_application_user.setter
    def is_application_user(self, value: _builtins.bool):
        pulumi.set(self, "is_application_user", value)

    @_builtins.property
    @pulumi.getter(name="jobTitle")
    def job_title(self) -> _builtins.str:
        """
        Job Title.
        """
        return pulumi.get(self, "job_title")

    @job_title.setter
    def job_title(self, value: _builtins.str):
        pulumi.set(self, "job_title", value)

    @_builtins.property
    @pulumi.getter(name="managedByScim")
    def managed_by_scim(self) -> _builtins.bool:
        """
        Managed By Scim.
        """
        return pulumi.get(self, "managed_by_scim")

    @managed_by_scim.setter
    def managed_by_scim(self, value: _builtins.bool):
        pulumi.set(self, "managed_by_scim", value)

    @_builtins.property
    @pulumi.getter(name="managingOrganizationId")
    def managing_organization_id(self) -> _builtins.str:
        """
        Managing Organization ID.
        """
        return pulumi.get(self, "managing_organization_id")

    @managing_organization_id.setter
    def managing_organization_id(self, value: _builtins.str):
        pulumi.set(self, "managing_organization_id", value)

    @_builtins.property
    @pulumi.getter(name="realName")
    def real_name(self) -> _builtins.str:
        """
        Real Name.
        """
        return pulumi.get(self, "real_name")

    @real_name.setter
    def real_name(self, value: _builtins.str):
        pulumi.set(self, "real_name", value)

    @_builtins.property
    @pulumi.getter
    def state(self) -> _builtins.str:
        """
        State.
        """
        return pulumi.get(self, "state")

    @state.setter
    def state(self, value: _builtins.str):
        pulumi.set(self, "state", value)

    @_builtins.property
    @pulumi.getter(name="userEmail")
    def user_email(self) -> _builtins.str:
        """
        User Email.
        """
        return pulumi.get(self, "user_email")

    @user_email.setter
    def user_email(self, value: _builtins.str):
        pulumi.set(self, "user_email", value)


if not MYPY:
    class GetOrganizationUserGroupMemberListTimeoutsArgsDict(TypedDict):
        read: NotRequired[_builtins.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).
        """
elif False:
    GetOrganizationUserGroupMemberListTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetOrganizationUserGroupMemberListTimeoutsArgs:
    def __init__(__self__, *,
                 read: Optional[_builtins.str] = None):
        """
        :param _builtins.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).
        """
        if read is not None:
            pulumi.set(__self__, "read", read)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[_builtins.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, "read")

    @read.setter
    def read(self, value: Optional[_builtins.str]):
        pulumi.set(self, "read", value)


if not MYPY:
    class GetOrganizationUserListTimeoutsArgsDict(TypedDict):
        read: NotRequired[_builtins.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).
        """
elif False:
    GetOrganizationUserListTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetOrganizationUserListTimeoutsArgs:
    def __init__(__self__, *,
                 read: Optional[_builtins.str] = None):
        """
        :param _builtins.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).
        """
        if read is not None:
            pulumi.set(__self__, "read", read)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[_builtins.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, "read")

    @read.setter
    def read(self, value: Optional[_builtins.str]):
        pulumi.set(self, "read", value)


if not MYPY:
    class GetOrganizationUserListUserArgsDict(TypedDict):
        is_super_admin: _builtins.bool
        """
        Super admin state of the organization user.
        """
        join_time: _builtins.str
        """
        Join time.
        """
        last_activity_time: _builtins.str
        """
        Last activity time.
        """
        user_id: _builtins.str
        """
        User ID.
        """
        user_infos: NotRequired[Sequence['GetOrganizationUserListUserUserInfoArgsDict']]
        """
        OrganizationUserInfo.
        """
elif False:
    GetOrganizationUserListUserArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetOrganizationUserListUserArgs:
    def __init__(__self__, *,
                 is_super_admin: _builtins.bool,
                 join_time: _builtins.str,
                 last_activity_time: _builtins.str,
                 user_id: _builtins.str,
                 user_infos: Optional[Sequence['GetOrganizationUserListUserUserInfoArgs']] = None):
        """
        :param _builtins.bool is_super_admin: Super admin state of the organization user.
        :param _builtins.str join_time: Join time.
        :param _builtins.str last_activity_time: Last activity time.
        :param _builtins.str user_id: User ID.
        :param Sequence['GetOrganizationUserListUserUserInfoArgs'] user_infos: OrganizationUserInfo.
        """
        pulumi.set(__self__, "is_super_admin", is_super_admin)
        pulumi.set(__self__, "join_time", join_time)
        pulumi.set(__self__, "last_activity_time", last_activity_time)
        pulumi.set(__self__, "user_id", user_id)
        if user_infos is not None:
            pulumi.set(__self__, "user_infos", user_infos)

    @_builtins.property
    @pulumi.getter(name="isSuperAdmin")
    def is_super_admin(self) -> _builtins.bool:
        """
        Super admin state of the organization user.
        """
        return pulumi.get(self, "is_super_admin")

    @is_super_admin.setter
    def is_super_admin(self, value: _builtins.bool):
        pulumi.set(self, "is_super_admin", value)

    @_builtins.property
    @pulumi.getter(name="joinTime")
    def join_time(self) -> _builtins.str:
        """
        Join time.
        """
        return pulumi.get(self, "join_time")

    @join_time.setter
    def join_time(self, value: _builtins.str):
        pulumi.set(self, "join_time", value)

    @_builtins.property
    @pulumi.getter(name="lastActivityTime")
    def last_activity_time(self) -> _builtins.str:
        """
        Last activity time.
        """
        return pulumi.get(self, "last_activity_time")

    @last_activity_time.setter
    def last_activity_time(self, value: _builtins.str):
        pulumi.set(self, "last_activity_time", value)

    @_builtins.property
    @pulumi.getter(name="userId")
    def user_id(self) -> _builtins.str:
        """
        User ID.
        """
        return pulumi.get(self, "user_id")

    @user_id.setter
    def user_id(self, value: _builtins.str):
        pulumi.set(self, "user_id", value)

    @_builtins.property
    @pulumi.getter(name="userInfos")
    def user_infos(self) -> Optional[Sequence['GetOrganizationUserListUserUserInfoArgs']]:
        """
        OrganizationUserInfo.
        """
        return pulumi.get(self, "user_infos")

    @user_infos.setter
    def user_infos(self, value: Optional[Sequence['GetOrganizationUserListUserUserInfoArgs']]):
        pulumi.set(self, "user_infos", value)


if not MYPY:
    class GetOrganizationUserListUserUserInfoArgsDict(TypedDict):
        city: _builtins.str
        """
        City.
        """
        country: _builtins.str
        """
        Country.
        """
        create_time: _builtins.str
        """
        Creation time.
        """
        department: _builtins.str
        """
        Department.
        """
        is_application_user: _builtins.bool
        """
        Is Application User.
        """
        job_title: _builtins.str
        """
        Job Title.
        """
        managed_by_scim: _builtins.bool
        """
        Managed By Scim.
        """
        managing_organization_id: _builtins.str
        """
        Managing Organization ID.
        """
        real_name: _builtins.str
        """
        Real Name.
        """
        state: _builtins.str
        """
        State.
        """
        user_email: _builtins.str
        """
        User Email.
        """
elif False:
    GetOrganizationUserListUserUserInfoArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetOrganizationUserListUserUserInfoArgs:
    def __init__(__self__, *,
                 city: _builtins.str,
                 country: _builtins.str,
                 create_time: _builtins.str,
                 department: _builtins.str,
                 is_application_user: _builtins.bool,
                 job_title: _builtins.str,
                 managed_by_scim: _builtins.bool,
                 managing_organization_id: _builtins.str,
                 real_name: _builtins.str,
                 state: _builtins.str,
                 user_email: _builtins.str):
        """
        :param _builtins.str city: City.
        :param _builtins.str country: Country.
        :param _builtins.str create_time: Creation time.
        :param _builtins.str department: Department.
        :param _builtins.bool is_application_user: Is Application User.
        :param _builtins.str job_title: Job Title.
        :param _builtins.bool managed_by_scim: Managed By Scim.
        :param _builtins.str managing_organization_id: Managing Organization ID.
        :param _builtins.str real_name: Real Name.
        :param _builtins.str state: State.
        :param _builtins.str user_email: User Email.
        """
        pulumi.set(__self__, "city", city)
        pulumi.set(__self__, "country", country)
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "department", department)
        pulumi.set(__self__, "is_application_user", is_application_user)
        pulumi.set(__self__, "job_title", job_title)
        pulumi.set(__self__, "managed_by_scim", managed_by_scim)
        pulumi.set(__self__, "managing_organization_id", managing_organization_id)
        pulumi.set(__self__, "real_name", real_name)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "user_email", user_email)

    @_builtins.property
    @pulumi.getter
    def city(self) -> _builtins.str:
        """
        City.
        """
        return pulumi.get(self, "city")

    @city.setter
    def city(self, value: _builtins.str):
        pulumi.set(self, "city", value)

    @_builtins.property
    @pulumi.getter
    def country(self) -> _builtins.str:
        """
        Country.
        """
        return pulumi.get(self, "country")

    @country.setter
    def country(self, value: _builtins.str):
        pulumi.set(self, "country", value)

    @_builtins.property
    @pulumi.getter(name="createTime")
    def create_time(self) -> _builtins.str:
        """
        Creation time.
        """
        return pulumi.get(self, "create_time")

    @create_time.setter
    def create_time(self, value: _builtins.str):
        pulumi.set(self, "create_time", value)

    @_builtins.property
    @pulumi.getter
    def department(self) -> _builtins.str:
        """
        Department.
        """
        return pulumi.get(self, "department")

    @department.setter
    def department(self, value: _builtins.str):
        pulumi.set(self, "department", value)

    @_builtins.property
    @pulumi.getter(name="isApplicationUser")
    def is_application_user(self) -> _builtins.bool:
        """
        Is Application User.
        """
        return pulumi.get(self, "is_application_user")

    @is_application_user.setter
    def is_application_user(self, value: _builtins.bool):
        pulumi.set(self, "is_application_user", value)

    @_builtins.property
    @pulumi.getter(name="jobTitle")
    def job_title(self) -> _builtins.str:
        """
        Job Title.
        """
        return pulumi.get(self, "job_title")

    @job_title.setter
    def job_title(self, value: _builtins.str):
        pulumi.set(self, "job_title", value)

    @_builtins.property
    @pulumi.getter(name="managedByScim")
    def managed_by_scim(self) -> _builtins.bool:
        """
        Managed By Scim.
        """
        return pulumi.get(self, "managed_by_scim")

    @managed_by_scim.setter
    def managed_by_scim(self, value: _builtins.bool):
        pulumi.set(self, "managed_by_scim", value)

    @_builtins.property
    @pulumi.getter(name="managingOrganizationId")
    def managing_organization_id(self) -> _builtins.str:
        """
        Managing Organization ID.
        """
        return pulumi.get(self, "managing_organization_id")

    @managing_organization_id.setter
    def managing_organization_id(self, value: _builtins.str):
        pulumi.set(self, "managing_organization_id", value)

    @_builtins.property
    @pulumi.getter(name="realName")
    def real_name(self) -> _builtins.str:
        """
        Real Name.
        """
        return pulumi.get(self, "real_name")

    @real_name.setter
    def real_name(self, value: _builtins.str):
        pulumi.set(self, "real_name", value)

    @_builtins.property
    @pulumi.getter
    def state(self) -> _builtins.str:
        """
        State.
        """
        return pulumi.get(self, "state")

    @state.setter
    def state(self, value: _builtins.str):
        pulumi.set(self, "state", value)

    @_builtins.property
    @pulumi.getter(name="userEmail")
    def user_email(self) -> _builtins.str:
        """
        User Email.
        """
        return pulumi.get(self, "user_email")

    @user_email.setter
    def user_email(self, value: _builtins.str):
        pulumi.set(self, "user_email", value)


if not MYPY:
    class GetOrganizationalUnitTimeoutsArgsDict(TypedDict):
        read: NotRequired[_builtins.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).
        """
elif False:
    GetOrganizationalUnitTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetOrganizationalUnitTimeoutsArgs:
    def __init__(__self__, *,
                 read: Optional[_builtins.str] = None):
        """
        :param _builtins.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).
        """
        if read is not None:
            pulumi.set(__self__, "read", read)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[_builtins.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, "read")

    @read.setter
    def read(self, value: Optional[_builtins.str]):
        pulumi.set(self, "read", value)


if not MYPY:
    class GetPgDatabaseTimeoutsArgsDict(TypedDict):
        read: NotRequired[_builtins.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).
        """
elif False:
    GetPgDatabaseTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetPgDatabaseTimeoutsArgs:
    def __init__(__self__, *,
                 read: Optional[_builtins.str] = None):
        """
        :param _builtins.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).
        """
        if read is not None:
            pulumi.set(__self__, "read", read)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[_builtins.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, "read")

    @read.setter
    def read(self, value: Optional[_builtins.str]):
        pulumi.set(self, "read", value)


if not MYPY:
    class GetServiceListServiceArgsDict(TypedDict):
        cloud_description: _builtins.str
        """
        Cloud provider and location.
        """
        cloud_name: _builtins.str
        """
        Target cloud.
        """
        create_time: _builtins.str
        """
        Service creation timestamp (ISO 8601).
        """
        disk_space_mb: _builtins.int
        """
        Megabytes of disk space for data storage.
        """
        node_count: _builtins.int
        """
        Number of service nodes in the active plan.
        """
        node_cpu_count: _builtins.int
        """
        Number of CPUs for each node.
        """
        node_memory_mb: _builtins.float
        """
        Megabytes of memory for each node.
        """
        plan: _builtins.str
        """
        Subscription plan.
        """
        project_vpc_id: _builtins.str
        """
        Project VPC ID.
        """
        service_name: _builtins.str
        """
        Service name.
        """
        service_type: _builtins.str
        """
        Service type code.
        """
        service_type_description: _builtins.str
        """
        Single line description of the service.
        """
        service_uri: _builtins.str
        """
        URI for connecting to the service (may be null).
        """
        state: _builtins.str
        """
        State of the service. The possible values are `POWEROFF`, `REBALANCING`, `REBUILDING` and `RUNNING`.
        """
        termination_protection: _builtins.bool
        """
        Service is protected against termination and powering off.
        """
        update_time: _builtins.str
        """
        Service last update timestamp (ISO 8601).
        """
elif False:
    GetServiceListServiceArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetServiceListServiceArgs:
    def __init__(__self__, *,
                 cloud_description: _builtins.str,
                 cloud_name: _builtins.str,
                 create_time: _builtins.str,
                 disk_space_mb: _builtins.int,
                 node_count: _builtins.int,
                 node_cpu_count: _builtins.int,
                 node_memory_mb: _builtins.float,
                 plan: _builtins.str,
                 project_vpc_id: _builtins.str,
                 service_name: _builtins.str,
                 service_type: _builtins.str,
                 service_type_description: _builtins.str,
                 service_uri: _builtins.str,
                 state: _builtins.str,
                 termination_protection: _builtins.bool,
                 update_time: _builtins.str):
        """
        :param _builtins.str cloud_description: Cloud provider and location.
        :param _builtins.str cloud_name: Target cloud.
        :param _builtins.str create_time: Service creation timestamp (ISO 8601).
        :param _builtins.int disk_space_mb: Megabytes of disk space for data storage.
        :param _builtins.int node_count: Number of service nodes in the active plan.
        :param _builtins.int node_cpu_count: Number of CPUs for each node.
        :param _builtins.float node_memory_mb: Megabytes of memory for each node.
        :param _builtins.str plan: Subscription plan.
        :param _builtins.str project_vpc_id: Project VPC ID.
        :param _builtins.str service_name: Service name.
        :param _builtins.str service_type: Service type code.
        :param _builtins.str service_type_description: Single line description of the service.
        :param _builtins.str service_uri: URI for connecting to the service (may be null).
        :param _builtins.str state: State of the service. The possible values are `POWEROFF`, `REBALANCING`, `REBUILDING` and `RUNNING`.
        :param _builtins.bool termination_protection: Service is protected against termination and powering off.
        :param _builtins.str update_time: Service last update timestamp (ISO 8601).
        """
        pulumi.set(__self__, "cloud_description", cloud_description)
        pulumi.set(__self__, "cloud_name", cloud_name)
        pulumi.set(__self__, "create_time", create_time)
        pulumi.set(__self__, "disk_space_mb", disk_space_mb)
        pulumi.set(__self__, "node_count", node_count)
        pulumi.set(__self__, "node_cpu_count", node_cpu_count)
        pulumi.set(__self__, "node_memory_mb", node_memory_mb)
        pulumi.set(__self__, "plan", plan)
        pulumi.set(__self__, "project_vpc_id", project_vpc_id)
        pulumi.set(__self__, "service_name", service_name)
        pulumi.set(__self__, "service_type", service_type)
        pulumi.set(__self__, "service_type_description", service_type_description)
        pulumi.set(__self__, "service_uri", service_uri)
        pulumi.set(__self__, "state", state)
        pulumi.set(__self__, "termination_protection", termination_protection)
        pulumi.set(__self__, "update_time", update_time)

    @_builtins.property
    @pulumi.getter(name="cloudDescription")
    def cloud_description(self) -> _builtins.str:
        """
        Cloud provider and location.
        """
        return pulumi.get(self, "cloud_description")

    @cloud_description.setter
    def cloud_description(self, value: _builtins.str):
        pulumi.set(self, "cloud_description", value)

    @_builtins.property
    @pulumi.getter(name="cloudName")
    def cloud_name(self) -> _builtins.str:
        """
        Target cloud.
        """
        return pulumi.get(self, "cloud_name")

    @cloud_name.setter
    def cloud_name(self, value: _builtins.str):
        pulumi.set(self, "cloud_name", value)

    @_builtins.property
    @pulumi.getter(name="createTime")
    def create_time(self) -> _builtins.str:
        """
        Service creation timestamp (ISO 8601).
        """
        return pulumi.get(self, "create_time")

    @create_time.setter
    def create_time(self, value: _builtins.str):
        pulumi.set(self, "create_time", value)

    @_builtins.property
    @pulumi.getter(name="diskSpaceMb")
    def disk_space_mb(self) -> _builtins.int:
        """
        Megabytes of disk space for data storage.
        """
        return pulumi.get(self, "disk_space_mb")

    @disk_space_mb.setter
    def disk_space_mb(self, value: _builtins.int):
        pulumi.set(self, "disk_space_mb", value)

    @_builtins.property
    @pulumi.getter(name="nodeCount")
    def node_count(self) -> _builtins.int:
        """
        Number of service nodes in the active plan.
        """
        return pulumi.get(self, "node_count")

    @node_count.setter
    def node_count(self, value: _builtins.int):
        pulumi.set(self, "node_count", value)

    @_builtins.property
    @pulumi.getter(name="nodeCpuCount")
    def node_cpu_count(self) -> _builtins.int:
        """
        Number of CPUs for each node.
        """
        return pulumi.get(self, "node_cpu_count")

    @node_cpu_count.setter
    def node_cpu_count(self, value: _builtins.int):
        pulumi.set(self, "node_cpu_count", value)

    @_builtins.property
    @pulumi.getter(name="nodeMemoryMb")
    def node_memory_mb(self) -> _builtins.float:
        """
        Megabytes of memory for each node.
        """
        return pulumi.get(self, "node_memory_mb")

    @node_memory_mb.setter
    def node_memory_mb(self, value: _builtins.float):
        pulumi.set(self, "node_memory_mb", value)

    @_builtins.property
    @pulumi.getter
    def plan(self) -> _builtins.str:
        """
        Subscription plan.
        """
        return pulumi.get(self, "plan")

    @plan.setter
    def plan(self, value: _builtins.str):
        pulumi.set(self, "plan", value)

    @_builtins.property
    @pulumi.getter(name="projectVpcId")
    def project_vpc_id(self) -> _builtins.str:
        """
        Project VPC ID.
        """
        return pulumi.get(self, "project_vpc_id")

    @project_vpc_id.setter
    def project_vpc_id(self, value: _builtins.str):
        pulumi.set(self, "project_vpc_id", value)

    @_builtins.property
    @pulumi.getter(name="serviceName")
    def service_name(self) -> _builtins.str:
        """
        Service name.
        """
        return pulumi.get(self, "service_name")

    @service_name.setter
    def service_name(self, value: _builtins.str):
        pulumi.set(self, "service_name", value)

    @_builtins.property
    @pulumi.getter(name="serviceType")
    def service_type(self) -> _builtins.str:
        """
        Service type code.
        """
        return pulumi.get(self, "service_type")

    @service_type.setter
    def service_type(self, value: _builtins.str):
        pulumi.set(self, "service_type", value)

    @_builtins.property
    @pulumi.getter(name="serviceTypeDescription")
    def service_type_description(self) -> _builtins.str:
        """
        Single line description of the service.
        """
        return pulumi.get(self, "service_type_description")

    @service_type_description.setter
    def service_type_description(self, value: _builtins.str):
        pulumi.set(self, "service_type_description", value)

    @_builtins.property
    @pulumi.getter(name="serviceUri")
    def service_uri(self) -> _builtins.str:
        """
        URI for connecting to the service (may be null).
        """
        return pulumi.get(self, "service_uri")

    @service_uri.setter
    def service_uri(self, value: _builtins.str):
        pulumi.set(self, "service_uri", value)

    @_builtins.property
    @pulumi.getter
    def state(self) -> _builtins.str:
        """
        State of the service. The possible values are `POWEROFF`, `REBALANCING`, `REBUILDING` and `RUNNING`.
        """
        return pulumi.get(self, "state")

    @state.setter
    def state(self, value: _builtins.str):
        pulumi.set(self, "state", value)

    @_builtins.property
    @pulumi.getter(name="terminationProtection")
    def termination_protection(self) -> _builtins.bool:
        """
        Service is protected against termination and powering off.
        """
        return pulumi.get(self, "termination_protection")

    @termination_protection.setter
    def termination_protection(self, value: _builtins.bool):
        pulumi.set(self, "termination_protection", value)

    @_builtins.property
    @pulumi.getter(name="updateTime")
    def update_time(self) -> _builtins.str:
        """
        Service last update timestamp (ISO 8601).
        """
        return pulumi.get(self, "update_time")

    @update_time.setter
    def update_time(self, value: _builtins.str):
        pulumi.set(self, "update_time", value)


if not MYPY:
    class GetServiceListTimeoutsArgsDict(TypedDict):
        read: NotRequired[_builtins.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).
        """
elif False:
    GetServiceListTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetServiceListTimeoutsArgs:
    def __init__(__self__, *,
                 read: Optional[_builtins.str] = None):
        """
        :param _builtins.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).
        """
        if read is not None:
            pulumi.set(__self__, "read", read)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[_builtins.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, "read")

    @read.setter
    def read(self, value: Optional[_builtins.str]):
        pulumi.set(self, "read", value)


if not MYPY:
    class GetServicePlanBackupConfigArgsDict(TypedDict):
        frequent_interval_minutes: _builtins.int
        """
        Interval of taking a frequent backup in service types supporting different backup schedules.
        """
        frequent_oldest_age_minutes: _builtins.int
        """
        Maximum age of the oldest frequent backup in service types supporting different backup schedules.
        """
        infrequent_interval_minutes: _builtins.int
        """
        Interval of taking an infrequent backup in service types supporting different backup schedules.
        """
        infrequent_oldest_age_minutes: _builtins.int
        """
        Maximum age of the oldest infrequent backup in service types supporting different backup schedules.
        """
        interval: _builtins.int
        """
        The interval, in hours, at which backups are generated. For some services, like PostgreSQL, this is the interval at which full snapshots are taken and continuous incremental backup stream is maintained in addition to that.
        """
        max_count: _builtins.int
        """
        Maximum number of backups to keep. Zero when no backups are created.
        """
        recovery_mode: _builtins.str
        """
        Mechanism how backups can be restored. 'basic' means a backup is restored as is so that the system is restored to the state it was when the backup was generated. 'pitr' means point-in-time-recovery, which allows restoring the system to any state since the first available full snapshot. The possible values are `basic` and `pitr`.
        """
elif False:
    GetServicePlanBackupConfigArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetServicePlanBackupConfigArgs:
    def __init__(__self__, *,
                 frequent_interval_minutes: _builtins.int,
                 frequent_oldest_age_minutes: _builtins.int,
                 infrequent_interval_minutes: _builtins.int,
                 infrequent_oldest_age_minutes: _builtins.int,
                 interval: _builtins.int,
                 max_count: _builtins.int,
                 recovery_mode: _builtins.str):
        """
        :param _builtins.int frequent_interval_minutes: Interval of taking a frequent backup in service types supporting different backup schedules.
        :param _builtins.int frequent_oldest_age_minutes: Maximum age of the oldest frequent backup in service types supporting different backup schedules.
        :param _builtins.int infrequent_interval_minutes: Interval of taking an infrequent backup in service types supporting different backup schedules.
        :param _builtins.int infrequent_oldest_age_minutes: Maximum age of the oldest infrequent backup in service types supporting different backup schedules.
        :param _builtins.int interval: The interval, in hours, at which backups are generated. For some services, like PostgreSQL, this is the interval at which full snapshots are taken and continuous incremental backup stream is maintained in addition to that.
        :param _builtins.int max_count: Maximum number of backups to keep. Zero when no backups are created.
        :param _builtins.str recovery_mode: Mechanism how backups can be restored. 'basic' means a backup is restored as is so that the system is restored to the state it was when the backup was generated. 'pitr' means point-in-time-recovery, which allows restoring the system to any state since the first available full snapshot. The possible values are `basic` and `pitr`.
        """
        pulumi.set(__self__, "frequent_interval_minutes", frequent_interval_minutes)
        pulumi.set(__self__, "frequent_oldest_age_minutes", frequent_oldest_age_minutes)
        pulumi.set(__self__, "infrequent_interval_minutes", infrequent_interval_minutes)
        pulumi.set(__self__, "infrequent_oldest_age_minutes", infrequent_oldest_age_minutes)
        pulumi.set(__self__, "interval", interval)
        pulumi.set(__self__, "max_count", max_count)
        pulumi.set(__self__, "recovery_mode", recovery_mode)

    @_builtins.property
    @pulumi.getter(name="frequentIntervalMinutes")
    def frequent_interval_minutes(self) -> _builtins.int:
        """
        Interval of taking a frequent backup in service types supporting different backup schedules.
        """
        return pulumi.get(self, "frequent_interval_minutes")

    @frequent_interval_minutes.setter
    def frequent_interval_minutes(self, value: _builtins.int):
        pulumi.set(self, "frequent_interval_minutes", value)

    @_builtins.property
    @pulumi.getter(name="frequentOldestAgeMinutes")
    def frequent_oldest_age_minutes(self) -> _builtins.int:
        """
        Maximum age of the oldest frequent backup in service types supporting different backup schedules.
        """
        return pulumi.get(self, "frequent_oldest_age_minutes")

    @frequent_oldest_age_minutes.setter
    def frequent_oldest_age_minutes(self, value: _builtins.int):
        pulumi.set(self, "frequent_oldest_age_minutes", value)

    @_builtins.property
    @pulumi.getter(name="infrequentIntervalMinutes")
    def infrequent_interval_minutes(self) -> _builtins.int:
        """
        Interval of taking an infrequent backup in service types supporting different backup schedules.
        """
        return pulumi.get(self, "infrequent_interval_minutes")

    @infrequent_interval_minutes.setter
    def infrequent_interval_minutes(self, value: _builtins.int):
        pulumi.set(self, "infrequent_interval_minutes", value)

    @_builtins.property
    @pulumi.getter(name="infrequentOldestAgeMinutes")
    def infrequent_oldest_age_minutes(self) -> _builtins.int:
        """
        Maximum age of the oldest infrequent backup in service types supporting different backup schedules.
        """
        return pulumi.get(self, "infrequent_oldest_age_minutes")

    @infrequent_oldest_age_minutes.setter
    def infrequent_oldest_age_minutes(self, value: _builtins.int):
        pulumi.set(self, "infrequent_oldest_age_minutes", value)

    @_builtins.property
    @pulumi.getter
    def interval(self) -> _builtins.int:
        """
        The interval, in hours, at which backups are generated. For some services, like PostgreSQL, this is the interval at which full snapshots are taken and continuous incremental backup stream is maintained in addition to that.
        """
        return pulumi.get(self, "interval")

    @interval.setter
    def interval(self, value: _builtins.int):
        pulumi.set(self, "interval", value)

    @_builtins.property
    @pulumi.getter(name="maxCount")
    def max_count(self) -> _builtins.int:
        """
        Maximum number of backups to keep. Zero when no backups are created.
        """
        return pulumi.get(self, "max_count")

    @max_count.setter
    def max_count(self, value: _builtins.int):
        pulumi.set(self, "max_count", value)

    @_builtins.property
    @pulumi.getter(name="recoveryMode")
    def recovery_mode(self) -> _builtins.str:
        """
        Mechanism how backups can be restored. 'basic' means a backup is restored as is so that the system is restored to the state it was when the backup was generated. 'pitr' means point-in-time-recovery, which allows restoring the system to any state since the first available full snapshot. The possible values are `basic` and `pitr`.
        """
        return pulumi.get(self, "recovery_mode")

    @recovery_mode.setter
    def recovery_mode(self, value: _builtins.str):
        pulumi.set(self, "recovery_mode", value)


if not MYPY:
    class GetServicePlanListServicePlanArgsDict(TypedDict):
        max_memory_percent: _builtins.int
        """
        Maximum amount of system memory as a percentage (0-100) the service can actually use after taking into account management overhead. This is relevant for memory bound services for which some service management operations require allocating proportional amount of memory on top the basic load.
        """
        node_count: _builtins.int
        """
        Number of nodes in this service plan.
        """
        regions: Mapping[str, 'GetServicePlanListServicePlanRegionsArgsDict']
        """
        Service plan hourly price per cloud region.
        """
        service_plan: _builtins.str
        """
        Subscription plan.
        """
        service_type: _builtins.str
        """
        Service type code.
        """
        shard_count: _builtins.int
        """
        Number of shards in this service plan.
        """
elif False:
    GetServicePlanListServicePlanArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetServicePlanListServicePlanArgs:
    def __init__(__self__, *,
                 max_memory_percent: _builtins.int,
                 node_count: _builtins.int,
                 regions: Mapping[str, 'GetServicePlanListServicePlanRegionsArgs'],
                 service_plan: _builtins.str,
                 service_type: _builtins.str,
                 shard_count: _builtins.int):
        """
        :param _builtins.int max_memory_percent: Maximum amount of system memory as a percentage (0-100) the service can actually use after taking into account management overhead. This is relevant for memory bound services for which some service management operations require allocating proportional amount of memory on top the basic load.
        :param _builtins.int node_count: Number of nodes in this service plan.
        :param Mapping[str, 'GetServicePlanListServicePlanRegionsArgs'] regions: Service plan hourly price per cloud region.
        :param _builtins.str service_plan: Subscription plan.
        :param _builtins.str service_type: Service type code.
        :param _builtins.int shard_count: Number of shards in this service plan.
        """
        pulumi.set(__self__, "max_memory_percent", max_memory_percent)
        pulumi.set(__self__, "node_count", node_count)
        pulumi.set(__self__, "regions", regions)
        pulumi.set(__self__, "service_plan", service_plan)
        pulumi.set(__self__, "service_type", service_type)
        pulumi.set(__self__, "shard_count", shard_count)

    @_builtins.property
    @pulumi.getter(name="maxMemoryPercent")
    def max_memory_percent(self) -> _builtins.int:
        """
        Maximum amount of system memory as a percentage (0-100) the service can actually use after taking into account management overhead. This is relevant for memory bound services for which some service management operations require allocating proportional amount of memory on top the basic load.
        """
        return pulumi.get(self, "max_memory_percent")

    @max_memory_percent.setter
    def max_memory_percent(self, value: _builtins.int):
        pulumi.set(self, "max_memory_percent", value)

    @_builtins.property
    @pulumi.getter(name="nodeCount")
    def node_count(self) -> _builtins.int:
        """
        Number of nodes in this service plan.
        """
        return pulumi.get(self, "node_count")

    @node_count.setter
    def node_count(self, value: _builtins.int):
        pulumi.set(self, "node_count", value)

    @_builtins.property
    @pulumi.getter
    def regions(self) -> Mapping[str, 'GetServicePlanListServicePlanRegionsArgs']:
        """
        Service plan hourly price per cloud region.
        """
        return pulumi.get(self, "regions")

    @regions.setter
    def regions(self, value: Mapping[str, 'GetServicePlanListServicePlanRegionsArgs']):
        pulumi.set(self, "regions", value)

    @_builtins.property
    @pulumi.getter(name="servicePlan")
    def service_plan(self) -> _builtins.str:
        """
        Subscription plan.
        """
        return pulumi.get(self, "service_plan")

    @service_plan.setter
    def service_plan(self, value: _builtins.str):
        pulumi.set(self, "service_plan", value)

    @_builtins.property
    @pulumi.getter(name="serviceType")
    def service_type(self) -> _builtins.str:
        """
        Service type code.
        """
        return pulumi.get(self, "service_type")

    @service_type.setter
    def service_type(self, value: _builtins.str):
        pulumi.set(self, "service_type", value)

    @_builtins.property
    @pulumi.getter(name="shardCount")
    def shard_count(self) -> _builtins.int:
        """
        Number of shards in this service plan.
        """
        return pulumi.get(self, "shard_count")

    @shard_count.setter
    def shard_count(self, value: _builtins.int):
        pulumi.set(self, "shard_count", value)


if not MYPY:
    class GetServicePlanListServicePlanRegionsArgsDict(TypedDict):
        disk_space_cap_mb: _builtins.int
        """
        Maximum amount of disk space possible for the plan in the given region.
        """
        disk_space_gb_price_usd: _builtins.str
        """
        Hourly additional disk space price per GiB in this region.
        """
        disk_space_mb: _builtins.int
        """
        Combined amount of service disk space of all service nodes in megabytes.
        """
        disk_space_step_mb: _builtins.int
        """
        Disk space change step size.
        """
        node_cpu_count: _builtins.int
        """
        Number of CPU cores on each service node.
        """
        node_memory_mb: _builtins.int
        """
        Amount of memory on each service node in megabytes.
        """
        object_storage_gb_price_usd: _builtins.str
        """
        Hourly object storage price per GiB in this region.
        """
        price_usd: _builtins.str
        """
        Hourly service price in this region.
        """
elif False:
    GetServicePlanListServicePlanRegionsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetServicePlanListServicePlanRegionsArgs:
    def __init__(__self__, *,
                 disk_space_cap_mb: _builtins.int,
                 disk_space_gb_price_usd: _builtins.str,
                 disk_space_mb: _builtins.int,
                 disk_space_step_mb: _builtins.int,
                 node_cpu_count: _builtins.int,
                 node_memory_mb: _builtins.int,
                 object_storage_gb_price_usd: _builtins.str,
                 price_usd: _builtins.str):
        """
        :param _builtins.int disk_space_cap_mb: Maximum amount of disk space possible for the plan in the given region.
        :param _builtins.str disk_space_gb_price_usd: Hourly additional disk space price per GiB in this region.
        :param _builtins.int disk_space_mb: Combined amount of service disk space of all service nodes in megabytes.
        :param _builtins.int disk_space_step_mb: Disk space change step size.
        :param _builtins.int node_cpu_count: Number of CPU cores on each service node.
        :param _builtins.int node_memory_mb: Amount of memory on each service node in megabytes.
        :param _builtins.str object_storage_gb_price_usd: Hourly object storage price per GiB in this region.
        :param _builtins.str price_usd: Hourly service price in this region.
        """
        pulumi.set(__self__, "disk_space_cap_mb", disk_space_cap_mb)
        pulumi.set(__self__, "disk_space_gb_price_usd", disk_space_gb_price_usd)
        pulumi.set(__self__, "disk_space_mb", disk_space_mb)
        pulumi.set(__self__, "disk_space_step_mb", disk_space_step_mb)
        pulumi.set(__self__, "node_cpu_count", node_cpu_count)
        pulumi.set(__self__, "node_memory_mb", node_memory_mb)
        pulumi.set(__self__, "object_storage_gb_price_usd", object_storage_gb_price_usd)
        pulumi.set(__self__, "price_usd", price_usd)

    @_builtins.property
    @pulumi.getter(name="diskSpaceCapMb")
    def disk_space_cap_mb(self) -> _builtins.int:
        """
        Maximum amount of disk space possible for the plan in the given region.
        """
        return pulumi.get(self, "disk_space_cap_mb")

    @disk_space_cap_mb.setter
    def disk_space_cap_mb(self, value: _builtins.int):
        pulumi.set(self, "disk_space_cap_mb", value)

    @_builtins.property
    @pulumi.getter(name="diskSpaceGbPriceUsd")
    def disk_space_gb_price_usd(self) -> _builtins.str:
        """
        Hourly additional disk space price per GiB in this region.
        """
        return pulumi.get(self, "disk_space_gb_price_usd")

    @disk_space_gb_price_usd.setter
    def disk_space_gb_price_usd(self, value: _builtins.str):
        pulumi.set(self, "disk_space_gb_price_usd", value)

    @_builtins.property
    @pulumi.getter(name="diskSpaceMb")
    def disk_space_mb(self) -> _builtins.int:
        """
        Combined amount of service disk space of all service nodes in megabytes.
        """
        return pulumi.get(self, "disk_space_mb")

    @disk_space_mb.setter
    def disk_space_mb(self, value: _builtins.int):
        pulumi.set(self, "disk_space_mb", value)

    @_builtins.property
    @pulumi.getter(name="diskSpaceStepMb")
    def disk_space_step_mb(self) -> _builtins.int:
        """
        Disk space change step size.
        """
        return pulumi.get(self, "disk_space_step_mb")

    @disk_space_step_mb.setter
    def disk_space_step_mb(self, value: _builtins.int):
        pulumi.set(self, "disk_space_step_mb", value)

    @_builtins.property
    @pulumi.getter(name="nodeCpuCount")
    def node_cpu_count(self) -> _builtins.int:
        """
        Number of CPU cores on each service node.
        """
        return pulumi.get(self, "node_cpu_count")

    @node_cpu_count.setter
    def node_cpu_count(self, value: _builtins.int):
        pulumi.set(self, "node_cpu_count", value)

    @_builtins.property
    @pulumi.getter(name="nodeMemoryMb")
    def node_memory_mb(self) -> _builtins.int:
        """
        Amount of memory on each service node in megabytes.
        """
        return pulumi.get(self, "node_memory_mb")

    @node_memory_mb.setter
    def node_memory_mb(self, value: _builtins.int):
        pulumi.set(self, "node_memory_mb", value)

    @_builtins.property
    @pulumi.getter(name="objectStorageGbPriceUsd")
    def object_storage_gb_price_usd(self) -> _builtins.str:
        """
        Hourly object storage price per GiB in this region.
        """
        return pulumi.get(self, "object_storage_gb_price_usd")

    @object_storage_gb_price_usd.setter
    def object_storage_gb_price_usd(self, value: _builtins.str):
        pulumi.set(self, "object_storage_gb_price_usd", value)

    @_builtins.property
    @pulumi.getter(name="priceUsd")
    def price_usd(self) -> _builtins.str:
        """
        Hourly service price in this region.
        """
        return pulumi.get(self, "price_usd")

    @price_usd.setter
    def price_usd(self, value: _builtins.str):
        pulumi.set(self, "price_usd", value)


if not MYPY:
    class GetServicePlanListTimeoutsArgsDict(TypedDict):
        read: NotRequired[_builtins.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).
        """
elif False:
    GetServicePlanListTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetServicePlanListTimeoutsArgs:
    def __init__(__self__, *,
                 read: Optional[_builtins.str] = None):
        """
        :param _builtins.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).
        """
        if read is not None:
            pulumi.set(__self__, "read", read)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[_builtins.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, "read")

    @read.setter
    def read(self, value: Optional[_builtins.str]):
        pulumi.set(self, "read", value)


if not MYPY:
    class GetServicePlanTimeoutsArgsDict(TypedDict):
        read: NotRequired[_builtins.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).
        """
elif False:
    GetServicePlanTimeoutsArgsDict: TypeAlias = Mapping[str, Any]

@pulumi.input_type
class GetServicePlanTimeoutsArgs:
    def __init__(__self__, *,
                 read: Optional[_builtins.str] = None):
        """
        :param _builtins.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).
        """
        if read is not None:
            pulumi.set(__self__, "read", read)

    @_builtins.property
    @pulumi.getter
    def read(self) -> Optional[_builtins.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, "read")

    @read.setter
    def read(self, value: Optional[_builtins.str]):
        pulumi.set(self, "read", value)


