pulumi-digitalocean 4.40.0a1739511652__py3-none-any.whl → 4.56.0a1766428645__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (154) hide show
  1. pulumi_digitalocean/__init__.py +224 -1
  2. pulumi_digitalocean/_enums.py +19 -9
  3. pulumi_digitalocean/_inputs.py +17037 -4771
  4. pulumi_digitalocean/_utilities.py +1 -1
  5. pulumi_digitalocean/app.py +238 -88
  6. pulumi_digitalocean/byoip_prefix.py +452 -0
  7. pulumi_digitalocean/cdn.py +106 -105
  8. pulumi_digitalocean/certificate.py +139 -138
  9. pulumi_digitalocean/config/__init__.py +2 -1
  10. pulumi_digitalocean/config/__init__.pyi +2 -2
  11. pulumi_digitalocean/config/vars.py +11 -11
  12. pulumi_digitalocean/container_registries.py +285 -0
  13. pulumi_digitalocean/container_registry.py +90 -89
  14. pulumi_digitalocean/container_registry_docker_credentials.py +84 -83
  15. pulumi_digitalocean/custom_image.py +180 -179
  16. pulumi_digitalocean/database_cluster.py +402 -373
  17. pulumi_digitalocean/database_connection_pool.py +159 -158
  18. pulumi_digitalocean/database_db.py +37 -36
  19. pulumi_digitalocean/database_firewall.py +23 -22
  20. pulumi_digitalocean/database_kafka_config.py +309 -308
  21. pulumi_digitalocean/database_kafka_schema_registry.py +360 -0
  22. pulumi_digitalocean/database_kafka_topic.py +83 -82
  23. pulumi_digitalocean/database_logsink_opensearch.py +680 -0
  24. pulumi_digitalocean/database_logsink_rsyslog.py +842 -0
  25. pulumi_digitalocean/database_mongodb_config.py +105 -104
  26. pulumi_digitalocean/database_mysql_config.py +479 -478
  27. pulumi_digitalocean/database_online_migration.py +460 -0
  28. pulumi_digitalocean/database_opensearch_config.py +666 -665
  29. pulumi_digitalocean/database_postgresql_config.py +859 -858
  30. pulumi_digitalocean/database_redis_config.py +211 -206
  31. pulumi_digitalocean/database_replica.py +199 -198
  32. pulumi_digitalocean/database_user.py +93 -92
  33. pulumi_digitalocean/database_valkey_config.py +776 -0
  34. pulumi_digitalocean/dns_record.py +184 -183
  35. pulumi_digitalocean/domain.py +55 -54
  36. pulumi_digitalocean/droplet.py +403 -402
  37. pulumi_digitalocean/droplet_autoscale.py +55 -54
  38. pulumi_digitalocean/droplet_snapshot.py +73 -72
  39. pulumi_digitalocean/firewall.py +80 -79
  40. pulumi_digitalocean/floating_ip.py +63 -62
  41. pulumi_digitalocean/floating_ip_assignment.py +37 -36
  42. pulumi_digitalocean/genai_agent.py +1903 -0
  43. pulumi_digitalocean/genai_agent_knowledge_base_attachment.py +198 -0
  44. pulumi_digitalocean/genai_agent_route.py +354 -0
  45. pulumi_digitalocean/genai_function.py +464 -0
  46. pulumi_digitalocean/genai_indexing_job_cancel.py +542 -0
  47. pulumi_digitalocean/genai_knowledge_base.py +627 -0
  48. pulumi_digitalocean/genai_knowledge_base_data_source.py +220 -0
  49. pulumi_digitalocean/genai_openai_api_key.py +386 -0
  50. pulumi_digitalocean/get_account.py +18 -18
  51. pulumi_digitalocean/get_app.py +28 -28
  52. pulumi_digitalocean/get_byoip_prefix.py +214 -0
  53. pulumi_digitalocean/get_byoip_prefix_resources.py +150 -0
  54. pulumi_digitalocean/get_certificate.py +22 -22
  55. pulumi_digitalocean/get_container_registries.py +151 -0
  56. pulumi_digitalocean/get_container_registry.py +22 -22
  57. pulumi_digitalocean/get_database_ca.py +12 -12
  58. pulumi_digitalocean/get_database_cluster.py +76 -62
  59. pulumi_digitalocean/get_database_connection_pool.py +36 -36
  60. pulumi_digitalocean/get_database_metrics_credentials.py +120 -0
  61. pulumi_digitalocean/get_database_replica.py +46 -46
  62. pulumi_digitalocean/get_database_user.py +27 -27
  63. pulumi_digitalocean/get_domain.py +16 -16
  64. pulumi_digitalocean/get_domains.py +7 -7
  65. pulumi_digitalocean/get_droplet.py +72 -72
  66. pulumi_digitalocean/get_droplet_autoscale.py +23 -23
  67. pulumi_digitalocean/get_droplet_snapshot.py +38 -38
  68. pulumi_digitalocean/get_droplets.py +13 -13
  69. pulumi_digitalocean/get_firewall.py +31 -31
  70. pulumi_digitalocean/get_floating_ip.py +16 -16
  71. pulumi_digitalocean/get_genai_agent.py +572 -0
  72. pulumi_digitalocean/get_genai_agent_versions.py +128 -0
  73. pulumi_digitalocean/get_genai_agents.py +128 -0
  74. pulumi_digitalocean/get_genai_agents_by_openai_api_key.py +97 -0
  75. pulumi_digitalocean/get_genai_indexing_job.py +239 -0
  76. pulumi_digitalocean/get_genai_indexing_job_data_sources.py +97 -0
  77. pulumi_digitalocean/get_genai_knowledge_base.py +259 -0
  78. pulumi_digitalocean/get_genai_knowledge_base_data_sources.py +97 -0
  79. pulumi_digitalocean/get_genai_knowledge_base_indexing_jobs.py +108 -0
  80. pulumi_digitalocean/get_genai_knowledge_bases.py +113 -0
  81. pulumi_digitalocean/get_genai_models.py +113 -0
  82. pulumi_digitalocean/get_genai_openai_api_key.py +152 -0
  83. pulumi_digitalocean/get_genai_openai_api_keys.py +113 -0
  84. pulumi_digitalocean/get_genai_regions.py +113 -0
  85. pulumi_digitalocean/get_image.py +50 -50
  86. pulumi_digitalocean/get_images.py +7 -7
  87. pulumi_digitalocean/get_kubernetes_cluster.py +144 -53
  88. pulumi_digitalocean/get_kubernetes_versions.py +14 -14
  89. pulumi_digitalocean/get_load_balancer.py +70 -59
  90. pulumi_digitalocean/get_nfs.py +205 -0
  91. pulumi_digitalocean/get_nfs_snapshot.py +188 -0
  92. pulumi_digitalocean/get_partner_attachment.py +206 -0
  93. pulumi_digitalocean/get_partner_attachment_service_key.py +118 -0
  94. pulumi_digitalocean/get_project.py +32 -32
  95. pulumi_digitalocean/get_projects.py +7 -7
  96. pulumi_digitalocean/get_record.py +32 -32
  97. pulumi_digitalocean/get_records.py +13 -13
  98. pulumi_digitalocean/get_region.py +18 -18
  99. pulumi_digitalocean/get_regions.py +7 -7
  100. pulumi_digitalocean/get_reserved_ip.py +16 -16
  101. pulumi_digitalocean/get_reserved_ipv6.py +51 -16
  102. pulumi_digitalocean/get_sizes.py +141 -7
  103. pulumi_digitalocean/get_spaces_bucket.py +22 -22
  104. pulumi_digitalocean/get_spaces_bucket_object.py +58 -58
  105. pulumi_digitalocean/get_spaces_bucket_objects.py +46 -46
  106. pulumi_digitalocean/get_spaces_buckets.py +7 -7
  107. pulumi_digitalocean/get_spaces_key.py +157 -0
  108. pulumi_digitalocean/get_ssh_key.py +14 -14
  109. pulumi_digitalocean/get_ssh_keys.py +7 -7
  110. pulumi_digitalocean/get_tag.py +22 -22
  111. pulumi_digitalocean/get_tags.py +7 -7
  112. pulumi_digitalocean/get_volume.py +34 -34
  113. pulumi_digitalocean/get_volume_snapshot.py +40 -40
  114. pulumi_digitalocean/get_vpc.py +30 -30
  115. pulumi_digitalocean/get_vpc_nat_gateway.py +263 -0
  116. pulumi_digitalocean/get_vpc_peering.py +24 -24
  117. pulumi_digitalocean/kubernetes_cluster.py +572 -303
  118. pulumi_digitalocean/kubernetes_node_pool.py +170 -169
  119. pulumi_digitalocean/load_balancer.py +406 -372
  120. pulumi_digitalocean/monitor_alert.py +153 -156
  121. pulumi_digitalocean/nfs.py +481 -0
  122. pulumi_digitalocean/nfs_attachment.py +289 -0
  123. pulumi_digitalocean/nfs_snapshot.py +379 -0
  124. pulumi_digitalocean/outputs.py +26759 -7592
  125. pulumi_digitalocean/partner_attachment.py +555 -0
  126. pulumi_digitalocean/project.py +141 -140
  127. pulumi_digitalocean/project_resources.py +37 -36
  128. pulumi_digitalocean/provider.py +105 -84
  129. pulumi_digitalocean/pulumi-plugin.json +1 -1
  130. pulumi_digitalocean/reserved_ip.py +63 -62
  131. pulumi_digitalocean/reserved_ip_assignment.py +37 -36
  132. pulumi_digitalocean/reserved_ipv6.py +122 -62
  133. pulumi_digitalocean/reserved_ipv6_assignment.py +81 -30
  134. pulumi_digitalocean/spaces_bucket.py +107 -106
  135. pulumi_digitalocean/spaces_bucket_cors_configuration.py +40 -39
  136. pulumi_digitalocean/spaces_bucket_logging.py +346 -0
  137. pulumi_digitalocean/spaces_bucket_object.py +284 -283
  138. pulumi_digitalocean/spaces_bucket_policy.py +54 -53
  139. pulumi_digitalocean/spaces_key.py +388 -0
  140. pulumi_digitalocean/ssh_key.py +46 -45
  141. pulumi_digitalocean/tag.py +74 -73
  142. pulumi_digitalocean/uptime_alert.py +112 -111
  143. pulumi_digitalocean/uptime_check.py +90 -89
  144. pulumi_digitalocean/volume.py +183 -182
  145. pulumi_digitalocean/volume_attachment.py +37 -36
  146. pulumi_digitalocean/volume_snapshot.py +90 -89
  147. pulumi_digitalocean/vpc.py +100 -99
  148. pulumi_digitalocean/vpc_nat_gateway.py +722 -0
  149. pulumi_digitalocean/vpc_peering.py +55 -58
  150. {pulumi_digitalocean-4.40.0a1739511652.dist-info → pulumi_digitalocean-4.56.0a1766428645.dist-info}/METADATA +4 -4
  151. pulumi_digitalocean-4.56.0a1766428645.dist-info/RECORD +154 -0
  152. {pulumi_digitalocean-4.40.0a1739511652.dist-info → pulumi_digitalocean-4.56.0a1766428645.dist-info}/WHEEL +1 -1
  153. pulumi_digitalocean-4.40.0a1739511652.dist-info/RECORD +0 -108
  154. {pulumi_digitalocean-4.40.0a1739511652.dist-info → pulumi_digitalocean-4.56.0a1766428645.dist-info}/top_level.txt +0 -0
pulumi_digitalocean/database_kafka_config.py CHANGED
@@ -1,8 +1,8 @@
1
1
  # coding=utf-8
2
- # *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
2
+ # *** WARNING: this file was generated by pulumi-language-python. ***
3
3
  # *** Do not edit by hand unless you're certain you know what you are doing! ***
4
4
 
5
- import copy
5
+ import builtins as _builtins
6
6
  import warnings
7
7
  import sys
8
8
  import pulumi
@@ -19,44 +19,44 @@ __all__ = ['DatabaseKafkaConfigArgs', 'DatabaseKafkaConfig']
19
19
  @pulumi.input_type
20
20
  class DatabaseKafkaConfigArgs:
21
21
  def __init__(__self__, *,
22
- cluster_id: pulumi.Input[str],
23
- auto_create_topics_enable: Optional[pulumi.Input[bool]] = None,
24
- group_initial_rebalance_delay_ms: Optional[pulumi.Input[int]] = None,
25
- group_max_session_timeout_ms: Optional[pulumi.Input[int]] = None,
26
- group_min_session_timeout_ms: Optional[pulumi.Input[int]] = None,
27
- log_cleaner_delete_retention_ms: Optional[pulumi.Input[int]] = None,
28
- log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[str]] = None,
29
- log_flush_interval_ms: Optional[pulumi.Input[str]] = None,
30
- log_index_interval_bytes: Optional[pulumi.Input[int]] = None,
31
- log_message_downconversion_enable: Optional[pulumi.Input[bool]] = None,
32
- log_message_timestamp_difference_max_ms: Optional[pulumi.Input[str]] = None,
33
- log_preallocate: Optional[pulumi.Input[bool]] = None,
34
- log_retention_bytes: Optional[pulumi.Input[str]] = None,
35
- log_retention_hours: Optional[pulumi.Input[int]] = None,
36
- log_retention_ms: Optional[pulumi.Input[str]] = None,
37
- log_roll_jitter_ms: Optional[pulumi.Input[str]] = None,
38
- log_segment_delete_delay_ms: Optional[pulumi.Input[int]] = None,
39
- message_max_bytes: Optional[pulumi.Input[int]] = None):
22
+ cluster_id: pulumi.Input[_builtins.str],
23
+ auto_create_topics_enable: Optional[pulumi.Input[_builtins.bool]] = None,
24
+ group_initial_rebalance_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
25
+ group_max_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
26
+ group_min_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
27
+ log_cleaner_delete_retention_ms: Optional[pulumi.Input[_builtins.int]] = None,
28
+ log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[_builtins.str]] = None,
29
+ log_flush_interval_ms: Optional[pulumi.Input[_builtins.str]] = None,
30
+ log_index_interval_bytes: Optional[pulumi.Input[_builtins.int]] = None,
31
+ log_message_downconversion_enable: Optional[pulumi.Input[_builtins.bool]] = None,
32
+ log_message_timestamp_difference_max_ms: Optional[pulumi.Input[_builtins.str]] = None,
33
+ log_preallocate: Optional[pulumi.Input[_builtins.bool]] = None,
34
+ log_retention_bytes: Optional[pulumi.Input[_builtins.str]] = None,
35
+ log_retention_hours: Optional[pulumi.Input[_builtins.int]] = None,
36
+ log_retention_ms: Optional[pulumi.Input[_builtins.str]] = None,
37
+ log_roll_jitter_ms: Optional[pulumi.Input[_builtins.str]] = None,
38
+ log_segment_delete_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
39
+ message_max_bytes: Optional[pulumi.Input[_builtins.int]] = None):
40
40
  """
41
41
  The set of arguments for constructing a DatabaseKafkaConfig resource.
42
- :param pulumi.Input[str] cluster_id: The ID of the target Kafka cluster.
43
- :param pulumi.Input[bool] auto_create_topics_enable: Enable auto creation of topics.
44
- :param pulumi.Input[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.
45
- :param pulumi.Input[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.
46
- :param pulumi.Input[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.
47
- :param pulumi.Input[int] log_cleaner_delete_retention_ms: How long are delete records retained?
48
- :param pulumi.Input[str] 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.
49
- :param pulumi.Input[str] log_flush_interval_ms: The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
50
- :param pulumi.Input[int] log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index.
51
- :param pulumi.Input[bool] log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
52
- :param pulumi.Input[str] 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.
53
- :param pulumi.Input[bool] log_preallocate: Controls whether to preallocate a file when creating a new segment.
54
- :param pulumi.Input[str] log_retention_bytes: The maximum size of the log before deleting messages.
55
- :param pulumi.Input[int] log_retention_hours: The number of hours to keep a log file before deleting it.
56
- :param pulumi.Input[str] 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.
57
- :param pulumi.Input[str] 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.
58
- :param pulumi.Input[int] log_segment_delete_delay_ms: The amount of time to wait before deleting a file from the filesystem.
59
- :param pulumi.Input[int] message_max_bytes: The maximum size of message that the server can receive.
42
+ :param pulumi.Input[_builtins.str] cluster_id: The ID of the target Kafka cluster.
43
+ :param pulumi.Input[_builtins.bool] auto_create_topics_enable: Enable auto creation of topics.
44
+ :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.
45
+ :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.
46
+ :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.
47
+ :param pulumi.Input[_builtins.int] log_cleaner_delete_retention_ms: How long are delete records retained?
48
+ :param pulumi.Input[_builtins.str] 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.
49
+ :param pulumi.Input[_builtins.str] log_flush_interval_ms: The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
50
+ :param pulumi.Input[_builtins.int] log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index.
51
+ :param pulumi.Input[_builtins.bool] log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
52
+ :param pulumi.Input[_builtins.str] 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.
53
+ :param pulumi.Input[_builtins.bool] log_preallocate: Controls whether to preallocate a file when creating a new segment.
54
+ :param pulumi.Input[_builtins.str] log_retention_bytes: The maximum size of the log before deleting messages.
55
+ :param pulumi.Input[_builtins.int] log_retention_hours: The number of hours to keep a log file before deleting it.
56
+ :param pulumi.Input[_builtins.str] 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.
57
+ :param pulumi.Input[_builtins.str] 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.
58
+ :param pulumi.Input[_builtins.int] log_segment_delete_delay_ms: The amount of time to wait before deleting a file from the filesystem.
59
+ :param pulumi.Input[_builtins.int] message_max_bytes: The maximum size of message that the server can receive.
60
60
  """
61
61
  pulumi.set(__self__, "cluster_id", cluster_id)
62
62
  if auto_create_topics_enable is not None:
@@ -94,264 +94,264 @@ class DatabaseKafkaConfigArgs:
94
94
  if message_max_bytes is not None:
95
95
  pulumi.set(__self__, "message_max_bytes", message_max_bytes)
96
96
 
97
- @property
97
+ @_builtins.property
98
98
  @pulumi.getter(name="clusterId")
99
- def cluster_id(self) -> pulumi.Input[str]:
99
+ def cluster_id(self) -> pulumi.Input[_builtins.str]:
100
100
  """
101
101
  The ID of the target Kafka cluster.
102
102
  """
103
103
  return pulumi.get(self, "cluster_id")
104
104
 
105
105
  @cluster_id.setter
106
- def cluster_id(self, value: pulumi.Input[str]):
106
+ def cluster_id(self, value: pulumi.Input[_builtins.str]):
107
107
  pulumi.set(self, "cluster_id", value)
108
108
 
109
- @property
109
+ @_builtins.property
110
110
  @pulumi.getter(name="autoCreateTopicsEnable")
111
- def auto_create_topics_enable(self) -> Optional[pulumi.Input[bool]]:
111
+ def auto_create_topics_enable(self) -> Optional[pulumi.Input[_builtins.bool]]:
112
112
  """
113
113
  Enable auto creation of topics.
114
114
  """
115
115
  return pulumi.get(self, "auto_create_topics_enable")
116
116
 
117
117
  @auto_create_topics_enable.setter
118
- def auto_create_topics_enable(self, value: Optional[pulumi.Input[bool]]):
118
+ def auto_create_topics_enable(self, value: Optional[pulumi.Input[_builtins.bool]]):
119
119
  pulumi.set(self, "auto_create_topics_enable", value)
120
120
 
121
- @property
121
+ @_builtins.property
122
122
  @pulumi.getter(name="groupInitialRebalanceDelayMs")
123
- def group_initial_rebalance_delay_ms(self) -> Optional[pulumi.Input[int]]:
123
+ def group_initial_rebalance_delay_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
124
124
  """
125
125
  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.
126
126
  """
127
127
  return pulumi.get(self, "group_initial_rebalance_delay_ms")
128
128
 
129
129
  @group_initial_rebalance_delay_ms.setter
130
- def group_initial_rebalance_delay_ms(self, value: Optional[pulumi.Input[int]]):
130
+ def group_initial_rebalance_delay_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
131
131
  pulumi.set(self, "group_initial_rebalance_delay_ms", value)
132
132
 
133
- @property
133
+ @_builtins.property
134
134
  @pulumi.getter(name="groupMaxSessionTimeoutMs")
135
- def group_max_session_timeout_ms(self) -> Optional[pulumi.Input[int]]:
135
+ def group_max_session_timeout_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
136
136
  """
137
137
  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.
138
138
  """
139
139
  return pulumi.get(self, "group_max_session_timeout_ms")
140
140
 
141
141
  @group_max_session_timeout_ms.setter
142
- def group_max_session_timeout_ms(self, value: Optional[pulumi.Input[int]]):
142
+ def group_max_session_timeout_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
143
143
  pulumi.set(self, "group_max_session_timeout_ms", value)
144
144
 
145
- @property
145
+ @_builtins.property
146
146
  @pulumi.getter(name="groupMinSessionTimeoutMs")
147
- def group_min_session_timeout_ms(self) -> Optional[pulumi.Input[int]]:
147
+ def group_min_session_timeout_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
148
148
  """
149
149
  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.
150
150
  """
151
151
  return pulumi.get(self, "group_min_session_timeout_ms")
152
152
 
153
153
  @group_min_session_timeout_ms.setter
154
- def group_min_session_timeout_ms(self, value: Optional[pulumi.Input[int]]):
154
+ def group_min_session_timeout_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
155
155
  pulumi.set(self, "group_min_session_timeout_ms", value)
156
156
 
157
- @property
157
+ @_builtins.property
158
158
  @pulumi.getter(name="logCleanerDeleteRetentionMs")
159
- def log_cleaner_delete_retention_ms(self) -> Optional[pulumi.Input[int]]:
159
+ def log_cleaner_delete_retention_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
160
160
  """
161
161
  How long are delete records retained?
162
162
  """
163
163
  return pulumi.get(self, "log_cleaner_delete_retention_ms")
164
164
 
165
165
  @log_cleaner_delete_retention_ms.setter
166
- def log_cleaner_delete_retention_ms(self, value: Optional[pulumi.Input[int]]):
166
+ def log_cleaner_delete_retention_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
167
167
  pulumi.set(self, "log_cleaner_delete_retention_ms", value)
168
168
 
169
- @property
169
+ @_builtins.property
170
170
  @pulumi.getter(name="logCleanerMinCompactionLagMs")
171
- def log_cleaner_min_compaction_lag_ms(self) -> Optional[pulumi.Input[str]]:
171
+ def log_cleaner_min_compaction_lag_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
172
172
  """
173
173
  The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted.
174
174
  """
175
175
  return pulumi.get(self, "log_cleaner_min_compaction_lag_ms")
176
176
 
177
177
  @log_cleaner_min_compaction_lag_ms.setter
178
- def log_cleaner_min_compaction_lag_ms(self, value: Optional[pulumi.Input[str]]):
178
+ def log_cleaner_min_compaction_lag_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
179
179
  pulumi.set(self, "log_cleaner_min_compaction_lag_ms", value)
180
180
 
181
- @property
181
+ @_builtins.property
182
182
  @pulumi.getter(name="logFlushIntervalMs")
183
- def log_flush_interval_ms(self) -> Optional[pulumi.Input[str]]:
183
+ def log_flush_interval_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
184
184
  """
185
185
  The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
186
186
  """
187
187
  return pulumi.get(self, "log_flush_interval_ms")
188
188
 
189
189
  @log_flush_interval_ms.setter
190
- def log_flush_interval_ms(self, value: Optional[pulumi.Input[str]]):
190
+ def log_flush_interval_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
191
191
  pulumi.set(self, "log_flush_interval_ms", value)
192
192
 
193
- @property
193
+ @_builtins.property
194
194
  @pulumi.getter(name="logIndexIntervalBytes")
195
- def log_index_interval_bytes(self) -> Optional[pulumi.Input[int]]:
195
+ def log_index_interval_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
196
196
  """
197
197
  The interval with which Kafka adds an entry to the offset index.
198
198
  """
199
199
  return pulumi.get(self, "log_index_interval_bytes")
200
200
 
201
201
  @log_index_interval_bytes.setter
202
- def log_index_interval_bytes(self, value: Optional[pulumi.Input[int]]):
202
+ def log_index_interval_bytes(self, value: Optional[pulumi.Input[_builtins.int]]):
203
203
  pulumi.set(self, "log_index_interval_bytes", value)
204
204
 
205
- @property
205
+ @_builtins.property
206
206
  @pulumi.getter(name="logMessageDownconversionEnable")
207
- def log_message_downconversion_enable(self) -> Optional[pulumi.Input[bool]]:
207
+ def log_message_downconversion_enable(self) -> Optional[pulumi.Input[_builtins.bool]]:
208
208
  """
209
209
  This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
210
210
  """
211
211
  return pulumi.get(self, "log_message_downconversion_enable")
212
212
 
213
213
  @log_message_downconversion_enable.setter
214
- def log_message_downconversion_enable(self, value: Optional[pulumi.Input[bool]]):
214
+ def log_message_downconversion_enable(self, value: Optional[pulumi.Input[_builtins.bool]]):
215
215
  pulumi.set(self, "log_message_downconversion_enable", value)
216
216
 
217
- @property
217
+ @_builtins.property
218
218
  @pulumi.getter(name="logMessageTimestampDifferenceMaxMs")
219
- def log_message_timestamp_difference_max_ms(self) -> Optional[pulumi.Input[str]]:
219
+ def log_message_timestamp_difference_max_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
220
220
  """
221
221
  The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message.
222
222
  """
223
223
  return pulumi.get(self, "log_message_timestamp_difference_max_ms")
224
224
 
225
225
  @log_message_timestamp_difference_max_ms.setter
226
- def log_message_timestamp_difference_max_ms(self, value: Optional[pulumi.Input[str]]):
226
+ def log_message_timestamp_difference_max_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
227
227
  pulumi.set(self, "log_message_timestamp_difference_max_ms", value)
228
228
 
229
- @property
229
+ @_builtins.property
230
230
  @pulumi.getter(name="logPreallocate")
231
- def log_preallocate(self) -> Optional[pulumi.Input[bool]]:
231
+ def log_preallocate(self) -> Optional[pulumi.Input[_builtins.bool]]:
232
232
  """
233
233
  Controls whether to preallocate a file when creating a new segment.
234
234
  """
235
235
  return pulumi.get(self, "log_preallocate")
236
236
 
237
237
  @log_preallocate.setter
238
- def log_preallocate(self, value: Optional[pulumi.Input[bool]]):
238
+ def log_preallocate(self, value: Optional[pulumi.Input[_builtins.bool]]):
239
239
  pulumi.set(self, "log_preallocate", value)
240
240
 
241
- @property
241
+ @_builtins.property
242
242
  @pulumi.getter(name="logRetentionBytes")
243
- def log_retention_bytes(self) -> Optional[pulumi.Input[str]]:
243
+ def log_retention_bytes(self) -> Optional[pulumi.Input[_builtins.str]]:
244
244
  """
245
245
  The maximum size of the log before deleting messages.
246
246
  """
247
247
  return pulumi.get(self, "log_retention_bytes")
248
248
 
249
249
  @log_retention_bytes.setter
250
- def log_retention_bytes(self, value: Optional[pulumi.Input[str]]):
250
+ def log_retention_bytes(self, value: Optional[pulumi.Input[_builtins.str]]):
251
251
  pulumi.set(self, "log_retention_bytes", value)
252
252
 
253
- @property
253
+ @_builtins.property
254
254
  @pulumi.getter(name="logRetentionHours")
255
- def log_retention_hours(self) -> Optional[pulumi.Input[int]]:
255
+ def log_retention_hours(self) -> Optional[pulumi.Input[_builtins.int]]:
256
256
  """
257
257
  The number of hours to keep a log file before deleting it.
258
258
  """
259
259
  return pulumi.get(self, "log_retention_hours")
260
260
 
261
261
  @log_retention_hours.setter
262
- def log_retention_hours(self, value: Optional[pulumi.Input[int]]):
262
+ def log_retention_hours(self, value: Optional[pulumi.Input[_builtins.int]]):
263
263
  pulumi.set(self, "log_retention_hours", value)
264
264
 
265
- @property
265
+ @_builtins.property
266
266
  @pulumi.getter(name="logRetentionMs")
267
- def log_retention_ms(self) -> Optional[pulumi.Input[str]]:
267
+ def log_retention_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
268
268
  """
269
269
  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.
270
270
  """
271
271
  return pulumi.get(self, "log_retention_ms")
272
272
 
273
273
  @log_retention_ms.setter
274
- def log_retention_ms(self, value: Optional[pulumi.Input[str]]):
274
+ def log_retention_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
275
275
  pulumi.set(self, "log_retention_ms", value)
276
276
 
277
- @property
277
+ @_builtins.property
278
278
  @pulumi.getter(name="logRollJitterMs")
279
- def log_roll_jitter_ms(self) -> Optional[pulumi.Input[str]]:
279
+ def log_roll_jitter_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
280
280
  """
281
281
  The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used.
282
282
  """
283
283
  return pulumi.get(self, "log_roll_jitter_ms")
284
284
 
285
285
  @log_roll_jitter_ms.setter
286
- def log_roll_jitter_ms(self, value: Optional[pulumi.Input[str]]):
286
+ def log_roll_jitter_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
287
287
  pulumi.set(self, "log_roll_jitter_ms", value)
288
288
 
289
- @property
289
+ @_builtins.property
290
290
  @pulumi.getter(name="logSegmentDeleteDelayMs")
291
- def log_segment_delete_delay_ms(self) -> Optional[pulumi.Input[int]]:
291
+ def log_segment_delete_delay_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
292
292
  """
293
293
  The amount of time to wait before deleting a file from the filesystem.
294
294
  """
295
295
  return pulumi.get(self, "log_segment_delete_delay_ms")
296
296
 
297
297
  @log_segment_delete_delay_ms.setter
298
- def log_segment_delete_delay_ms(self, value: Optional[pulumi.Input[int]]):
298
+ def log_segment_delete_delay_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
299
299
  pulumi.set(self, "log_segment_delete_delay_ms", value)
300
300
 
301
- @property
301
+ @_builtins.property
302
302
  @pulumi.getter(name="messageMaxBytes")
303
- def message_max_bytes(self) -> Optional[pulumi.Input[int]]:
303
+ def message_max_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
304
304
  """
305
305
  The maximum size of message that the server can receive.
306
306
  """
307
307
  return pulumi.get(self, "message_max_bytes")
308
308
 
309
309
  @message_max_bytes.setter
310
- def message_max_bytes(self, value: Optional[pulumi.Input[int]]):
310
+ def message_max_bytes(self, value: Optional[pulumi.Input[_builtins.int]]):
311
311
  pulumi.set(self, "message_max_bytes", value)
312
312
 
313
313
 
314
314
  @pulumi.input_type
315
315
  class _DatabaseKafkaConfigState:
316
316
  def __init__(__self__, *,
317
- auto_create_topics_enable: Optional[pulumi.Input[bool]] = None,
318
- cluster_id: Optional[pulumi.Input[str]] = None,
319
- group_initial_rebalance_delay_ms: Optional[pulumi.Input[int]] = None,
320
- group_max_session_timeout_ms: Optional[pulumi.Input[int]] = None,
321
- group_min_session_timeout_ms: Optional[pulumi.Input[int]] = None,
322
- log_cleaner_delete_retention_ms: Optional[pulumi.Input[int]] = None,
323
- log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[str]] = None,
324
- log_flush_interval_ms: Optional[pulumi.Input[str]] = None,
325
- log_index_interval_bytes: Optional[pulumi.Input[int]] = None,
326
- log_message_downconversion_enable: Optional[pulumi.Input[bool]] = None,
327
- log_message_timestamp_difference_max_ms: Optional[pulumi.Input[str]] = None,
328
- log_preallocate: Optional[pulumi.Input[bool]] = None,
329
- log_retention_bytes: Optional[pulumi.Input[str]] = None,
330
- log_retention_hours: Optional[pulumi.Input[int]] = None,
331
- log_retention_ms: Optional[pulumi.Input[str]] = None,
332
- log_roll_jitter_ms: Optional[pulumi.Input[str]] = None,
333
- log_segment_delete_delay_ms: Optional[pulumi.Input[int]] = None,
334
- message_max_bytes: Optional[pulumi.Input[int]] = None):
317
+ auto_create_topics_enable: Optional[pulumi.Input[_builtins.bool]] = None,
318
+ cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
319
+ group_initial_rebalance_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
320
+ group_max_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
321
+ group_min_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
322
+ log_cleaner_delete_retention_ms: Optional[pulumi.Input[_builtins.int]] = None,
323
+ log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[_builtins.str]] = None,
324
+ log_flush_interval_ms: Optional[pulumi.Input[_builtins.str]] = None,
325
+ log_index_interval_bytes: Optional[pulumi.Input[_builtins.int]] = None,
326
+ log_message_downconversion_enable: Optional[pulumi.Input[_builtins.bool]] = None,
327
+ log_message_timestamp_difference_max_ms: Optional[pulumi.Input[_builtins.str]] = None,
328
+ log_preallocate: Optional[pulumi.Input[_builtins.bool]] = None,
329
+ log_retention_bytes: Optional[pulumi.Input[_builtins.str]] = None,
330
+ log_retention_hours: Optional[pulumi.Input[_builtins.int]] = None,
331
+ log_retention_ms: Optional[pulumi.Input[_builtins.str]] = None,
332
+ log_roll_jitter_ms: Optional[pulumi.Input[_builtins.str]] = None,
333
+ log_segment_delete_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
334
+ message_max_bytes: Optional[pulumi.Input[_builtins.int]] = None):
335
335
  """
336
336
  Input properties used for looking up and filtering DatabaseKafkaConfig resources.
337
- :param pulumi.Input[bool] auto_create_topics_enable: Enable auto creation of topics.
338
- :param pulumi.Input[str] cluster_id: The ID of the target Kafka cluster.
339
- :param pulumi.Input[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.
340
- :param pulumi.Input[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.
341
- :param pulumi.Input[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.
342
- :param pulumi.Input[int] log_cleaner_delete_retention_ms: How long are delete records retained?
343
- :param pulumi.Input[str] 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.
344
- :param pulumi.Input[str] log_flush_interval_ms: The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
345
- :param pulumi.Input[int] log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index.
346
- :param pulumi.Input[bool] log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
347
- :param pulumi.Input[str] 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.
348
- :param pulumi.Input[bool] log_preallocate: Controls whether to preallocate a file when creating a new segment.
349
- :param pulumi.Input[str] log_retention_bytes: The maximum size of the log before deleting messages.
350
- :param pulumi.Input[int] log_retention_hours: The number of hours to keep a log file before deleting it.
351
- :param pulumi.Input[str] 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.
352
- :param pulumi.Input[str] 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.
353
- :param pulumi.Input[int] log_segment_delete_delay_ms: The amount of time to wait before deleting a file from the filesystem.
354
- :param pulumi.Input[int] message_max_bytes: The maximum size of message that the server can receive.
337
+ :param pulumi.Input[_builtins.bool] auto_create_topics_enable: Enable auto creation of topics.
338
+ :param pulumi.Input[_builtins.str] cluster_id: The ID of the target Kafka cluster.
339
+ :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.
340
+ :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.
341
+ :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.
342
+ :param pulumi.Input[_builtins.int] log_cleaner_delete_retention_ms: How long are delete records retained?
343
+ :param pulumi.Input[_builtins.str] 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.
344
+ :param pulumi.Input[_builtins.str] log_flush_interval_ms: The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
345
+ :param pulumi.Input[_builtins.int] log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index.
346
+ :param pulumi.Input[_builtins.bool] log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
347
+ :param pulumi.Input[_builtins.str] 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.
348
+ :param pulumi.Input[_builtins.bool] log_preallocate: Controls whether to preallocate a file when creating a new segment.
349
+ :param pulumi.Input[_builtins.str] log_retention_bytes: The maximum size of the log before deleting messages.
350
+ :param pulumi.Input[_builtins.int] log_retention_hours: The number of hours to keep a log file before deleting it.
351
+ :param pulumi.Input[_builtins.str] 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.
352
+ :param pulumi.Input[_builtins.str] 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.
353
+ :param pulumi.Input[_builtins.int] log_segment_delete_delay_ms: The amount of time to wait before deleting a file from the filesystem.
354
+ :param pulumi.Input[_builtins.int] message_max_bytes: The maximum size of message that the server can receive.
355
355
  """
356
356
  if auto_create_topics_enable is not None:
357
357
  pulumi.set(__self__, "auto_create_topics_enable", auto_create_topics_enable)
@@ -390,246 +390,247 @@ class _DatabaseKafkaConfigState:
390
390
  if message_max_bytes is not None:
391
391
  pulumi.set(__self__, "message_max_bytes", message_max_bytes)
392
392
 
393
- @property
393
+ @_builtins.property
394
394
  @pulumi.getter(name="autoCreateTopicsEnable")
395
- def auto_create_topics_enable(self) -> Optional[pulumi.Input[bool]]:
395
+ def auto_create_topics_enable(self) -> Optional[pulumi.Input[_builtins.bool]]:
396
396
  """
397
397
  Enable auto creation of topics.
398
398
  """
399
399
  return pulumi.get(self, "auto_create_topics_enable")
400
400
 
401
401
  @auto_create_topics_enable.setter
402
- def auto_create_topics_enable(self, value: Optional[pulumi.Input[bool]]):
402
+ def auto_create_topics_enable(self, value: Optional[pulumi.Input[_builtins.bool]]):
403
403
  pulumi.set(self, "auto_create_topics_enable", value)
404
404
 
405
- @property
405
+ @_builtins.property
406
406
  @pulumi.getter(name="clusterId")
407
- def cluster_id(self) -> Optional[pulumi.Input[str]]:
407
+ def cluster_id(self) -> Optional[pulumi.Input[_builtins.str]]:
408
408
  """
409
409
  The ID of the target Kafka cluster.
410
410
  """
411
411
  return pulumi.get(self, "cluster_id")
412
412
 
413
413
  @cluster_id.setter
414
- def cluster_id(self, value: Optional[pulumi.Input[str]]):
414
+ def cluster_id(self, value: Optional[pulumi.Input[_builtins.str]]):
415
415
  pulumi.set(self, "cluster_id", value)
416
416
 
417
- @property
417
+ @_builtins.property
418
418
  @pulumi.getter(name="groupInitialRebalanceDelayMs")
419
- def group_initial_rebalance_delay_ms(self) -> Optional[pulumi.Input[int]]:
419
+ def group_initial_rebalance_delay_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
420
420
  """
421
421
  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.
422
422
  """
423
423
  return pulumi.get(self, "group_initial_rebalance_delay_ms")
424
424
 
425
425
  @group_initial_rebalance_delay_ms.setter
426
- def group_initial_rebalance_delay_ms(self, value: Optional[pulumi.Input[int]]):
426
+ def group_initial_rebalance_delay_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
427
427
  pulumi.set(self, "group_initial_rebalance_delay_ms", value)
428
428
 
429
- @property
429
+ @_builtins.property
430
430
  @pulumi.getter(name="groupMaxSessionTimeoutMs")
431
- def group_max_session_timeout_ms(self) -> Optional[pulumi.Input[int]]:
431
+ def group_max_session_timeout_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
432
432
  """
433
433
  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.
434
434
  """
435
435
  return pulumi.get(self, "group_max_session_timeout_ms")
436
436
 
437
437
  @group_max_session_timeout_ms.setter
438
- def group_max_session_timeout_ms(self, value: Optional[pulumi.Input[int]]):
438
+ def group_max_session_timeout_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
439
439
  pulumi.set(self, "group_max_session_timeout_ms", value)
440
440
 
441
- @property
441
+ @_builtins.property
442
442
  @pulumi.getter(name="groupMinSessionTimeoutMs")
443
- def group_min_session_timeout_ms(self) -> Optional[pulumi.Input[int]]:
443
+ def group_min_session_timeout_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
444
444
  """
445
445
  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.
446
446
  """
447
447
  return pulumi.get(self, "group_min_session_timeout_ms")
448
448
 
449
449
  @group_min_session_timeout_ms.setter
450
- def group_min_session_timeout_ms(self, value: Optional[pulumi.Input[int]]):
450
+ def group_min_session_timeout_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
451
451
  pulumi.set(self, "group_min_session_timeout_ms", value)
452
452
 
453
- @property
453
+ @_builtins.property
454
454
  @pulumi.getter(name="logCleanerDeleteRetentionMs")
455
- def log_cleaner_delete_retention_ms(self) -> Optional[pulumi.Input[int]]:
455
+ def log_cleaner_delete_retention_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
456
456
  """
457
457
  How long are delete records retained?
458
458
  """
459
459
  return pulumi.get(self, "log_cleaner_delete_retention_ms")
460
460
 
461
461
  @log_cleaner_delete_retention_ms.setter
462
- def log_cleaner_delete_retention_ms(self, value: Optional[pulumi.Input[int]]):
462
+ def log_cleaner_delete_retention_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
463
463
  pulumi.set(self, "log_cleaner_delete_retention_ms", value)
464
464
 
465
- @property
465
+ @_builtins.property
466
466
  @pulumi.getter(name="logCleanerMinCompactionLagMs")
467
- def log_cleaner_min_compaction_lag_ms(self) -> Optional[pulumi.Input[str]]:
467
+ def log_cleaner_min_compaction_lag_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
468
468
  """
469
469
  The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted.
470
470
  """
471
471
  return pulumi.get(self, "log_cleaner_min_compaction_lag_ms")
472
472
 
473
473
  @log_cleaner_min_compaction_lag_ms.setter
474
- def log_cleaner_min_compaction_lag_ms(self, value: Optional[pulumi.Input[str]]):
474
+ def log_cleaner_min_compaction_lag_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
475
475
  pulumi.set(self, "log_cleaner_min_compaction_lag_ms", value)
476
476
 
477
- @property
477
+ @_builtins.property
478
478
  @pulumi.getter(name="logFlushIntervalMs")
479
- def log_flush_interval_ms(self) -> Optional[pulumi.Input[str]]:
479
+ def log_flush_interval_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
480
480
  """
481
481
  The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
482
482
  """
483
483
  return pulumi.get(self, "log_flush_interval_ms")
484
484
 
485
485
  @log_flush_interval_ms.setter
486
- def log_flush_interval_ms(self, value: Optional[pulumi.Input[str]]):
486
+ def log_flush_interval_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
487
487
  pulumi.set(self, "log_flush_interval_ms", value)
488
488
 
489
- @property
489
+ @_builtins.property
490
490
  @pulumi.getter(name="logIndexIntervalBytes")
491
- def log_index_interval_bytes(self) -> Optional[pulumi.Input[int]]:
491
+ def log_index_interval_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
492
492
  """
493
493
  The interval with which Kafka adds an entry to the offset index.
494
494
  """
495
495
  return pulumi.get(self, "log_index_interval_bytes")
496
496
 
497
497
  @log_index_interval_bytes.setter
498
- def log_index_interval_bytes(self, value: Optional[pulumi.Input[int]]):
498
+ def log_index_interval_bytes(self, value: Optional[pulumi.Input[_builtins.int]]):
499
499
  pulumi.set(self, "log_index_interval_bytes", value)
500
500
 
501
- @property
501
+ @_builtins.property
502
502
  @pulumi.getter(name="logMessageDownconversionEnable")
503
- def log_message_downconversion_enable(self) -> Optional[pulumi.Input[bool]]:
503
+ def log_message_downconversion_enable(self) -> Optional[pulumi.Input[_builtins.bool]]:
504
504
  """
505
505
  This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
506
506
  """
507
507
  return pulumi.get(self, "log_message_downconversion_enable")
508
508
 
509
509
  @log_message_downconversion_enable.setter
510
- def log_message_downconversion_enable(self, value: Optional[pulumi.Input[bool]]):
510
+ def log_message_downconversion_enable(self, value: Optional[pulumi.Input[_builtins.bool]]):
511
511
  pulumi.set(self, "log_message_downconversion_enable", value)
512
512
 
513
- @property
513
+ @_builtins.property
514
514
  @pulumi.getter(name="logMessageTimestampDifferenceMaxMs")
515
- def log_message_timestamp_difference_max_ms(self) -> Optional[pulumi.Input[str]]:
515
+ def log_message_timestamp_difference_max_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
516
516
  """
517
517
  The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message.
518
518
  """
519
519
  return pulumi.get(self, "log_message_timestamp_difference_max_ms")
520
520
 
521
521
  @log_message_timestamp_difference_max_ms.setter
522
- def log_message_timestamp_difference_max_ms(self, value: Optional[pulumi.Input[str]]):
522
+ def log_message_timestamp_difference_max_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
523
523
  pulumi.set(self, "log_message_timestamp_difference_max_ms", value)
524
524
 
525
- @property
525
+ @_builtins.property
526
526
  @pulumi.getter(name="logPreallocate")
527
- def log_preallocate(self) -> Optional[pulumi.Input[bool]]:
527
+ def log_preallocate(self) -> Optional[pulumi.Input[_builtins.bool]]:
528
528
  """
529
529
  Controls whether to preallocate a file when creating a new segment.
530
530
  """
531
531
  return pulumi.get(self, "log_preallocate")
532
532
 
533
533
  @log_preallocate.setter
534
- def log_preallocate(self, value: Optional[pulumi.Input[bool]]):
534
+ def log_preallocate(self, value: Optional[pulumi.Input[_builtins.bool]]):
535
535
  pulumi.set(self, "log_preallocate", value)
536
536
 
537
- @property
537
+ @_builtins.property
538
538
  @pulumi.getter(name="logRetentionBytes")
539
- def log_retention_bytes(self) -> Optional[pulumi.Input[str]]:
539
+ def log_retention_bytes(self) -> Optional[pulumi.Input[_builtins.str]]:
540
540
  """
541
541
  The maximum size of the log before deleting messages.
542
542
  """
543
543
  return pulumi.get(self, "log_retention_bytes")
544
544
 
545
545
  @log_retention_bytes.setter
546
- def log_retention_bytes(self, value: Optional[pulumi.Input[str]]):
546
+ def log_retention_bytes(self, value: Optional[pulumi.Input[_builtins.str]]):
547
547
  pulumi.set(self, "log_retention_bytes", value)
548
548
 
549
- @property
549
+ @_builtins.property
550
550
  @pulumi.getter(name="logRetentionHours")
551
- def log_retention_hours(self) -> Optional[pulumi.Input[int]]:
551
+ def log_retention_hours(self) -> Optional[pulumi.Input[_builtins.int]]:
552
552
  """
553
553
  The number of hours to keep a log file before deleting it.
554
554
  """
555
555
  return pulumi.get(self, "log_retention_hours")
556
556
 
557
557
  @log_retention_hours.setter
558
- def log_retention_hours(self, value: Optional[pulumi.Input[int]]):
558
+ def log_retention_hours(self, value: Optional[pulumi.Input[_builtins.int]]):
559
559
  pulumi.set(self, "log_retention_hours", value)
560
560
 
561
- @property
561
+ @_builtins.property
562
562
  @pulumi.getter(name="logRetentionMs")
563
- def log_retention_ms(self) -> Optional[pulumi.Input[str]]:
563
+ def log_retention_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
564
564
  """
565
565
  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.
566
566
  """
567
567
  return pulumi.get(self, "log_retention_ms")
568
568
 
569
569
  @log_retention_ms.setter
570
- def log_retention_ms(self, value: Optional[pulumi.Input[str]]):
570
+ def log_retention_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
571
571
  pulumi.set(self, "log_retention_ms", value)
572
572
 
573
- @property
573
+ @_builtins.property
574
574
  @pulumi.getter(name="logRollJitterMs")
575
- def log_roll_jitter_ms(self) -> Optional[pulumi.Input[str]]:
575
+ def log_roll_jitter_ms(self) -> Optional[pulumi.Input[_builtins.str]]:
576
576
  """
577
577
  The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used.
578
578
  """
579
579
  return pulumi.get(self, "log_roll_jitter_ms")
580
580
 
581
581
  @log_roll_jitter_ms.setter
582
- def log_roll_jitter_ms(self, value: Optional[pulumi.Input[str]]):
582
+ def log_roll_jitter_ms(self, value: Optional[pulumi.Input[_builtins.str]]):
583
583
  pulumi.set(self, "log_roll_jitter_ms", value)
584
584
 
585
- @property
585
+ @_builtins.property
586
586
  @pulumi.getter(name="logSegmentDeleteDelayMs")
587
- def log_segment_delete_delay_ms(self) -> Optional[pulumi.Input[int]]:
587
+ def log_segment_delete_delay_ms(self) -> Optional[pulumi.Input[_builtins.int]]:
588
588
  """
589
589
  The amount of time to wait before deleting a file from the filesystem.
590
590
  """
591
591
  return pulumi.get(self, "log_segment_delete_delay_ms")
592
592
 
593
593
  @log_segment_delete_delay_ms.setter
594
- def log_segment_delete_delay_ms(self, value: Optional[pulumi.Input[int]]):
594
+ def log_segment_delete_delay_ms(self, value: Optional[pulumi.Input[_builtins.int]]):
595
595
  pulumi.set(self, "log_segment_delete_delay_ms", value)
596
596
 
597
- @property
597
+ @_builtins.property
598
598
  @pulumi.getter(name="messageMaxBytes")
599
- def message_max_bytes(self) -> Optional[pulumi.Input[int]]:
599
+ def message_max_bytes(self) -> Optional[pulumi.Input[_builtins.int]]:
600
600
  """
601
601
  The maximum size of message that the server can receive.
602
602
  """
603
603
  return pulumi.get(self, "message_max_bytes")
604
604
 
605
605
  @message_max_bytes.setter
606
- def message_max_bytes(self, value: Optional[pulumi.Input[int]]):
606
+ def message_max_bytes(self, value: Optional[pulumi.Input[_builtins.int]]):
607
607
  pulumi.set(self, "message_max_bytes", value)
608
608
 
609
609
 
610
+ @pulumi.type_token("digitalocean:index/databaseKafkaConfig:DatabaseKafkaConfig")
610
611
  class DatabaseKafkaConfig(pulumi.CustomResource):
611
612
  @overload
612
613
  def __init__(__self__,
613
614
  resource_name: str,
614
615
  opts: Optional[pulumi.ResourceOptions] = None,
615
- auto_create_topics_enable: Optional[pulumi.Input[bool]] = None,
616
- cluster_id: Optional[pulumi.Input[str]] = None,
617
- group_initial_rebalance_delay_ms: Optional[pulumi.Input[int]] = None,
618
- group_max_session_timeout_ms: Optional[pulumi.Input[int]] = None,
619
- group_min_session_timeout_ms: Optional[pulumi.Input[int]] = None,
620
- log_cleaner_delete_retention_ms: Optional[pulumi.Input[int]] = None,
621
- log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[str]] = None,
622
- log_flush_interval_ms: Optional[pulumi.Input[str]] = None,
623
- log_index_interval_bytes: Optional[pulumi.Input[int]] = None,
624
- log_message_downconversion_enable: Optional[pulumi.Input[bool]] = None,
625
- log_message_timestamp_difference_max_ms: Optional[pulumi.Input[str]] = None,
626
- log_preallocate: Optional[pulumi.Input[bool]] = None,
627
- log_retention_bytes: Optional[pulumi.Input[str]] = None,
628
- log_retention_hours: Optional[pulumi.Input[int]] = None,
629
- log_retention_ms: Optional[pulumi.Input[str]] = None,
630
- log_roll_jitter_ms: Optional[pulumi.Input[str]] = None,
631
- log_segment_delete_delay_ms: Optional[pulumi.Input[int]] = None,
632
- message_max_bytes: Optional[pulumi.Input[int]] = None,
616
+ auto_create_topics_enable: Optional[pulumi.Input[_builtins.bool]] = None,
617
+ cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
618
+ group_initial_rebalance_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
619
+ group_max_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
620
+ group_min_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
621
+ log_cleaner_delete_retention_ms: Optional[pulumi.Input[_builtins.int]] = None,
622
+ log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[_builtins.str]] = None,
623
+ log_flush_interval_ms: Optional[pulumi.Input[_builtins.str]] = None,
624
+ log_index_interval_bytes: Optional[pulumi.Input[_builtins.int]] = None,
625
+ log_message_downconversion_enable: Optional[pulumi.Input[_builtins.bool]] = None,
626
+ log_message_timestamp_difference_max_ms: Optional[pulumi.Input[_builtins.str]] = None,
627
+ log_preallocate: Optional[pulumi.Input[_builtins.bool]] = None,
628
+ log_retention_bytes: Optional[pulumi.Input[_builtins.str]] = None,
629
+ log_retention_hours: Optional[pulumi.Input[_builtins.int]] = None,
630
+ log_retention_ms: Optional[pulumi.Input[_builtins.str]] = None,
631
+ log_roll_jitter_ms: Optional[pulumi.Input[_builtins.str]] = None,
632
+ log_segment_delete_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
633
+ message_max_bytes: Optional[pulumi.Input[_builtins.int]] = None,
633
634
  __props__=None):
634
635
  """
635
636
  Provides a virtual resource that can be used to change advanced configuration
@@ -681,24 +682,24 @@ class DatabaseKafkaConfig(pulumi.CustomResource):
681
682
 
682
683
  :param str resource_name: The name of the resource.
683
684
  :param pulumi.ResourceOptions opts: Options for the resource.
684
- :param pulumi.Input[bool] auto_create_topics_enable: Enable auto creation of topics.
685
- :param pulumi.Input[str] cluster_id: The ID of the target Kafka cluster.
686
- :param pulumi.Input[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.
687
- :param pulumi.Input[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.
688
- :param pulumi.Input[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.
689
- :param pulumi.Input[int] log_cleaner_delete_retention_ms: How long are delete records retained?
690
- :param pulumi.Input[str] 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.
691
- :param pulumi.Input[str] log_flush_interval_ms: The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
692
- :param pulumi.Input[int] log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index.
693
- :param pulumi.Input[bool] log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
694
- :param pulumi.Input[str] 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.
695
- :param pulumi.Input[bool] log_preallocate: Controls whether to preallocate a file when creating a new segment.
696
- :param pulumi.Input[str] log_retention_bytes: The maximum size of the log before deleting messages.
697
- :param pulumi.Input[int] log_retention_hours: The number of hours to keep a log file before deleting it.
698
- :param pulumi.Input[str] 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.
699
- :param pulumi.Input[str] 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.
700
- :param pulumi.Input[int] log_segment_delete_delay_ms: The amount of time to wait before deleting a file from the filesystem.
701
- :param pulumi.Input[int] message_max_bytes: The maximum size of message that the server can receive.
685
+ :param pulumi.Input[_builtins.bool] auto_create_topics_enable: Enable auto creation of topics.
686
+ :param pulumi.Input[_builtins.str] cluster_id: The ID of the target Kafka cluster.
687
+ :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.
688
+ :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.
689
+ :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.
690
+ :param pulumi.Input[_builtins.int] log_cleaner_delete_retention_ms: How long are delete records retained?
691
+ :param pulumi.Input[_builtins.str] 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.
692
+ :param pulumi.Input[_builtins.str] log_flush_interval_ms: The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
693
+ :param pulumi.Input[_builtins.int] log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index.
694
+ :param pulumi.Input[_builtins.bool] log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
695
+ :param pulumi.Input[_builtins.str] 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.
696
+ :param pulumi.Input[_builtins.bool] log_preallocate: Controls whether to preallocate a file when creating a new segment.
697
+ :param pulumi.Input[_builtins.str] log_retention_bytes: The maximum size of the log before deleting messages.
698
+ :param pulumi.Input[_builtins.int] log_retention_hours: The number of hours to keep a log file before deleting it.
699
+ :param pulumi.Input[_builtins.str] 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.
700
+ :param pulumi.Input[_builtins.str] 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.
701
+ :param pulumi.Input[_builtins.int] log_segment_delete_delay_ms: The amount of time to wait before deleting a file from the filesystem.
702
+ :param pulumi.Input[_builtins.int] message_max_bytes: The maximum size of message that the server can receive.
702
703
  """
703
704
  ...
704
705
  @overload
@@ -769,24 +770,24 @@ class DatabaseKafkaConfig(pulumi.CustomResource):
769
770
  def _internal_init(__self__,
770
771
  resource_name: str,
771
772
  opts: Optional[pulumi.ResourceOptions] = None,
772
- auto_create_topics_enable: Optional[pulumi.Input[bool]] = None,
773
- cluster_id: Optional[pulumi.Input[str]] = None,
774
- group_initial_rebalance_delay_ms: Optional[pulumi.Input[int]] = None,
775
- group_max_session_timeout_ms: Optional[pulumi.Input[int]] = None,
776
- group_min_session_timeout_ms: Optional[pulumi.Input[int]] = None,
777
- log_cleaner_delete_retention_ms: Optional[pulumi.Input[int]] = None,
778
- log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[str]] = None,
779
- log_flush_interval_ms: Optional[pulumi.Input[str]] = None,
780
- log_index_interval_bytes: Optional[pulumi.Input[int]] = None,
781
- log_message_downconversion_enable: Optional[pulumi.Input[bool]] = None,
782
- log_message_timestamp_difference_max_ms: Optional[pulumi.Input[str]] = None,
783
- log_preallocate: Optional[pulumi.Input[bool]] = None,
784
- log_retention_bytes: Optional[pulumi.Input[str]] = None,
785
- log_retention_hours: Optional[pulumi.Input[int]] = None,
786
- log_retention_ms: Optional[pulumi.Input[str]] = None,
787
- log_roll_jitter_ms: Optional[pulumi.Input[str]] = None,
788
- log_segment_delete_delay_ms: Optional[pulumi.Input[int]] = None,
789
- message_max_bytes: Optional[pulumi.Input[int]] = None,
773
+ auto_create_topics_enable: Optional[pulumi.Input[_builtins.bool]] = None,
774
+ cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
775
+ group_initial_rebalance_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
776
+ group_max_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
777
+ group_min_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
778
+ log_cleaner_delete_retention_ms: Optional[pulumi.Input[_builtins.int]] = None,
779
+ log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[_builtins.str]] = None,
780
+ log_flush_interval_ms: Optional[pulumi.Input[_builtins.str]] = None,
781
+ log_index_interval_bytes: Optional[pulumi.Input[_builtins.int]] = None,
782
+ log_message_downconversion_enable: Optional[pulumi.Input[_builtins.bool]] = None,
783
+ log_message_timestamp_difference_max_ms: Optional[pulumi.Input[_builtins.str]] = None,
784
+ log_preallocate: Optional[pulumi.Input[_builtins.bool]] = None,
785
+ log_retention_bytes: Optional[pulumi.Input[_builtins.str]] = None,
786
+ log_retention_hours: Optional[pulumi.Input[_builtins.int]] = None,
787
+ log_retention_ms: Optional[pulumi.Input[_builtins.str]] = None,
788
+ log_roll_jitter_ms: Optional[pulumi.Input[_builtins.str]] = None,
789
+ log_segment_delete_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
790
+ message_max_bytes: Optional[pulumi.Input[_builtins.int]] = None,
790
791
  __props__=None):
791
792
  opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
792
793
  if not isinstance(opts, pulumi.ResourceOptions):
@@ -826,24 +827,24 @@ class DatabaseKafkaConfig(pulumi.CustomResource):
826
827
  def get(resource_name: str,
827
828
  id: pulumi.Input[str],
828
829
  opts: Optional[pulumi.ResourceOptions] = None,
829
- auto_create_topics_enable: Optional[pulumi.Input[bool]] = None,
830
- cluster_id: Optional[pulumi.Input[str]] = None,
831
- group_initial_rebalance_delay_ms: Optional[pulumi.Input[int]] = None,
832
- group_max_session_timeout_ms: Optional[pulumi.Input[int]] = None,
833
- group_min_session_timeout_ms: Optional[pulumi.Input[int]] = None,
834
- log_cleaner_delete_retention_ms: Optional[pulumi.Input[int]] = None,
835
- log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[str]] = None,
836
- log_flush_interval_ms: Optional[pulumi.Input[str]] = None,
837
- log_index_interval_bytes: Optional[pulumi.Input[int]] = None,
838
- log_message_downconversion_enable: Optional[pulumi.Input[bool]] = None,
839
- log_message_timestamp_difference_max_ms: Optional[pulumi.Input[str]] = None,
840
- log_preallocate: Optional[pulumi.Input[bool]] = None,
841
- log_retention_bytes: Optional[pulumi.Input[str]] = None,
842
- log_retention_hours: Optional[pulumi.Input[int]] = None,
843
- log_retention_ms: Optional[pulumi.Input[str]] = None,
844
- log_roll_jitter_ms: Optional[pulumi.Input[str]] = None,
845
- log_segment_delete_delay_ms: Optional[pulumi.Input[int]] = None,
846
- message_max_bytes: Optional[pulumi.Input[int]] = None) -> 'DatabaseKafkaConfig':
830
+ auto_create_topics_enable: Optional[pulumi.Input[_builtins.bool]] = None,
831
+ cluster_id: Optional[pulumi.Input[_builtins.str]] = None,
832
+ group_initial_rebalance_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
833
+ group_max_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
834
+ group_min_session_timeout_ms: Optional[pulumi.Input[_builtins.int]] = None,
835
+ log_cleaner_delete_retention_ms: Optional[pulumi.Input[_builtins.int]] = None,
836
+ log_cleaner_min_compaction_lag_ms: Optional[pulumi.Input[_builtins.str]] = None,
837
+ log_flush_interval_ms: Optional[pulumi.Input[_builtins.str]] = None,
838
+ log_index_interval_bytes: Optional[pulumi.Input[_builtins.int]] = None,
839
+ log_message_downconversion_enable: Optional[pulumi.Input[_builtins.bool]] = None,
840
+ log_message_timestamp_difference_max_ms: Optional[pulumi.Input[_builtins.str]] = None,
841
+ log_preallocate: Optional[pulumi.Input[_builtins.bool]] = None,
842
+ log_retention_bytes: Optional[pulumi.Input[_builtins.str]] = None,
843
+ log_retention_hours: Optional[pulumi.Input[_builtins.int]] = None,
844
+ log_retention_ms: Optional[pulumi.Input[_builtins.str]] = None,
845
+ log_roll_jitter_ms: Optional[pulumi.Input[_builtins.str]] = None,
846
+ log_segment_delete_delay_ms: Optional[pulumi.Input[_builtins.int]] = None,
847
+ message_max_bytes: Optional[pulumi.Input[_builtins.int]] = None) -> 'DatabaseKafkaConfig':
847
848
  """
848
849
  Get an existing DatabaseKafkaConfig resource's state with the given name, id, and optional extra
849
850
  properties used to qualify the lookup.
@@ -851,24 +852,24 @@ class DatabaseKafkaConfig(pulumi.CustomResource):
851
852
  :param str resource_name: The unique name of the resulting resource.
852
853
  :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
853
854
  :param pulumi.ResourceOptions opts: Options for the resource.
854
- :param pulumi.Input[bool] auto_create_topics_enable: Enable auto creation of topics.
855
- :param pulumi.Input[str] cluster_id: The ID of the target Kafka cluster.
856
- :param pulumi.Input[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.
857
- :param pulumi.Input[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.
858
- :param pulumi.Input[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.
859
- :param pulumi.Input[int] log_cleaner_delete_retention_ms: How long are delete records retained?
860
- :param pulumi.Input[str] 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.
861
- :param pulumi.Input[str] log_flush_interval_ms: The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
862
- :param pulumi.Input[int] log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index.
863
- :param pulumi.Input[bool] log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
864
- :param pulumi.Input[str] 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.
865
- :param pulumi.Input[bool] log_preallocate: Controls whether to preallocate a file when creating a new segment.
866
- :param pulumi.Input[str] log_retention_bytes: The maximum size of the log before deleting messages.
867
- :param pulumi.Input[int] log_retention_hours: The number of hours to keep a log file before deleting it.
868
- :param pulumi.Input[str] 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.
869
- :param pulumi.Input[str] 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.
870
- :param pulumi.Input[int] log_segment_delete_delay_ms: The amount of time to wait before deleting a file from the filesystem.
871
- :param pulumi.Input[int] message_max_bytes: The maximum size of message that the server can receive.
855
+ :param pulumi.Input[_builtins.bool] auto_create_topics_enable: Enable auto creation of topics.
856
+ :param pulumi.Input[_builtins.str] cluster_id: The ID of the target Kafka cluster.
857
+ :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.
858
+ :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.
859
+ :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.
860
+ :param pulumi.Input[_builtins.int] log_cleaner_delete_retention_ms: How long are delete records retained?
861
+ :param pulumi.Input[_builtins.str] 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.
862
+ :param pulumi.Input[_builtins.str] log_flush_interval_ms: The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
863
+ :param pulumi.Input[_builtins.int] log_index_interval_bytes: The interval with which Kafka adds an entry to the offset index.
864
+ :param pulumi.Input[_builtins.bool] log_message_downconversion_enable: This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
865
+ :param pulumi.Input[_builtins.str] 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.
866
+ :param pulumi.Input[_builtins.bool] log_preallocate: Controls whether to preallocate a file when creating a new segment.
867
+ :param pulumi.Input[_builtins.str] log_retention_bytes: The maximum size of the log before deleting messages.
868
+ :param pulumi.Input[_builtins.int] log_retention_hours: The number of hours to keep a log file before deleting it.
869
+ :param pulumi.Input[_builtins.str] 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.
870
+ :param pulumi.Input[_builtins.str] 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.
871
+ :param pulumi.Input[_builtins.int] log_segment_delete_delay_ms: The amount of time to wait before deleting a file from the filesystem.
872
+ :param pulumi.Input[_builtins.int] message_max_bytes: The maximum size of message that the server can receive.
872
873
  """
873
874
  opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
874
875
 
@@ -894,145 +895,145 @@ class DatabaseKafkaConfig(pulumi.CustomResource):
894
895
  __props__.__dict__["message_max_bytes"] = message_max_bytes
895
896
  return DatabaseKafkaConfig(resource_name, opts=opts, __props__=__props__)
896
897
 
897
- @property
898
+ @_builtins.property
898
899
  @pulumi.getter(name="autoCreateTopicsEnable")
899
- def auto_create_topics_enable(self) -> pulumi.Output[bool]:
900
+ def auto_create_topics_enable(self) -> pulumi.Output[_builtins.bool]:
900
901
  """
901
902
  Enable auto creation of topics.
902
903
  """
903
904
  return pulumi.get(self, "auto_create_topics_enable")
904
905
 
905
- @property
906
+ @_builtins.property
906
907
  @pulumi.getter(name="clusterId")
907
- def cluster_id(self) -> pulumi.Output[str]:
908
+ def cluster_id(self) -> pulumi.Output[_builtins.str]:
908
909
  """
909
910
  The ID of the target Kafka cluster.
910
911
  """
911
912
  return pulumi.get(self, "cluster_id")
912
913
 
913
- @property
914
+ @_builtins.property
914
915
  @pulumi.getter(name="groupInitialRebalanceDelayMs")
915
- def group_initial_rebalance_delay_ms(self) -> pulumi.Output[int]:
916
+ def group_initial_rebalance_delay_ms(self) -> pulumi.Output[_builtins.int]:
916
917
  """
917
918
  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.
918
919
  """
919
920
  return pulumi.get(self, "group_initial_rebalance_delay_ms")
920
921
 
921
- @property
922
+ @_builtins.property
922
923
  @pulumi.getter(name="groupMaxSessionTimeoutMs")
923
- def group_max_session_timeout_ms(self) -> pulumi.Output[int]:
924
+ def group_max_session_timeout_ms(self) -> pulumi.Output[_builtins.int]:
924
925
  """
925
926
  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.
926
927
  """
927
928
  return pulumi.get(self, "group_max_session_timeout_ms")
928
929
 
929
- @property
930
+ @_builtins.property
930
931
  @pulumi.getter(name="groupMinSessionTimeoutMs")
931
- def group_min_session_timeout_ms(self) -> pulumi.Output[int]:
932
+ def group_min_session_timeout_ms(self) -> pulumi.Output[_builtins.int]:
932
933
  """
933
934
  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.
934
935
  """
935
936
  return pulumi.get(self, "group_min_session_timeout_ms")
936
937
 
937
- @property
938
+ @_builtins.property
938
939
  @pulumi.getter(name="logCleanerDeleteRetentionMs")
939
- def log_cleaner_delete_retention_ms(self) -> pulumi.Output[int]:
940
+ def log_cleaner_delete_retention_ms(self) -> pulumi.Output[_builtins.int]:
940
941
  """
941
942
  How long are delete records retained?
942
943
  """
943
944
  return pulumi.get(self, "log_cleaner_delete_retention_ms")
944
945
 
945
- @property
946
+ @_builtins.property
946
947
  @pulumi.getter(name="logCleanerMinCompactionLagMs")
947
- def log_cleaner_min_compaction_lag_ms(self) -> pulumi.Output[str]:
948
+ def log_cleaner_min_compaction_lag_ms(self) -> pulumi.Output[_builtins.str]:
948
949
  """
949
950
  The minimum time a message will remain uncompacted in the log. Only applicable for logs that are being compacted.
950
951
  """
951
952
  return pulumi.get(self, "log_cleaner_min_compaction_lag_ms")
952
953
 
953
- @property
954
+ @_builtins.property
954
955
  @pulumi.getter(name="logFlushIntervalMs")
955
- def log_flush_interval_ms(self) -> pulumi.Output[str]:
956
+ def log_flush_interval_ms(self) -> pulumi.Output[_builtins.str]:
956
957
  """
957
958
  The maximum time in ms that a message in any topic is kept in memory before flushed to disk. If not set, the value in log.flush.scheduler.interval.ms is used.
958
959
  """
959
960
  return pulumi.get(self, "log_flush_interval_ms")
960
961
 
961
- @property
962
+ @_builtins.property
962
963
  @pulumi.getter(name="logIndexIntervalBytes")
963
- def log_index_interval_bytes(self) -> pulumi.Output[int]:
964
+ def log_index_interval_bytes(self) -> pulumi.Output[_builtins.int]:
964
965
  """
965
966
  The interval with which Kafka adds an entry to the offset index.
966
967
  """
967
968
  return pulumi.get(self, "log_index_interval_bytes")
968
969
 
969
- @property
970
+ @_builtins.property
970
971
  @pulumi.getter(name="logMessageDownconversionEnable")
971
- def log_message_downconversion_enable(self) -> pulumi.Output[bool]:
972
+ def log_message_downconversion_enable(self) -> pulumi.Output[_builtins.bool]:
972
973
  """
973
974
  This configuration controls whether down-conversion of message formats is enabled to satisfy consume requests.
974
975
  """
975
976
  return pulumi.get(self, "log_message_downconversion_enable")
976
977
 
977
- @property
978
+ @_builtins.property
978
979
  @pulumi.getter(name="logMessageTimestampDifferenceMaxMs")
979
- def log_message_timestamp_difference_max_ms(self) -> pulumi.Output[str]:
980
+ def log_message_timestamp_difference_max_ms(self) -> pulumi.Output[_builtins.str]:
980
981
  """
981
982
  The maximum difference allowed between the timestamp when a broker receives a message and the timestamp specified in the message.
982
983
  """
983
984
  return pulumi.get(self, "log_message_timestamp_difference_max_ms")
984
985
 
985
- @property
986
+ @_builtins.property
986
987
  @pulumi.getter(name="logPreallocate")
987
- def log_preallocate(self) -> pulumi.Output[bool]:
988
+ def log_preallocate(self) -> pulumi.Output[_builtins.bool]:
988
989
  """
989
990
  Controls whether to preallocate a file when creating a new segment.
990
991
  """
991
992
  return pulumi.get(self, "log_preallocate")
992
993
 
993
- @property
994
+ @_builtins.property
994
995
  @pulumi.getter(name="logRetentionBytes")
995
- def log_retention_bytes(self) -> pulumi.Output[str]:
996
+ def log_retention_bytes(self) -> pulumi.Output[_builtins.str]:
996
997
  """
997
998
  The maximum size of the log before deleting messages.
998
999
  """
999
1000
  return pulumi.get(self, "log_retention_bytes")
1000
1001
 
1001
- @property
1002
+ @_builtins.property
1002
1003
  @pulumi.getter(name="logRetentionHours")
1003
- def log_retention_hours(self) -> pulumi.Output[int]:
1004
+ def log_retention_hours(self) -> pulumi.Output[_builtins.int]:
1004
1005
  """
1005
1006
  The number of hours to keep a log file before deleting it.
1006
1007
  """
1007
1008
  return pulumi.get(self, "log_retention_hours")
1008
1009
 
1009
- @property
1010
+ @_builtins.property
1010
1011
  @pulumi.getter(name="logRetentionMs")
1011
- def log_retention_ms(self) -> pulumi.Output[str]:
1012
+ def log_retention_ms(self) -> pulumi.Output[_builtins.str]:
1012
1013
  """
1013
1014
  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.
1014
1015
  """
1015
1016
  return pulumi.get(self, "log_retention_ms")
1016
1017
 
1017
- @property
1018
+ @_builtins.property
1018
1019
  @pulumi.getter(name="logRollJitterMs")
1019
- def log_roll_jitter_ms(self) -> pulumi.Output[str]:
1020
+ def log_roll_jitter_ms(self) -> pulumi.Output[_builtins.str]:
1020
1021
  """
1021
1022
  The maximum jitter to subtract from logRollTimeMillis (in milliseconds). If not set, the value in log.roll.jitter.hours is used.
1022
1023
  """
1023
1024
  return pulumi.get(self, "log_roll_jitter_ms")
1024
1025
 
1025
- @property
1026
+ @_builtins.property
1026
1027
  @pulumi.getter(name="logSegmentDeleteDelayMs")
1027
- def log_segment_delete_delay_ms(self) -> pulumi.Output[int]:
1028
+ def log_segment_delete_delay_ms(self) -> pulumi.Output[_builtins.int]:
1028
1029
  """
1029
1030
  The amount of time to wait before deleting a file from the filesystem.
1030
1031
  """
1031
1032
  return pulumi.get(self, "log_segment_delete_delay_ms")
1032
1033
 
1033
- @property
1034
+ @_builtins.property
1034
1035
  @pulumi.getter(name="messageMaxBytes")
1035
- def message_max_bytes(self) -> pulumi.Output[int]:
1036
+ def message_max_bytes(self) -> pulumi.Output[_builtins.int]:
1036
1037
  """
1037
1038
  The maximum size of message that the server can receive.
1038
1039
  """