pulumi-linode 5.2.0a1752905257__py3-none-any.whl → 5.2.0a1753397983__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.

Potentially problematic release.

This version of pulumi-linode might be problematic. Click here for more details.

Files changed (125) hide show
  1. pulumi_linode/__init__.py +1 -1
  2. pulumi_linode/_inputs.py +5169 -5170
  3. pulumi_linode/account_settings.py +70 -71
  4. pulumi_linode/config/__init__.py +1 -1
  5. pulumi_linode/config/__init__.pyi +1 -2
  6. pulumi_linode/config/vars.py +21 -22
  7. pulumi_linode/database_access_controls.py +52 -53
  8. pulumi_linode/database_mysql.py +247 -248
  9. pulumi_linode/database_mysql_v2.py +782 -783
  10. pulumi_linode/database_postgresql.py +273 -274
  11. pulumi_linode/database_postgresql_v2.py +1105 -1106
  12. pulumi_linode/domain.py +222 -223
  13. pulumi_linode/domain_record.py +188 -189
  14. pulumi_linode/firewall.py +155 -156
  15. pulumi_linode/firewall_device.py +70 -71
  16. pulumi_linode/get_account.py +33 -34
  17. pulumi_linode/get_account_availabilities.py +5 -6
  18. pulumi_linode/get_account_availability.py +13 -14
  19. pulumi_linode/get_account_login.py +17 -18
  20. pulumi_linode/get_account_logins.py +5 -6
  21. pulumi_linode/get_account_settings.py +13 -14
  22. pulumi_linode/get_child_account.py +37 -38
  23. pulumi_linode/get_child_accounts.py +5 -6
  24. pulumi_linode/get_database_backups.py +35 -36
  25. pulumi_linode/get_database_engines.py +23 -24
  26. pulumi_linode/get_database_mysql.py +52 -53
  27. pulumi_linode/get_database_mysql_backups.py +29 -30
  28. pulumi_linode/get_database_mysql_config.py +5 -6
  29. pulumi_linode/get_database_mysql_v2.py +115 -116
  30. pulumi_linode/get_database_postgresql.py +56 -57
  31. pulumi_linode/get_database_postgresql_config.py +7 -8
  32. pulumi_linode/get_database_postgresql_v2.py +153 -154
  33. pulumi_linode/get_databases.py +17 -18
  34. pulumi_linode/get_domain.py +37 -38
  35. pulumi_linode/get_domain_record.py +37 -38
  36. pulumi_linode/get_domain_zonefile.py +11 -12
  37. pulumi_linode/get_domains.py +17 -18
  38. pulumi_linode/get_firewall.py +30 -31
  39. pulumi_linode/get_firewalls.py +17 -18
  40. pulumi_linode/get_image.py +36 -37
  41. pulumi_linode/get_images.py +23 -24
  42. pulumi_linode/get_instance_backups.py +12 -13
  43. pulumi_linode/get_instance_networking.py +11 -12
  44. pulumi_linode/get_instance_type.py +30 -31
  45. pulumi_linode/get_instance_types.py +17 -18
  46. pulumi_linode/get_instances.py +17 -18
  47. pulumi_linode/get_ipv6_range.py +17 -18
  48. pulumi_linode/get_ipv6_ranges.py +5 -6
  49. pulumi_linode/get_kernel.py +23 -24
  50. pulumi_linode/get_kernels.py +17 -18
  51. pulumi_linode/get_linode_object_storage_bucket.py +33 -34
  52. pulumi_linode/get_lke_cluster.py +33 -34
  53. pulumi_linode/get_lke_clusters.py +17 -18
  54. pulumi_linode/get_lke_types.py +17 -18
  55. pulumi_linode/get_lke_version.py +13 -14
  56. pulumi_linode/get_lke_versions.py +10 -11
  57. pulumi_linode/get_nb_types.py +13 -14
  58. pulumi_linode/get_network_transfer_prices.py +17 -18
  59. pulumi_linode/get_networking_ip.py +28 -29
  60. pulumi_linode/get_networking_ips.py +17 -18
  61. pulumi_linode/get_node_balancer.py +29 -30
  62. pulumi_linode/get_node_balancer_config.py +48 -49
  63. pulumi_linode/get_node_balancer_node.py +29 -30
  64. pulumi_linode/get_nodebalancer_configs.py +23 -24
  65. pulumi_linode/get_nodebalancers.py +17 -18
  66. pulumi_linode/get_object_storage_cluster.py +15 -16
  67. pulumi_linode/get_object_storage_endpoints.py +17 -18
  68. pulumi_linode/get_object_storage_quota.py +22 -23
  69. pulumi_linode/get_object_storage_quotas.py +5 -6
  70. pulumi_linode/get_placement_group.py +19 -20
  71. pulumi_linode/get_placement_groups.py +13 -14
  72. pulumi_linode/get_profile.py +22 -23
  73. pulumi_linode/get_region.py +19 -20
  74. pulumi_linode/get_regions.py +5 -6
  75. pulumi_linode/get_ssh_key.py +17 -18
  76. pulumi_linode/get_sshkeys.py +17 -18
  77. pulumi_linode/get_stack_script.py +32 -33
  78. pulumi_linode/get_stack_scripts.py +23 -24
  79. pulumi_linode/get_user.py +35 -36
  80. pulumi_linode/get_users.py +17 -18
  81. pulumi_linode/get_vlans.py +17 -18
  82. pulumi_linode/get_volume.py +27 -28
  83. pulumi_linode/get_volume_types.py +17 -18
  84. pulumi_linode/get_volumes.py +17 -18
  85. pulumi_linode/get_vpc.py +17 -18
  86. pulumi_linode/get_vpc_ips.py +11 -12
  87. pulumi_linode/get_vpc_subnet.py +22 -23
  88. pulumi_linode/get_vpc_subnets.py +11 -12
  89. pulumi_linode/get_vpcs.py +5 -6
  90. pulumi_linode/image.py +292 -293
  91. pulumi_linode/instance.py +520 -521
  92. pulumi_linode/instance_config.py +166 -167
  93. pulumi_linode/instance_disk.py +210 -211
  94. pulumi_linode/instance_ip.py +125 -126
  95. pulumi_linode/instance_shared_ips.py +35 -36
  96. pulumi_linode/ipv6_range.py +88 -89
  97. pulumi_linode/lke_cluster.py +162 -163
  98. pulumi_linode/lke_node_pool.py +137 -138
  99. pulumi_linode/networking_ip.py +133 -134
  100. pulumi_linode/networking_ip_assignment.py +21 -22
  101. pulumi_linode/node_balancer.py +152 -153
  102. pulumi_linode/node_balancer_config.py +319 -320
  103. pulumi_linode/node_balancer_node.py +112 -113
  104. pulumi_linode/object_storage_bucket.py +195 -196
  105. pulumi_linode/object_storage_key.py +67 -68
  106. pulumi_linode/object_storage_object.py +350 -351
  107. pulumi_linode/outputs.py +5305 -5306
  108. pulumi_linode/placement_group.py +80 -81
  109. pulumi_linode/placement_group_assignment.py +48 -49
  110. pulumi_linode/provider.py +180 -181
  111. pulumi_linode/pulumi-plugin.json +1 -1
  112. pulumi_linode/rdns.py +55 -56
  113. pulumi_linode/reserved_ip_assignment.py +142 -143
  114. pulumi_linode/ssh_key.py +44 -45
  115. pulumi_linode/stack_script.py +159 -160
  116. pulumi_linode/token.py +70 -71
  117. pulumi_linode/user.py +112 -113
  118. pulumi_linode/volume.py +141 -142
  119. pulumi_linode/vpc.py +70 -71
  120. pulumi_linode/vpc_subnet.py +72 -73
  121. {pulumi_linode-5.2.0a1752905257.dist-info → pulumi_linode-5.2.0a1753397983.dist-info}/METADATA +1 -1
  122. pulumi_linode-5.2.0a1753397983.dist-info/RECORD +126 -0
  123. pulumi_linode-5.2.0a1752905257.dist-info/RECORD +0 -126
  124. {pulumi_linode-5.2.0a1752905257.dist-info → pulumi_linode-5.2.0a1753397983.dist-info}/WHEEL +0 -0
  125. {pulumi_linode-5.2.0a1752905257.dist-info → pulumi_linode-5.2.0a1753397983.dist-info}/top_level.txt +0 -0
pulumi_linode/database_postgresql.py CHANGED
@@ -2,8 +2,7 @@
2
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 builtins
6
- import copy
5
+ import builtins as _builtins
7
6
  import warnings
8
7
  import sys
9
8
  import pulumi
@@ -22,39 +21,39 @@ __all__ = ['DatabasePostgresqlArgs', 'DatabasePostgresql']
22
21
  @pulumi.input_type
23
22
  class DatabasePostgresqlArgs:
24
23
  def __init__(__self__, *,
25
- engine_id: pulumi.Input[builtins.str],
26
- label: pulumi.Input[builtins.str],
27
- region: pulumi.Input[builtins.str],
28
- type: pulumi.Input[builtins.str],
29
- allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
30
- cluster_size: Optional[pulumi.Input[builtins.int]] = None,
31
- encrypted: Optional[pulumi.Input[builtins.bool]] = None,
32
- replication_commit_type: Optional[pulumi.Input[builtins.str]] = None,
33
- replication_type: Optional[pulumi.Input[builtins.str]] = None,
34
- ssl_connection: Optional[pulumi.Input[builtins.bool]] = None,
24
+ engine_id: pulumi.Input[_builtins.str],
25
+ label: pulumi.Input[_builtins.str],
26
+ region: pulumi.Input[_builtins.str],
27
+ type: pulumi.Input[_builtins.str],
28
+ allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
29
+ cluster_size: Optional[pulumi.Input[_builtins.int]] = None,
30
+ encrypted: Optional[pulumi.Input[_builtins.bool]] = None,
31
+ replication_commit_type: Optional[pulumi.Input[_builtins.str]] = None,
32
+ replication_type: Optional[pulumi.Input[_builtins.str]] = None,
33
+ ssl_connection: Optional[pulumi.Input[_builtins.bool]] = None,
35
34
  updates: Optional[pulumi.Input['DatabasePostgresqlUpdatesArgs']] = None):
36
35
  """
37
36
  The set of arguments for constructing a DatabasePostgresql resource.
38
- :param pulumi.Input[builtins.str] engine_id: The Managed Database engine in engine/version format. (e.g. `postgresql/13.2`)
39
- :param pulumi.Input[builtins.str] label: A unique, user-defined string referring to the Managed Database.
40
- :param pulumi.Input[builtins.str] region: The region to use for the Managed Database.
41
- :param pulumi.Input[builtins.str] type: The Linode Instance type used for the nodes of the Managed Database instance.
37
+ :param pulumi.Input[_builtins.str] engine_id: The Managed Database engine in engine/version format. (e.g. `postgresql/13.2`)
38
+ :param pulumi.Input[_builtins.str] label: A unique, user-defined string referring to the Managed Database.
39
+ :param pulumi.Input[_builtins.str] region: The region to use for the Managed Database.
40
+ :param pulumi.Input[_builtins.str] type: The Linode Instance type used for the nodes of the Managed Database instance.
42
41
 
43
42
  - - -
44
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] allow_lists: A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
45
- :param pulumi.Input[builtins.int] cluster_size: The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
46
- :param pulumi.Input[builtins.bool] encrypted: Whether the Managed Databases is encrypted. (default `false`)
47
- :param pulumi.Input[builtins.str] replication_commit_type: The synchronization level of the replicating server. (`on`, `local`, `remote_write`, `remote_apply`, `off`; default `off`)
43
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allow_lists: A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
44
+ :param pulumi.Input[_builtins.int] cluster_size: The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
45
+ :param pulumi.Input[_builtins.bool] encrypted: Whether the Managed Databases is encrypted. (default `false`)
46
+ :param pulumi.Input[_builtins.str] replication_commit_type: The synchronization level of the replicating server. (`on`, `local`, `remote_write`, `remote_apply`, `off`; default `off`)
48
47
 
49
48
  * Must be `local` or `off` for the `asynch` replication type.
50
49
 
51
50
  * Must be `on`, `remote_write`, or `remote_apply` for the `semi_synch` replication type.
52
- :param pulumi.Input[builtins.str] replication_type: The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
51
+ :param pulumi.Input[_builtins.str] replication_type: The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
53
52
 
54
53
  * Must be `none` for a single node cluster.
55
54
 
56
55
  * Must be `asynch` or `semi_synch` for a high availability cluster.
57
- :param pulumi.Input[builtins.bool] ssl_connection: Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
56
+ :param pulumi.Input[_builtins.bool] ssl_connection: Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
58
57
 
59
58
  * `updates` - (Optional) Configuration settings for automated patch update maintenance for the Managed Database.
60
59
  :param pulumi.Input['DatabasePostgresqlUpdatesArgs'] updates: Configuration settings for automated patch update maintenance for the Managed Database.
@@ -78,45 +77,45 @@ class DatabasePostgresqlArgs:
78
77
  if updates is not None:
79
78
  pulumi.set(__self__, "updates", updates)
80
79
 
81
- @property
80
+ @_builtins.property
82
81
  @pulumi.getter(name="engineId")
83
- def engine_id(self) -> pulumi.Input[builtins.str]:
82
+ def engine_id(self) -> pulumi.Input[_builtins.str]:
84
83
  """
85
84
  The Managed Database engine in engine/version format. (e.g. `postgresql/13.2`)
86
85
  """
87
86
  return pulumi.get(self, "engine_id")
88
87
 
89
88
  @engine_id.setter
90
- def engine_id(self, value: pulumi.Input[builtins.str]):
89
+ def engine_id(self, value: pulumi.Input[_builtins.str]):
91
90
  pulumi.set(self, "engine_id", value)
92
91
 
93
- @property
92
+ @_builtins.property
94
93
  @pulumi.getter
95
- def label(self) -> pulumi.Input[builtins.str]:
94
+ def label(self) -> pulumi.Input[_builtins.str]:
96
95
  """
97
96
  A unique, user-defined string referring to the Managed Database.
98
97
  """
99
98
  return pulumi.get(self, "label")
100
99
 
101
100
  @label.setter
102
- def label(self, value: pulumi.Input[builtins.str]):
101
+ def label(self, value: pulumi.Input[_builtins.str]):
103
102
  pulumi.set(self, "label", value)
104
103
 
105
- @property
104
+ @_builtins.property
106
105
  @pulumi.getter
107
- def region(self) -> pulumi.Input[builtins.str]:
106
+ def region(self) -> pulumi.Input[_builtins.str]:
108
107
  """
109
108
  The region to use for the Managed Database.
110
109
  """
111
110
  return pulumi.get(self, "region")
112
111
 
113
112
  @region.setter
114
- def region(self, value: pulumi.Input[builtins.str]):
113
+ def region(self, value: pulumi.Input[_builtins.str]):
115
114
  pulumi.set(self, "region", value)
116
115
 
117
- @property
116
+ @_builtins.property
118
117
  @pulumi.getter
119
- def type(self) -> pulumi.Input[builtins.str]:
118
+ def type(self) -> pulumi.Input[_builtins.str]:
120
119
  """
121
120
  The Linode Instance type used for the nodes of the Managed Database instance.
122
121
 
@@ -125,48 +124,48 @@ class DatabasePostgresqlArgs:
125
124
  return pulumi.get(self, "type")
126
125
 
127
126
  @type.setter
128
- def type(self, value: pulumi.Input[builtins.str]):
127
+ def type(self, value: pulumi.Input[_builtins.str]):
129
128
  pulumi.set(self, "type", value)
130
129
 
131
- @property
130
+ @_builtins.property
132
131
  @pulumi.getter(name="allowLists")
133
- def allow_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
132
+ def allow_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
134
133
  """
135
134
  A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
136
135
  """
137
136
  return pulumi.get(self, "allow_lists")
138
137
 
139
138
  @allow_lists.setter
140
- def allow_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
139
+ def allow_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
141
140
  pulumi.set(self, "allow_lists", value)
142
141
 
143
- @property
142
+ @_builtins.property
144
143
  @pulumi.getter(name="clusterSize")
145
- def cluster_size(self) -> Optional[pulumi.Input[builtins.int]]:
144
+ def cluster_size(self) -> Optional[pulumi.Input[_builtins.int]]:
146
145
  """
147
146
  The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
148
147
  """
149
148
  return pulumi.get(self, "cluster_size")
150
149
 
151
150
  @cluster_size.setter
152
- def cluster_size(self, value: Optional[pulumi.Input[builtins.int]]):
151
+ def cluster_size(self, value: Optional[pulumi.Input[_builtins.int]]):
153
152
  pulumi.set(self, "cluster_size", value)
154
153
 
155
- @property
154
+ @_builtins.property
156
155
  @pulumi.getter
157
- def encrypted(self) -> Optional[pulumi.Input[builtins.bool]]:
156
+ def encrypted(self) -> Optional[pulumi.Input[_builtins.bool]]:
158
157
  """
159
158
  Whether the Managed Databases is encrypted. (default `false`)
160
159
  """
161
160
  return pulumi.get(self, "encrypted")
162
161
 
163
162
  @encrypted.setter
164
- def encrypted(self, value: Optional[pulumi.Input[builtins.bool]]):
163
+ def encrypted(self, value: Optional[pulumi.Input[_builtins.bool]]):
165
164
  pulumi.set(self, "encrypted", value)
166
165
 
167
- @property
166
+ @_builtins.property
168
167
  @pulumi.getter(name="replicationCommitType")
169
- def replication_commit_type(self) -> Optional[pulumi.Input[builtins.str]]:
168
+ def replication_commit_type(self) -> Optional[pulumi.Input[_builtins.str]]:
170
169
  """
171
170
  The synchronization level of the replicating server. (`on`, `local`, `remote_write`, `remote_apply`, `off`; default `off`)
172
171
 
@@ -177,12 +176,12 @@ class DatabasePostgresqlArgs:
177
176
  return pulumi.get(self, "replication_commit_type")
178
177
 
179
178
  @replication_commit_type.setter
180
- def replication_commit_type(self, value: Optional[pulumi.Input[builtins.str]]):
179
+ def replication_commit_type(self, value: Optional[pulumi.Input[_builtins.str]]):
181
180
  pulumi.set(self, "replication_commit_type", value)
182
181
 
183
- @property
182
+ @_builtins.property
184
183
  @pulumi.getter(name="replicationType")
185
- def replication_type(self) -> Optional[pulumi.Input[builtins.str]]:
184
+ def replication_type(self) -> Optional[pulumi.Input[_builtins.str]]:
186
185
  """
187
186
  The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
188
187
 
@@ -193,12 +192,12 @@ class DatabasePostgresqlArgs:
193
192
  return pulumi.get(self, "replication_type")
194
193
 
195
194
  @replication_type.setter
196
- def replication_type(self, value: Optional[pulumi.Input[builtins.str]]):
195
+ def replication_type(self, value: Optional[pulumi.Input[_builtins.str]]):
197
196
  pulumi.set(self, "replication_type", value)
198
197
 
199
- @property
198
+ @_builtins.property
200
199
  @pulumi.getter(name="sslConnection")
201
- def ssl_connection(self) -> Optional[pulumi.Input[builtins.bool]]:
200
+ def ssl_connection(self) -> Optional[pulumi.Input[_builtins.bool]]:
202
201
  """
203
202
  Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
204
203
 
@@ -207,10 +206,10 @@ class DatabasePostgresqlArgs:
207
206
  return pulumi.get(self, "ssl_connection")
208
207
 
209
208
  @ssl_connection.setter
210
- def ssl_connection(self, value: Optional[pulumi.Input[builtins.bool]]):
209
+ def ssl_connection(self, value: Optional[pulumi.Input[_builtins.bool]]):
211
210
  pulumi.set(self, "ssl_connection", value)
212
211
 
213
- @property
212
+ @_builtins.property
214
213
  @pulumi.getter
215
214
  def updates(self) -> Optional[pulumi.Input['DatabasePostgresqlUpdatesArgs']]:
216
215
  """
@@ -226,64 +225,64 @@ class DatabasePostgresqlArgs:
226
225
  @pulumi.input_type
227
226
  class _DatabasePostgresqlState:
228
227
  def __init__(__self__, *,
229
- allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
230
- ca_cert: Optional[pulumi.Input[builtins.str]] = None,
231
- cluster_size: Optional[pulumi.Input[builtins.int]] = None,
232
- created: Optional[pulumi.Input[builtins.str]] = None,
233
- encrypted: Optional[pulumi.Input[builtins.bool]] = None,
234
- engine: Optional[pulumi.Input[builtins.str]] = None,
235
- engine_id: Optional[pulumi.Input[builtins.str]] = None,
236
- host_primary: Optional[pulumi.Input[builtins.str]] = None,
237
- host_secondary: Optional[pulumi.Input[builtins.str]] = None,
238
- label: Optional[pulumi.Input[builtins.str]] = None,
239
- port: Optional[pulumi.Input[builtins.int]] = None,
240
- region: Optional[pulumi.Input[builtins.str]] = None,
241
- replication_commit_type: Optional[pulumi.Input[builtins.str]] = None,
242
- replication_type: Optional[pulumi.Input[builtins.str]] = None,
243
- root_password: Optional[pulumi.Input[builtins.str]] = None,
244
- root_username: Optional[pulumi.Input[builtins.str]] = None,
245
- ssl_connection: Optional[pulumi.Input[builtins.bool]] = None,
246
- status: Optional[pulumi.Input[builtins.str]] = None,
247
- type: Optional[pulumi.Input[builtins.str]] = None,
248
- updated: Optional[pulumi.Input[builtins.str]] = None,
228
+ allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
229
+ ca_cert: Optional[pulumi.Input[_builtins.str]] = None,
230
+ cluster_size: Optional[pulumi.Input[_builtins.int]] = None,
231
+ created: Optional[pulumi.Input[_builtins.str]] = None,
232
+ encrypted: Optional[pulumi.Input[_builtins.bool]] = None,
233
+ engine: Optional[pulumi.Input[_builtins.str]] = None,
234
+ engine_id: Optional[pulumi.Input[_builtins.str]] = None,
235
+ host_primary: Optional[pulumi.Input[_builtins.str]] = None,
236
+ host_secondary: Optional[pulumi.Input[_builtins.str]] = None,
237
+ label: Optional[pulumi.Input[_builtins.str]] = None,
238
+ port: Optional[pulumi.Input[_builtins.int]] = None,
239
+ region: Optional[pulumi.Input[_builtins.str]] = None,
240
+ replication_commit_type: Optional[pulumi.Input[_builtins.str]] = None,
241
+ replication_type: Optional[pulumi.Input[_builtins.str]] = None,
242
+ root_password: Optional[pulumi.Input[_builtins.str]] = None,
243
+ root_username: Optional[pulumi.Input[_builtins.str]] = None,
244
+ ssl_connection: Optional[pulumi.Input[_builtins.bool]] = None,
245
+ status: Optional[pulumi.Input[_builtins.str]] = None,
246
+ type: Optional[pulumi.Input[_builtins.str]] = None,
247
+ updated: Optional[pulumi.Input[_builtins.str]] = None,
249
248
  updates: Optional[pulumi.Input['DatabasePostgresqlUpdatesArgs']] = None,
250
- version: Optional[pulumi.Input[builtins.str]] = None):
249
+ version: Optional[pulumi.Input[_builtins.str]] = None):
251
250
  """
252
251
  Input properties used for looking up and filtering DatabasePostgresql resources.
253
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] allow_lists: A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
254
- :param pulumi.Input[builtins.str] ca_cert: The base64-encoded SSL CA certificate for the Managed Database instance.
255
- :param pulumi.Input[builtins.int] cluster_size: The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
256
- :param pulumi.Input[builtins.str] created: When this Managed Database was created.
257
- :param pulumi.Input[builtins.bool] encrypted: Whether the Managed Databases is encrypted. (default `false`)
258
- :param pulumi.Input[builtins.str] engine: The Managed Database engine. (e.g. `postgresql`)
259
- :param pulumi.Input[builtins.str] engine_id: The Managed Database engine in engine/version format. (e.g. `postgresql/13.2`)
260
- :param pulumi.Input[builtins.str] host_primary: The primary host for the Managed Database.
261
- :param pulumi.Input[builtins.str] host_secondary: The secondary/private network host for the Managed Database.
262
- :param pulumi.Input[builtins.str] label: A unique, user-defined string referring to the Managed Database.
263
- :param pulumi.Input[builtins.int] port: The access port for this Managed Database.
264
- :param pulumi.Input[builtins.str] region: The region to use for the Managed Database.
265
- :param pulumi.Input[builtins.str] replication_commit_type: The synchronization level of the replicating server. (`on`, `local`, `remote_write`, `remote_apply`, `off`; default `off`)
252
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allow_lists: A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
253
+ :param pulumi.Input[_builtins.str] ca_cert: The base64-encoded SSL CA certificate for the Managed Database instance.
254
+ :param pulumi.Input[_builtins.int] cluster_size: The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
255
+ :param pulumi.Input[_builtins.str] created: When this Managed Database was created.
256
+ :param pulumi.Input[_builtins.bool] encrypted: Whether the Managed Databases is encrypted. (default `false`)
257
+ :param pulumi.Input[_builtins.str] engine: The Managed Database engine. (e.g. `postgresql`)
258
+ :param pulumi.Input[_builtins.str] engine_id: The Managed Database engine in engine/version format. (e.g. `postgresql/13.2`)
259
+ :param pulumi.Input[_builtins.str] host_primary: The primary host for the Managed Database.
260
+ :param pulumi.Input[_builtins.str] host_secondary: The secondary/private network host for the Managed Database.
261
+ :param pulumi.Input[_builtins.str] label: A unique, user-defined string referring to the Managed Database.
262
+ :param pulumi.Input[_builtins.int] port: The access port for this Managed Database.
263
+ :param pulumi.Input[_builtins.str] region: The region to use for the Managed Database.
264
+ :param pulumi.Input[_builtins.str] replication_commit_type: The synchronization level of the replicating server. (`on`, `local`, `remote_write`, `remote_apply`, `off`; default `off`)
266
265
 
267
266
  * Must be `local` or `off` for the `asynch` replication type.
268
267
 
269
268
  * Must be `on`, `remote_write`, or `remote_apply` for the `semi_synch` replication type.
270
- :param pulumi.Input[builtins.str] replication_type: The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
269
+ :param pulumi.Input[_builtins.str] replication_type: The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
271
270
 
272
271
  * Must be `none` for a single node cluster.
273
272
 
274
273
  * Must be `asynch` or `semi_synch` for a high availability cluster.
275
- :param pulumi.Input[builtins.str] root_password: The randomly-generated root password for the Managed Database instance.
276
- :param pulumi.Input[builtins.str] root_username: The root username for the Managed Database instance.
277
- :param pulumi.Input[builtins.bool] ssl_connection: Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
274
+ :param pulumi.Input[_builtins.str] root_password: The randomly-generated root password for the Managed Database instance.
275
+ :param pulumi.Input[_builtins.str] root_username: The root username for the Managed Database instance.
276
+ :param pulumi.Input[_builtins.bool] ssl_connection: Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
278
277
 
279
278
  * `updates` - (Optional) Configuration settings for automated patch update maintenance for the Managed Database.
280
- :param pulumi.Input[builtins.str] status: The operating status of the Managed Database.
281
- :param pulumi.Input[builtins.str] type: The Linode Instance type used for the nodes of the Managed Database instance.
279
+ :param pulumi.Input[_builtins.str] status: The operating status of the Managed Database.
280
+ :param pulumi.Input[_builtins.str] type: The Linode Instance type used for the nodes of the Managed Database instance.
282
281
 
283
282
  - - -
284
- :param pulumi.Input[builtins.str] updated: When this Managed Database was last updated.
283
+ :param pulumi.Input[_builtins.str] updated: When this Managed Database was last updated.
285
284
  :param pulumi.Input['DatabasePostgresqlUpdatesArgs'] updates: Configuration settings for automated patch update maintenance for the Managed Database.
286
- :param pulumi.Input[builtins.str] version: The Managed Database engine version. (e.g. `13.2`)
285
+ :param pulumi.Input[_builtins.str] version: The Managed Database engine version. (e.g. `13.2`)
287
286
  """
288
287
  if allow_lists is not None:
289
288
  pulumi.set(__self__, "allow_lists", allow_lists)
@@ -330,153 +329,153 @@ class _DatabasePostgresqlState:
330
329
  if version is not None:
331
330
  pulumi.set(__self__, "version", version)
332
331
 
333
- @property
332
+ @_builtins.property
334
333
  @pulumi.getter(name="allowLists")
335
- def allow_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
334
+ def allow_lists(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
336
335
  """
337
336
  A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
338
337
  """
339
338
  return pulumi.get(self, "allow_lists")
340
339
 
341
340
  @allow_lists.setter
342
- def allow_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
341
+ def allow_lists(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
343
342
  pulumi.set(self, "allow_lists", value)
344
343
 
345
- @property
344
+ @_builtins.property
346
345
  @pulumi.getter(name="caCert")
347
- def ca_cert(self) -> Optional[pulumi.Input[builtins.str]]:
346
+ def ca_cert(self) -> Optional[pulumi.Input[_builtins.str]]:
348
347
  """
349
348
  The base64-encoded SSL CA certificate for the Managed Database instance.
350
349
  """
351
350
  return pulumi.get(self, "ca_cert")
352
351
 
353
352
  @ca_cert.setter
354
- def ca_cert(self, value: Optional[pulumi.Input[builtins.str]]):
353
+ def ca_cert(self, value: Optional[pulumi.Input[_builtins.str]]):
355
354
  pulumi.set(self, "ca_cert", value)
356
355
 
357
- @property
356
+ @_builtins.property
358
357
  @pulumi.getter(name="clusterSize")
359
- def cluster_size(self) -> Optional[pulumi.Input[builtins.int]]:
358
+ def cluster_size(self) -> Optional[pulumi.Input[_builtins.int]]:
360
359
  """
361
360
  The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
362
361
  """
363
362
  return pulumi.get(self, "cluster_size")
364
363
 
365
364
  @cluster_size.setter
366
- def cluster_size(self, value: Optional[pulumi.Input[builtins.int]]):
365
+ def cluster_size(self, value: Optional[pulumi.Input[_builtins.int]]):
367
366
  pulumi.set(self, "cluster_size", value)
368
367
 
369
- @property
368
+ @_builtins.property
370
369
  @pulumi.getter
371
- def created(self) -> Optional[pulumi.Input[builtins.str]]:
370
+ def created(self) -> Optional[pulumi.Input[_builtins.str]]:
372
371
  """
373
372
  When this Managed Database was created.
374
373
  """
375
374
  return pulumi.get(self, "created")
376
375
 
377
376
  @created.setter
378
- def created(self, value: Optional[pulumi.Input[builtins.str]]):
377
+ def created(self, value: Optional[pulumi.Input[_builtins.str]]):
379
378
  pulumi.set(self, "created", value)
380
379
 
381
- @property
380
+ @_builtins.property
382
381
  @pulumi.getter
383
- def encrypted(self) -> Optional[pulumi.Input[builtins.bool]]:
382
+ def encrypted(self) -> Optional[pulumi.Input[_builtins.bool]]:
384
383
  """
385
384
  Whether the Managed Databases is encrypted. (default `false`)
386
385
  """
387
386
  return pulumi.get(self, "encrypted")
388
387
 
389
388
  @encrypted.setter
390
- def encrypted(self, value: Optional[pulumi.Input[builtins.bool]]):
389
+ def encrypted(self, value: Optional[pulumi.Input[_builtins.bool]]):
391
390
  pulumi.set(self, "encrypted", value)
392
391
 
393
- @property
392
+ @_builtins.property
394
393
  @pulumi.getter
395
- def engine(self) -> Optional[pulumi.Input[builtins.str]]:
394
+ def engine(self) -> Optional[pulumi.Input[_builtins.str]]:
396
395
  """
397
396
  The Managed Database engine. (e.g. `postgresql`)
398
397
  """
399
398
  return pulumi.get(self, "engine")
400
399
 
401
400
  @engine.setter
402
- def engine(self, value: Optional[pulumi.Input[builtins.str]]):
401
+ def engine(self, value: Optional[pulumi.Input[_builtins.str]]):
403
402
  pulumi.set(self, "engine", value)
404
403
 
405
- @property
404
+ @_builtins.property
406
405
  @pulumi.getter(name="engineId")
407
- def engine_id(self) -> Optional[pulumi.Input[builtins.str]]:
406
+ def engine_id(self) -> Optional[pulumi.Input[_builtins.str]]:
408
407
  """
409
408
  The Managed Database engine in engine/version format. (e.g. `postgresql/13.2`)
410
409
  """
411
410
  return pulumi.get(self, "engine_id")
412
411
 
413
412
  @engine_id.setter
414
- def engine_id(self, value: Optional[pulumi.Input[builtins.str]]):
413
+ def engine_id(self, value: Optional[pulumi.Input[_builtins.str]]):
415
414
  pulumi.set(self, "engine_id", value)
416
415
 
417
- @property
416
+ @_builtins.property
418
417
  @pulumi.getter(name="hostPrimary")
419
- def host_primary(self) -> Optional[pulumi.Input[builtins.str]]:
418
+ def host_primary(self) -> Optional[pulumi.Input[_builtins.str]]:
420
419
  """
421
420
  The primary host for the Managed Database.
422
421
  """
423
422
  return pulumi.get(self, "host_primary")
424
423
 
425
424
  @host_primary.setter
426
- def host_primary(self, value: Optional[pulumi.Input[builtins.str]]):
425
+ def host_primary(self, value: Optional[pulumi.Input[_builtins.str]]):
427
426
  pulumi.set(self, "host_primary", value)
428
427
 
429
- @property
428
+ @_builtins.property
430
429
  @pulumi.getter(name="hostSecondary")
431
- def host_secondary(self) -> Optional[pulumi.Input[builtins.str]]:
430
+ def host_secondary(self) -> Optional[pulumi.Input[_builtins.str]]:
432
431
  """
433
432
  The secondary/private network host for the Managed Database.
434
433
  """
435
434
  return pulumi.get(self, "host_secondary")
436
435
 
437
436
  @host_secondary.setter
438
- def host_secondary(self, value: Optional[pulumi.Input[builtins.str]]):
437
+ def host_secondary(self, value: Optional[pulumi.Input[_builtins.str]]):
439
438
  pulumi.set(self, "host_secondary", value)
440
439
 
441
- @property
440
+ @_builtins.property
442
441
  @pulumi.getter
443
- def label(self) -> Optional[pulumi.Input[builtins.str]]:
442
+ def label(self) -> Optional[pulumi.Input[_builtins.str]]:
444
443
  """
445
444
  A unique, user-defined string referring to the Managed Database.
446
445
  """
447
446
  return pulumi.get(self, "label")
448
447
 
449
448
  @label.setter
450
- def label(self, value: Optional[pulumi.Input[builtins.str]]):
449
+ def label(self, value: Optional[pulumi.Input[_builtins.str]]):
451
450
  pulumi.set(self, "label", value)
452
451
 
453
- @property
452
+ @_builtins.property
454
453
  @pulumi.getter
455
- def port(self) -> Optional[pulumi.Input[builtins.int]]:
454
+ def port(self) -> Optional[pulumi.Input[_builtins.int]]:
456
455
  """
457
456
  The access port for this Managed Database.
458
457
  """
459
458
  return pulumi.get(self, "port")
460
459
 
461
460
  @port.setter
462
- def port(self, value: Optional[pulumi.Input[builtins.int]]):
461
+ def port(self, value: Optional[pulumi.Input[_builtins.int]]):
463
462
  pulumi.set(self, "port", value)
464
463
 
465
- @property
464
+ @_builtins.property
466
465
  @pulumi.getter
467
- def region(self) -> Optional[pulumi.Input[builtins.str]]:
466
+ def region(self) -> Optional[pulumi.Input[_builtins.str]]:
468
467
  """
469
468
  The region to use for the Managed Database.
470
469
  """
471
470
  return pulumi.get(self, "region")
472
471
 
473
472
  @region.setter
474
- def region(self, value: Optional[pulumi.Input[builtins.str]]):
473
+ def region(self, value: Optional[pulumi.Input[_builtins.str]]):
475
474
  pulumi.set(self, "region", value)
476
475
 
477
- @property
476
+ @_builtins.property
478
477
  @pulumi.getter(name="replicationCommitType")
479
- def replication_commit_type(self) -> Optional[pulumi.Input[builtins.str]]:
478
+ def replication_commit_type(self) -> Optional[pulumi.Input[_builtins.str]]:
480
479
  """
481
480
  The synchronization level of the replicating server. (`on`, `local`, `remote_write`, `remote_apply`, `off`; default `off`)
482
481
 
@@ -487,12 +486,12 @@ class _DatabasePostgresqlState:
487
486
  return pulumi.get(self, "replication_commit_type")
488
487
 
489
488
  @replication_commit_type.setter
490
- def replication_commit_type(self, value: Optional[pulumi.Input[builtins.str]]):
489
+ def replication_commit_type(self, value: Optional[pulumi.Input[_builtins.str]]):
491
490
  pulumi.set(self, "replication_commit_type", value)
492
491
 
493
- @property
492
+ @_builtins.property
494
493
  @pulumi.getter(name="replicationType")
495
- def replication_type(self) -> Optional[pulumi.Input[builtins.str]]:
494
+ def replication_type(self) -> Optional[pulumi.Input[_builtins.str]]:
496
495
  """
497
496
  The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
498
497
 
@@ -503,36 +502,36 @@ class _DatabasePostgresqlState:
503
502
  return pulumi.get(self, "replication_type")
504
503
 
505
504
  @replication_type.setter
506
- def replication_type(self, value: Optional[pulumi.Input[builtins.str]]):
505
+ def replication_type(self, value: Optional[pulumi.Input[_builtins.str]]):
507
506
  pulumi.set(self, "replication_type", value)
508
507
 
509
- @property
508
+ @_builtins.property
510
509
  @pulumi.getter(name="rootPassword")
511
- def root_password(self) -> Optional[pulumi.Input[builtins.str]]:
510
+ def root_password(self) -> Optional[pulumi.Input[_builtins.str]]:
512
511
  """
513
512
  The randomly-generated root password for the Managed Database instance.
514
513
  """
515
514
  return pulumi.get(self, "root_password")
516
515
 
517
516
  @root_password.setter
518
- def root_password(self, value: Optional[pulumi.Input[builtins.str]]):
517
+ def root_password(self, value: Optional[pulumi.Input[_builtins.str]]):
519
518
  pulumi.set(self, "root_password", value)
520
519
 
521
- @property
520
+ @_builtins.property
522
521
  @pulumi.getter(name="rootUsername")
523
- def root_username(self) -> Optional[pulumi.Input[builtins.str]]:
522
+ def root_username(self) -> Optional[pulumi.Input[_builtins.str]]:
524
523
  """
525
524
  The root username for the Managed Database instance.
526
525
  """
527
526
  return pulumi.get(self, "root_username")
528
527
 
529
528
  @root_username.setter
530
- def root_username(self, value: Optional[pulumi.Input[builtins.str]]):
529
+ def root_username(self, value: Optional[pulumi.Input[_builtins.str]]):
531
530
  pulumi.set(self, "root_username", value)
532
531
 
533
- @property
532
+ @_builtins.property
534
533
  @pulumi.getter(name="sslConnection")
535
- def ssl_connection(self) -> Optional[pulumi.Input[builtins.bool]]:
534
+ def ssl_connection(self) -> Optional[pulumi.Input[_builtins.bool]]:
536
535
  """
537
536
  Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
538
537
 
@@ -541,24 +540,24 @@ class _DatabasePostgresqlState:
541
540
  return pulumi.get(self, "ssl_connection")
542
541
 
543
542
  @ssl_connection.setter
544
- def ssl_connection(self, value: Optional[pulumi.Input[builtins.bool]]):
543
+ def ssl_connection(self, value: Optional[pulumi.Input[_builtins.bool]]):
545
544
  pulumi.set(self, "ssl_connection", value)
546
545
 
547
- @property
546
+ @_builtins.property
548
547
  @pulumi.getter
549
- def status(self) -> Optional[pulumi.Input[builtins.str]]:
548
+ def status(self) -> Optional[pulumi.Input[_builtins.str]]:
550
549
  """
551
550
  The operating status of the Managed Database.
552
551
  """
553
552
  return pulumi.get(self, "status")
554
553
 
555
554
  @status.setter
556
- def status(self, value: Optional[pulumi.Input[builtins.str]]):
555
+ def status(self, value: Optional[pulumi.Input[_builtins.str]]):
557
556
  pulumi.set(self, "status", value)
558
557
 
559
- @property
558
+ @_builtins.property
560
559
  @pulumi.getter
561
- def type(self) -> Optional[pulumi.Input[builtins.str]]:
560
+ def type(self) -> Optional[pulumi.Input[_builtins.str]]:
562
561
  """
563
562
  The Linode Instance type used for the nodes of the Managed Database instance.
564
563
 
@@ -567,22 +566,22 @@ class _DatabasePostgresqlState:
567
566
  return pulumi.get(self, "type")
568
567
 
569
568
  @type.setter
570
- def type(self, value: Optional[pulumi.Input[builtins.str]]):
569
+ def type(self, value: Optional[pulumi.Input[_builtins.str]]):
571
570
  pulumi.set(self, "type", value)
572
571
 
573
- @property
572
+ @_builtins.property
574
573
  @pulumi.getter
575
- def updated(self) -> Optional[pulumi.Input[builtins.str]]:
574
+ def updated(self) -> Optional[pulumi.Input[_builtins.str]]:
576
575
  """
577
576
  When this Managed Database was last updated.
578
577
  """
579
578
  return pulumi.get(self, "updated")
580
579
 
581
580
  @updated.setter
582
- def updated(self, value: Optional[pulumi.Input[builtins.str]]):
581
+ def updated(self, value: Optional[pulumi.Input[_builtins.str]]):
583
582
  pulumi.set(self, "updated", value)
584
583
 
585
- @property
584
+ @_builtins.property
586
585
  @pulumi.getter
587
586
  def updates(self) -> Optional[pulumi.Input['DatabasePostgresqlUpdatesArgs']]:
588
587
  """
@@ -594,16 +593,16 @@ class _DatabasePostgresqlState:
594
593
  def updates(self, value: Optional[pulumi.Input['DatabasePostgresqlUpdatesArgs']]):
595
594
  pulumi.set(self, "updates", value)
596
595
 
597
- @property
596
+ @_builtins.property
598
597
  @pulumi.getter
599
- def version(self) -> Optional[pulumi.Input[builtins.str]]:
598
+ def version(self) -> Optional[pulumi.Input[_builtins.str]]:
600
599
  """
601
600
  The Managed Database engine version. (e.g. `13.2`)
602
601
  """
603
602
  return pulumi.get(self, "version")
604
603
 
605
604
  @version.setter
606
- def version(self, value: Optional[pulumi.Input[builtins.str]]):
605
+ def version(self, value: Optional[pulumi.Input[_builtins.str]]):
607
606
  pulumi.set(self, "version", value)
608
607
 
609
608
 
@@ -613,16 +612,16 @@ class DatabasePostgresql(pulumi.CustomResource):
613
612
  def __init__(__self__,
614
613
  resource_name: str,
615
614
  opts: Optional[pulumi.ResourceOptions] = None,
616
- allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
617
- cluster_size: Optional[pulumi.Input[builtins.int]] = None,
618
- encrypted: Optional[pulumi.Input[builtins.bool]] = None,
619
- engine_id: Optional[pulumi.Input[builtins.str]] = None,
620
- label: Optional[pulumi.Input[builtins.str]] = None,
621
- region: Optional[pulumi.Input[builtins.str]] = None,
622
- replication_commit_type: Optional[pulumi.Input[builtins.str]] = None,
623
- replication_type: Optional[pulumi.Input[builtins.str]] = None,
624
- ssl_connection: Optional[pulumi.Input[builtins.bool]] = None,
625
- type: Optional[pulumi.Input[builtins.str]] = None,
615
+ allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
616
+ cluster_size: Optional[pulumi.Input[_builtins.int]] = None,
617
+ encrypted: Optional[pulumi.Input[_builtins.bool]] = None,
618
+ engine_id: Optional[pulumi.Input[_builtins.str]] = None,
619
+ label: Optional[pulumi.Input[_builtins.str]] = None,
620
+ region: Optional[pulumi.Input[_builtins.str]] = None,
621
+ replication_commit_type: Optional[pulumi.Input[_builtins.str]] = None,
622
+ replication_type: Optional[pulumi.Input[_builtins.str]] = None,
623
+ ssl_connection: Optional[pulumi.Input[_builtins.bool]] = None,
624
+ type: Optional[pulumi.Input[_builtins.str]] = None,
626
625
  updates: Optional[pulumi.Input[Union['DatabasePostgresqlUpdatesArgs', 'DatabasePostgresqlUpdatesArgsDict']]] = None,
627
626
  __props__=None):
628
627
  """
@@ -698,26 +697,26 @@ class DatabasePostgresql(pulumi.CustomResource):
698
697
 
699
698
  :param str resource_name: The name of the resource.
700
699
  :param pulumi.ResourceOptions opts: Options for the resource.
701
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] allow_lists: A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
702
- :param pulumi.Input[builtins.int] cluster_size: The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
703
- :param pulumi.Input[builtins.bool] encrypted: Whether the Managed Databases is encrypted. (default `false`)
704
- :param pulumi.Input[builtins.str] engine_id: The Managed Database engine in engine/version format. (e.g. `postgresql/13.2`)
705
- :param pulumi.Input[builtins.str] label: A unique, user-defined string referring to the Managed Database.
706
- :param pulumi.Input[builtins.str] region: The region to use for the Managed Database.
707
- :param pulumi.Input[builtins.str] replication_commit_type: The synchronization level of the replicating server. (`on`, `local`, `remote_write`, `remote_apply`, `off`; default `off`)
700
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allow_lists: A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
701
+ :param pulumi.Input[_builtins.int] cluster_size: The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
702
+ :param pulumi.Input[_builtins.bool] encrypted: Whether the Managed Databases is encrypted. (default `false`)
703
+ :param pulumi.Input[_builtins.str] engine_id: The Managed Database engine in engine/version format. (e.g. `postgresql/13.2`)
704
+ :param pulumi.Input[_builtins.str] label: A unique, user-defined string referring to the Managed Database.
705
+ :param pulumi.Input[_builtins.str] region: The region to use for the Managed Database.
706
+ :param pulumi.Input[_builtins.str] replication_commit_type: The synchronization level of the replicating server. (`on`, `local`, `remote_write`, `remote_apply`, `off`; default `off`)
708
707
 
709
708
  * Must be `local` or `off` for the `asynch` replication type.
710
709
 
711
710
  * Must be `on`, `remote_write`, or `remote_apply` for the `semi_synch` replication type.
712
- :param pulumi.Input[builtins.str] replication_type: The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
711
+ :param pulumi.Input[_builtins.str] replication_type: The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
713
712
 
714
713
  * Must be `none` for a single node cluster.
715
714
 
716
715
  * Must be `asynch` or `semi_synch` for a high availability cluster.
717
- :param pulumi.Input[builtins.bool] ssl_connection: Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
716
+ :param pulumi.Input[_builtins.bool] ssl_connection: Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
718
717
 
719
718
  * `updates` - (Optional) Configuration settings for automated patch update maintenance for the Managed Database.
720
- :param pulumi.Input[builtins.str] type: The Linode Instance type used for the nodes of the Managed Database instance.
719
+ :param pulumi.Input[_builtins.str] type: The Linode Instance type used for the nodes of the Managed Database instance.
721
720
 
722
721
  - - -
723
722
  :param pulumi.Input[Union['DatabasePostgresqlUpdatesArgs', 'DatabasePostgresqlUpdatesArgsDict']] updates: Configuration settings for automated patch update maintenance for the Managed Database.
@@ -814,16 +813,16 @@ class DatabasePostgresql(pulumi.CustomResource):
814
813
  def _internal_init(__self__,
815
814
  resource_name: str,
816
815
  opts: Optional[pulumi.ResourceOptions] = None,
817
- allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
818
- cluster_size: Optional[pulumi.Input[builtins.int]] = None,
819
- encrypted: Optional[pulumi.Input[builtins.bool]] = None,
820
- engine_id: Optional[pulumi.Input[builtins.str]] = None,
821
- label: Optional[pulumi.Input[builtins.str]] = None,
822
- region: Optional[pulumi.Input[builtins.str]] = None,
823
- replication_commit_type: Optional[pulumi.Input[builtins.str]] = None,
824
- replication_type: Optional[pulumi.Input[builtins.str]] = None,
825
- ssl_connection: Optional[pulumi.Input[builtins.bool]] = None,
826
- type: Optional[pulumi.Input[builtins.str]] = None,
816
+ allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
817
+ cluster_size: Optional[pulumi.Input[_builtins.int]] = None,
818
+ encrypted: Optional[pulumi.Input[_builtins.bool]] = None,
819
+ engine_id: Optional[pulumi.Input[_builtins.str]] = None,
820
+ label: Optional[pulumi.Input[_builtins.str]] = None,
821
+ region: Optional[pulumi.Input[_builtins.str]] = None,
822
+ replication_commit_type: Optional[pulumi.Input[_builtins.str]] = None,
823
+ replication_type: Optional[pulumi.Input[_builtins.str]] = None,
824
+ ssl_connection: Optional[pulumi.Input[_builtins.bool]] = None,
825
+ type: Optional[pulumi.Input[_builtins.str]] = None,
827
826
  updates: Optional[pulumi.Input[Union['DatabasePostgresqlUpdatesArgs', 'DatabasePostgresqlUpdatesArgsDict']]] = None,
828
827
  __props__=None):
829
828
  opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
@@ -876,28 +875,28 @@ class DatabasePostgresql(pulumi.CustomResource):
876
875
  def get(resource_name: str,
877
876
  id: pulumi.Input[str],
878
877
  opts: Optional[pulumi.ResourceOptions] = None,
879
- allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
880
- ca_cert: Optional[pulumi.Input[builtins.str]] = None,
881
- cluster_size: Optional[pulumi.Input[builtins.int]] = None,
882
- created: Optional[pulumi.Input[builtins.str]] = None,
883
- encrypted: Optional[pulumi.Input[builtins.bool]] = None,
884
- engine: Optional[pulumi.Input[builtins.str]] = None,
885
- engine_id: Optional[pulumi.Input[builtins.str]] = None,
886
- host_primary: Optional[pulumi.Input[builtins.str]] = None,
887
- host_secondary: Optional[pulumi.Input[builtins.str]] = None,
888
- label: Optional[pulumi.Input[builtins.str]] = None,
889
- port: Optional[pulumi.Input[builtins.int]] = None,
890
- region: Optional[pulumi.Input[builtins.str]] = None,
891
- replication_commit_type: Optional[pulumi.Input[builtins.str]] = None,
892
- replication_type: Optional[pulumi.Input[builtins.str]] = None,
893
- root_password: Optional[pulumi.Input[builtins.str]] = None,
894
- root_username: Optional[pulumi.Input[builtins.str]] = None,
895
- ssl_connection: Optional[pulumi.Input[builtins.bool]] = None,
896
- status: Optional[pulumi.Input[builtins.str]] = None,
897
- type: Optional[pulumi.Input[builtins.str]] = None,
898
- updated: Optional[pulumi.Input[builtins.str]] = None,
878
+ allow_lists: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
879
+ ca_cert: Optional[pulumi.Input[_builtins.str]] = None,
880
+ cluster_size: Optional[pulumi.Input[_builtins.int]] = None,
881
+ created: Optional[pulumi.Input[_builtins.str]] = None,
882
+ encrypted: Optional[pulumi.Input[_builtins.bool]] = None,
883
+ engine: Optional[pulumi.Input[_builtins.str]] = None,
884
+ engine_id: Optional[pulumi.Input[_builtins.str]] = None,
885
+ host_primary: Optional[pulumi.Input[_builtins.str]] = None,
886
+ host_secondary: Optional[pulumi.Input[_builtins.str]] = None,
887
+ label: Optional[pulumi.Input[_builtins.str]] = None,
888
+ port: Optional[pulumi.Input[_builtins.int]] = None,
889
+ region: Optional[pulumi.Input[_builtins.str]] = None,
890
+ replication_commit_type: Optional[pulumi.Input[_builtins.str]] = None,
891
+ replication_type: Optional[pulumi.Input[_builtins.str]] = None,
892
+ root_password: Optional[pulumi.Input[_builtins.str]] = None,
893
+ root_username: Optional[pulumi.Input[_builtins.str]] = None,
894
+ ssl_connection: Optional[pulumi.Input[_builtins.bool]] = None,
895
+ status: Optional[pulumi.Input[_builtins.str]] = None,
896
+ type: Optional[pulumi.Input[_builtins.str]] = None,
897
+ updated: Optional[pulumi.Input[_builtins.str]] = None,
899
898
  updates: Optional[pulumi.Input[Union['DatabasePostgresqlUpdatesArgs', 'DatabasePostgresqlUpdatesArgsDict']]] = None,
900
- version: Optional[pulumi.Input[builtins.str]] = None) -> 'DatabasePostgresql':
899
+ version: Optional[pulumi.Input[_builtins.str]] = None) -> 'DatabasePostgresql':
901
900
  """
902
901
  Get an existing DatabasePostgresql resource's state with the given name, id, and optional extra
903
902
  properties used to qualify the lookup.
@@ -905,40 +904,40 @@ class DatabasePostgresql(pulumi.CustomResource):
905
904
  :param str resource_name: The unique name of the resulting resource.
906
905
  :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
907
906
  :param pulumi.ResourceOptions opts: Options for the resource.
908
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] allow_lists: A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
909
- :param pulumi.Input[builtins.str] ca_cert: The base64-encoded SSL CA certificate for the Managed Database instance.
910
- :param pulumi.Input[builtins.int] cluster_size: The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
911
- :param pulumi.Input[builtins.str] created: When this Managed Database was created.
912
- :param pulumi.Input[builtins.bool] encrypted: Whether the Managed Databases is encrypted. (default `false`)
913
- :param pulumi.Input[builtins.str] engine: The Managed Database engine. (e.g. `postgresql`)
914
- :param pulumi.Input[builtins.str] engine_id: The Managed Database engine in engine/version format. (e.g. `postgresql/13.2`)
915
- :param pulumi.Input[builtins.str] host_primary: The primary host for the Managed Database.
916
- :param pulumi.Input[builtins.str] host_secondary: The secondary/private network host for the Managed Database.
917
- :param pulumi.Input[builtins.str] label: A unique, user-defined string referring to the Managed Database.
918
- :param pulumi.Input[builtins.int] port: The access port for this Managed Database.
919
- :param pulumi.Input[builtins.str] region: The region to use for the Managed Database.
920
- :param pulumi.Input[builtins.str] replication_commit_type: The synchronization level of the replicating server. (`on`, `local`, `remote_write`, `remote_apply`, `off`; default `off`)
907
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] allow_lists: A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
908
+ :param pulumi.Input[_builtins.str] ca_cert: The base64-encoded SSL CA certificate for the Managed Database instance.
909
+ :param pulumi.Input[_builtins.int] cluster_size: The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
910
+ :param pulumi.Input[_builtins.str] created: When this Managed Database was created.
911
+ :param pulumi.Input[_builtins.bool] encrypted: Whether the Managed Databases is encrypted. (default `false`)
912
+ :param pulumi.Input[_builtins.str] engine: The Managed Database engine. (e.g. `postgresql`)
913
+ :param pulumi.Input[_builtins.str] engine_id: The Managed Database engine in engine/version format. (e.g. `postgresql/13.2`)
914
+ :param pulumi.Input[_builtins.str] host_primary: The primary host for the Managed Database.
915
+ :param pulumi.Input[_builtins.str] host_secondary: The secondary/private network host for the Managed Database.
916
+ :param pulumi.Input[_builtins.str] label: A unique, user-defined string referring to the Managed Database.
917
+ :param pulumi.Input[_builtins.int] port: The access port for this Managed Database.
918
+ :param pulumi.Input[_builtins.str] region: The region to use for the Managed Database.
919
+ :param pulumi.Input[_builtins.str] replication_commit_type: The synchronization level of the replicating server. (`on`, `local`, `remote_write`, `remote_apply`, `off`; default `off`)
921
920
 
922
921
  * Must be `local` or `off` for the `asynch` replication type.
923
922
 
924
923
  * Must be `on`, `remote_write`, or `remote_apply` for the `semi_synch` replication type.
925
- :param pulumi.Input[builtins.str] replication_type: The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
924
+ :param pulumi.Input[_builtins.str] replication_type: The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
926
925
 
927
926
  * Must be `none` for a single node cluster.
928
927
 
929
928
  * Must be `asynch` or `semi_synch` for a high availability cluster.
930
- :param pulumi.Input[builtins.str] root_password: The randomly-generated root password for the Managed Database instance.
931
- :param pulumi.Input[builtins.str] root_username: The root username for the Managed Database instance.
932
- :param pulumi.Input[builtins.bool] ssl_connection: Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
929
+ :param pulumi.Input[_builtins.str] root_password: The randomly-generated root password for the Managed Database instance.
930
+ :param pulumi.Input[_builtins.str] root_username: The root username for the Managed Database instance.
931
+ :param pulumi.Input[_builtins.bool] ssl_connection: Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
933
932
 
934
933
  * `updates` - (Optional) Configuration settings for automated patch update maintenance for the Managed Database.
935
- :param pulumi.Input[builtins.str] status: The operating status of the Managed Database.
936
- :param pulumi.Input[builtins.str] type: The Linode Instance type used for the nodes of the Managed Database instance.
934
+ :param pulumi.Input[_builtins.str] status: The operating status of the Managed Database.
935
+ :param pulumi.Input[_builtins.str] type: The Linode Instance type used for the nodes of the Managed Database instance.
937
936
 
938
937
  - - -
939
- :param pulumi.Input[builtins.str] updated: When this Managed Database was last updated.
938
+ :param pulumi.Input[_builtins.str] updated: When this Managed Database was last updated.
940
939
  :param pulumi.Input[Union['DatabasePostgresqlUpdatesArgs', 'DatabasePostgresqlUpdatesArgsDict']] updates: Configuration settings for automated patch update maintenance for the Managed Database.
941
- :param pulumi.Input[builtins.str] version: The Managed Database engine version. (e.g. `13.2`)
940
+ :param pulumi.Input[_builtins.str] version: The Managed Database engine version. (e.g. `13.2`)
942
941
  """
943
942
  opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
944
943
 
@@ -968,105 +967,105 @@ class DatabasePostgresql(pulumi.CustomResource):
968
967
  __props__.__dict__["version"] = version
969
968
  return DatabasePostgresql(resource_name, opts=opts, __props__=__props__)
970
969
 
971
- @property
970
+ @_builtins.property
972
971
  @pulumi.getter(name="allowLists")
973
- def allow_lists(self) -> pulumi.Output[Sequence[builtins.str]]:
972
+ def allow_lists(self) -> pulumi.Output[Sequence[_builtins.str]]:
974
973
  """
975
974
  A list of IP addresses that can access the Managed Database. Each item can be a single IP address or a range in CIDR format. Use `DatabaseAccessControls` to manage your allow list separately.
976
975
  """
977
976
  return pulumi.get(self, "allow_lists")
978
977
 
979
- @property
978
+ @_builtins.property
980
979
  @pulumi.getter(name="caCert")
981
- def ca_cert(self) -> pulumi.Output[builtins.str]:
980
+ def ca_cert(self) -> pulumi.Output[_builtins.str]:
982
981
  """
983
982
  The base64-encoded SSL CA certificate for the Managed Database instance.
984
983
  """
985
984
  return pulumi.get(self, "ca_cert")
986
985
 
987
- @property
986
+ @_builtins.property
988
987
  @pulumi.getter(name="clusterSize")
989
- def cluster_size(self) -> pulumi.Output[Optional[builtins.int]]:
988
+ def cluster_size(self) -> pulumi.Output[Optional[_builtins.int]]:
990
989
  """
991
990
  The number of Linode Instance nodes deployed to the Managed Database. (default `1`)
992
991
  """
993
992
  return pulumi.get(self, "cluster_size")
994
993
 
995
- @property
994
+ @_builtins.property
996
995
  @pulumi.getter
997
- def created(self) -> pulumi.Output[builtins.str]:
996
+ def created(self) -> pulumi.Output[_builtins.str]:
998
997
  """
999
998
  When this Managed Database was created.
1000
999
  """
1001
1000
  return pulumi.get(self, "created")
1002
1001
 
1003
- @property
1002
+ @_builtins.property
1004
1003
  @pulumi.getter
1005
- def encrypted(self) -> pulumi.Output[Optional[builtins.bool]]:
1004
+ def encrypted(self) -> pulumi.Output[Optional[_builtins.bool]]:
1006
1005
  """
1007
1006
  Whether the Managed Databases is encrypted. (default `false`)
1008
1007
  """
1009
1008
  return pulumi.get(self, "encrypted")
1010
1009
 
1011
- @property
1010
+ @_builtins.property
1012
1011
  @pulumi.getter
1013
- def engine(self) -> pulumi.Output[builtins.str]:
1012
+ def engine(self) -> pulumi.Output[_builtins.str]:
1014
1013
  """
1015
1014
  The Managed Database engine. (e.g. `postgresql`)
1016
1015
  """
1017
1016
  return pulumi.get(self, "engine")
1018
1017
 
1019
- @property
1018
+ @_builtins.property
1020
1019
  @pulumi.getter(name="engineId")
1021
- def engine_id(self) -> pulumi.Output[builtins.str]:
1020
+ def engine_id(self) -> pulumi.Output[_builtins.str]:
1022
1021
  """
1023
1022
  The Managed Database engine in engine/version format. (e.g. `postgresql/13.2`)
1024
1023
  """
1025
1024
  return pulumi.get(self, "engine_id")
1026
1025
 
1027
- @property
1026
+ @_builtins.property
1028
1027
  @pulumi.getter(name="hostPrimary")
1029
- def host_primary(self) -> pulumi.Output[builtins.str]:
1028
+ def host_primary(self) -> pulumi.Output[_builtins.str]:
1030
1029
  """
1031
1030
  The primary host for the Managed Database.
1032
1031
  """
1033
1032
  return pulumi.get(self, "host_primary")
1034
1033
 
1035
- @property
1034
+ @_builtins.property
1036
1035
  @pulumi.getter(name="hostSecondary")
1037
- def host_secondary(self) -> pulumi.Output[builtins.str]:
1036
+ def host_secondary(self) -> pulumi.Output[_builtins.str]:
1038
1037
  """
1039
1038
  The secondary/private network host for the Managed Database.
1040
1039
  """
1041
1040
  return pulumi.get(self, "host_secondary")
1042
1041
 
1043
- @property
1042
+ @_builtins.property
1044
1043
  @pulumi.getter
1045
- def label(self) -> pulumi.Output[builtins.str]:
1044
+ def label(self) -> pulumi.Output[_builtins.str]:
1046
1045
  """
1047
1046
  A unique, user-defined string referring to the Managed Database.
1048
1047
  """
1049
1048
  return pulumi.get(self, "label")
1050
1049
 
1051
- @property
1050
+ @_builtins.property
1052
1051
  @pulumi.getter
1053
- def port(self) -> pulumi.Output[builtins.int]:
1052
+ def port(self) -> pulumi.Output[_builtins.int]:
1054
1053
  """
1055
1054
  The access port for this Managed Database.
1056
1055
  """
1057
1056
  return pulumi.get(self, "port")
1058
1057
 
1059
- @property
1058
+ @_builtins.property
1060
1059
  @pulumi.getter
1061
- def region(self) -> pulumi.Output[builtins.str]:
1060
+ def region(self) -> pulumi.Output[_builtins.str]:
1062
1061
  """
1063
1062
  The region to use for the Managed Database.
1064
1063
  """
1065
1064
  return pulumi.get(self, "region")
1066
1065
 
1067
- @property
1066
+ @_builtins.property
1068
1067
  @pulumi.getter(name="replicationCommitType")
1069
- def replication_commit_type(self) -> pulumi.Output[Optional[builtins.str]]:
1068
+ def replication_commit_type(self) -> pulumi.Output[Optional[_builtins.str]]:
1070
1069
  """
1071
1070
  The synchronization level of the replicating server. (`on`, `local`, `remote_write`, `remote_apply`, `off`; default `off`)
1072
1071
 
@@ -1076,9 +1075,9 @@ class DatabasePostgresql(pulumi.CustomResource):
1076
1075
  """
1077
1076
  return pulumi.get(self, "replication_commit_type")
1078
1077
 
1079
- @property
1078
+ @_builtins.property
1080
1079
  @pulumi.getter(name="replicationType")
1081
- def replication_type(self) -> pulumi.Output[Optional[builtins.str]]:
1080
+ def replication_type(self) -> pulumi.Output[Optional[_builtins.str]]:
1082
1081
  """
1083
1082
  The replication method used for the Managed Database. (`none`, `asynch`, `semi_synch`; default `none`)
1084
1083
 
@@ -1088,25 +1087,25 @@ class DatabasePostgresql(pulumi.CustomResource):
1088
1087
  """
1089
1088
  return pulumi.get(self, "replication_type")
1090
1089
 
1091
- @property
1090
+ @_builtins.property
1092
1091
  @pulumi.getter(name="rootPassword")
1093
- def root_password(self) -> pulumi.Output[builtins.str]:
1092
+ def root_password(self) -> pulumi.Output[_builtins.str]:
1094
1093
  """
1095
1094
  The randomly-generated root password for the Managed Database instance.
1096
1095
  """
1097
1096
  return pulumi.get(self, "root_password")
1098
1097
 
1099
- @property
1098
+ @_builtins.property
1100
1099
  @pulumi.getter(name="rootUsername")
1101
- def root_username(self) -> pulumi.Output[builtins.str]:
1100
+ def root_username(self) -> pulumi.Output[_builtins.str]:
1102
1101
  """
1103
1102
  The root username for the Managed Database instance.
1104
1103
  """
1105
1104
  return pulumi.get(self, "root_username")
1106
1105
 
1107
- @property
1106
+ @_builtins.property
1108
1107
  @pulumi.getter(name="sslConnection")
1109
- def ssl_connection(self) -> pulumi.Output[Optional[builtins.bool]]:
1108
+ def ssl_connection(self) -> pulumi.Output[Optional[_builtins.bool]]:
1110
1109
  """
1111
1110
  Whether to require SSL credentials to establish a connection to the Managed Database. (default `false`)
1112
1111
 
@@ -1114,17 +1113,17 @@ class DatabasePostgresql(pulumi.CustomResource):
1114
1113
  """
1115
1114
  return pulumi.get(self, "ssl_connection")
1116
1115
 
1117
- @property
1116
+ @_builtins.property
1118
1117
  @pulumi.getter
1119
- def status(self) -> pulumi.Output[builtins.str]:
1118
+ def status(self) -> pulumi.Output[_builtins.str]:
1120
1119
  """
1121
1120
  The operating status of the Managed Database.
1122
1121
  """
1123
1122
  return pulumi.get(self, "status")
1124
1123
 
1125
- @property
1124
+ @_builtins.property
1126
1125
  @pulumi.getter
1127
- def type(self) -> pulumi.Output[builtins.str]:
1126
+ def type(self) -> pulumi.Output[_builtins.str]:
1128
1127
  """
1129
1128
  The Linode Instance type used for the nodes of the Managed Database instance.
1130
1129
 
@@ -1132,15 +1131,15 @@ class DatabasePostgresql(pulumi.CustomResource):
1132
1131
  """
1133
1132
  return pulumi.get(self, "type")
1134
1133
 
1135
- @property
1134
+ @_builtins.property
1136
1135
  @pulumi.getter
1137
- def updated(self) -> pulumi.Output[builtins.str]:
1136
+ def updated(self) -> pulumi.Output[_builtins.str]:
1138
1137
  """
1139
1138
  When this Managed Database was last updated.
1140
1139
  """
1141
1140
  return pulumi.get(self, "updated")
1142
1141
 
1143
- @property
1142
+ @_builtins.property
1144
1143
  @pulumi.getter
1145
1144
  def updates(self) -> pulumi.Output['outputs.DatabasePostgresqlUpdates']:
1146
1145
  """
@@ -1148,9 +1147,9 @@ class DatabasePostgresql(pulumi.CustomResource):
1148
1147
  """
1149
1148
  return pulumi.get(self, "updates")
1150
1149
 
1151
- @property
1150
+ @_builtins.property
1152
1151
  @pulumi.getter
1153
- def version(self) -> pulumi.Output[builtins.str]:
1152
+ def version(self) -> pulumi.Output[_builtins.str]:
1154
1153
  """
1155
1154
  The Managed Database engine version. (e.g. `13.2`)
1156
1155
  """