pulumi-hcloud 1.23.0a1747375245__py3-none-any.whl → 1.23.1__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 (67) hide show
  1. pulumi_hcloud/__init__.py +2 -2
  2. pulumi_hcloud/_inputs.py +348 -259
  3. pulumi_hcloud/_utilities.py +1 -1
  4. pulumi_hcloud/certificate.py +96 -97
  5. pulumi_hcloud/config/__init__.py +2 -2
  6. pulumi_hcloud/config/__init__.pyi +2 -3
  7. pulumi_hcloud/config/vars.py +6 -7
  8. pulumi_hcloud/firewall.py +42 -43
  9. pulumi_hcloud/firewall_attachment.py +53 -54
  10. pulumi_hcloud/floating_ip.py +139 -140
  11. pulumi_hcloud/floating_ip_assignment.py +36 -37
  12. pulumi_hcloud/get_certificate.py +36 -37
  13. pulumi_hcloud/get_certificates.py +11 -12
  14. pulumi_hcloud/get_datacenter.py +22 -23
  15. pulumi_hcloud/get_datacenters.py +11 -12
  16. pulumi_hcloud/get_firewall.py +34 -35
  17. pulumi_hcloud/get_firewalls.py +17 -18
  18. pulumi_hcloud/get_floating_ip.py +44 -45
  19. pulumi_hcloud/get_floating_ips.py +11 -12
  20. pulumi_hcloud/get_image.py +78 -75
  21. pulumi_hcloud/get_images.py +45 -40
  22. pulumi_hcloud/get_load_balancer.py +41 -42
  23. pulumi_hcloud/get_load_balancer_type.py +24 -25
  24. pulumi_hcloud/get_load_balancer_types.py +5 -6
  25. pulumi_hcloud/get_load_balancers.py +11 -12
  26. pulumi_hcloud/get_location.py +26 -27
  27. pulumi_hcloud/get_locations.py +11 -12
  28. pulumi_hcloud/get_network.py +38 -39
  29. pulumi_hcloud/get_networks.py +11 -12
  30. pulumi_hcloud/get_placement_group.py +40 -41
  31. pulumi_hcloud/get_placement_groups.py +17 -18
  32. pulumi_hcloud/get_primary_ip.py +46 -47
  33. pulumi_hcloud/get_primary_ips.py +11 -12
  34. pulumi_hcloud/get_server.py +93 -72
  35. pulumi_hcloud/get_server_type.py +36 -37
  36. pulumi_hcloud/get_server_types.py +11 -12
  37. pulumi_hcloud/get_servers.py +17 -18
  38. pulumi_hcloud/get_ssh_key.py +36 -37
  39. pulumi_hcloud/get_ssh_keys.py +15 -16
  40. pulumi_hcloud/get_volume.py +50 -51
  41. pulumi_hcloud/get_volumes.py +17 -18
  42. pulumi_hcloud/load_balancer.py +146 -147
  43. pulumi_hcloud/load_balancer_network.py +87 -88
  44. pulumi_hcloud/load_balancer_service.py +93 -94
  45. pulumi_hcloud/load_balancer_target.py +104 -105
  46. pulumi_hcloud/managed_certificate.py +105 -106
  47. pulumi_hcloud/network.py +87 -88
  48. pulumi_hcloud/network_route.py +53 -54
  49. pulumi_hcloud/network_subnet.py +94 -95
  50. pulumi_hcloud/outputs.py +913 -820
  51. pulumi_hcloud/placement_group.py +60 -61
  52. pulumi_hcloud/primary_ip.py +156 -157
  53. pulumi_hcloud/provider.py +43 -44
  54. pulumi_hcloud/pulumi-plugin.json +1 -1
  55. pulumi_hcloud/rdns.py +104 -105
  56. pulumi_hcloud/server.py +381 -382
  57. pulumi_hcloud/server_network.py +94 -95
  58. pulumi_hcloud/snapshot.py +53 -54
  59. pulumi_hcloud/ssh_key.py +62 -63
  60. pulumi_hcloud/uploaded_certificate.py +122 -123
  61. pulumi_hcloud/volume.py +147 -148
  62. pulumi_hcloud/volume_attachment.py +53 -54
  63. {pulumi_hcloud-1.23.0a1747375245.dist-info → pulumi_hcloud-1.23.1.dist-info}/METADATA +1 -1
  64. pulumi_hcloud-1.23.1.dist-info/RECORD +67 -0
  65. {pulumi_hcloud-1.23.0a1747375245.dist-info → pulumi_hcloud-1.23.1.dist-info}/WHEEL +1 -1
  66. pulumi_hcloud-1.23.0a1747375245.dist-info/RECORD +0 -67
  67. {pulumi_hcloud-1.23.0a1747375245.dist-info → pulumi_hcloud-1.23.1.dist-info}/top_level.txt +0 -0
pulumi_hcloud/_inputs.py CHANGED
@@ -1,9 +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 builtins
6
- import copy
5
+ import builtins as _builtins
7
6
  import warnings
8
7
  import sys
9
8
  import pulumi
@@ -38,18 +37,20 @@ __all__ = [
38
37
  'GetFirewallApplyToArgsDict',
39
38
  'GetFirewallRuleArgs',
40
39
  'GetFirewallRuleArgsDict',
40
+ 'GetServerNetworkArgs',
41
+ 'GetServerNetworkArgsDict',
41
42
  ]
42
43
 
43
44
  MYPY = False
44
45
 
45
46
  if not MYPY:
46
47
  class FirewallApplyToArgsDict(TypedDict):
47
- label_selector: NotRequired[pulumi.Input[builtins.str]]
48
+ label_selector: NotRequired[pulumi.Input[_builtins.str]]
48
49
  """
49
50
  Label Selector to select servers the firewall should be applied to (only one
50
51
  of `server` and `label_selector`can be applied in one block)
51
52
  """
52
- server: NotRequired[pulumi.Input[builtins.int]]
53
+ server: NotRequired[pulumi.Input[_builtins.int]]
53
54
  """
54
55
  ID of the server you want to apply the firewall to (only one of `server`
55
56
  and `label_selector`can be applied in one block)
@@ -60,12 +61,12 @@ elif False:
60
61
  @pulumi.input_type
61
62
  class FirewallApplyToArgs:
62
63
  def __init__(__self__, *,
63
- label_selector: Optional[pulumi.Input[builtins.str]] = None,
64
- server: Optional[pulumi.Input[builtins.int]] = None):
64
+ label_selector: Optional[pulumi.Input[_builtins.str]] = None,
65
+ server: Optional[pulumi.Input[_builtins.int]] = None):
65
66
  """
66
- :param pulumi.Input[builtins.str] label_selector: Label Selector to select servers the firewall should be applied to (only one
67
+ :param pulumi.Input[_builtins.str] label_selector: Label Selector to select servers the firewall should be applied to (only one
67
68
  of `server` and `label_selector`can be applied in one block)
68
- :param pulumi.Input[builtins.int] server: ID of the server you want to apply the firewall to (only one of `server`
69
+ :param pulumi.Input[_builtins.int] server: ID of the server you want to apply the firewall to (only one of `server`
69
70
  and `label_selector`can be applied in one block)
70
71
  """
71
72
  if label_selector is not None:
@@ -73,9 +74,9 @@ class FirewallApplyToArgs:
73
74
  if server is not None:
74
75
  pulumi.set(__self__, "server", server)
75
76
 
76
- @property
77
+ @_builtins.property
77
78
  @pulumi.getter(name="labelSelector")
78
- def label_selector(self) -> Optional[pulumi.Input[builtins.str]]:
79
+ def label_selector(self) -> Optional[pulumi.Input[_builtins.str]]:
79
80
  """
80
81
  Label Selector to select servers the firewall should be applied to (only one
81
82
  of `server` and `label_selector`can be applied in one block)
@@ -83,12 +84,12 @@ class FirewallApplyToArgs:
83
84
  return pulumi.get(self, "label_selector")
84
85
 
85
86
  @label_selector.setter
86
- def label_selector(self, value: Optional[pulumi.Input[builtins.str]]):
87
+ def label_selector(self, value: Optional[pulumi.Input[_builtins.str]]):
87
88
  pulumi.set(self, "label_selector", value)
88
89
 
89
- @property
90
+ @_builtins.property
90
91
  @pulumi.getter
91
- def server(self) -> Optional[pulumi.Input[builtins.int]]:
92
+ def server(self) -> Optional[pulumi.Input[_builtins.int]]:
92
93
  """
93
94
  ID of the server you want to apply the firewall to (only one of `server`
94
95
  and `label_selector`can be applied in one block)
@@ -96,35 +97,35 @@ class FirewallApplyToArgs:
96
97
  return pulumi.get(self, "server")
97
98
 
98
99
  @server.setter
99
- def server(self, value: Optional[pulumi.Input[builtins.int]]):
100
+ def server(self, value: Optional[pulumi.Input[_builtins.int]]):
100
101
  pulumi.set(self, "server", value)
101
102
 
102
103
 
103
104
  if not MYPY:
104
105
  class FirewallRuleArgsDict(TypedDict):
105
- direction: pulumi.Input[builtins.str]
106
+ direction: pulumi.Input[_builtins.str]
106
107
  """
107
108
  Direction of the Firewall Rule. `in`
108
109
  """
109
- protocol: pulumi.Input[builtins.str]
110
+ protocol: pulumi.Input[_builtins.str]
110
111
  """
111
112
  Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
112
113
  """
113
- description: NotRequired[pulumi.Input[builtins.str]]
114
+ description: NotRequired[pulumi.Input[_builtins.str]]
114
115
  """
115
116
  Description of the firewall rule
116
117
  """
117
- destination_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
118
+ destination_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
118
119
  """
119
120
  List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
120
121
  is `out`)
121
122
  """
122
- port: NotRequired[pulumi.Input[builtins.str]]
123
+ port: NotRequired[pulumi.Input[_builtins.str]]
123
124
  """
124
125
  Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`. You can use `any`
125
126
  to allow all ports for the specific protocol. Port ranges are also possible: `80-85` allows all ports between 80 and 85.
126
127
  """
127
- source_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
128
+ source_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
128
129
  """
129
130
  List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
130
131
  is `in`)
@@ -135,21 +136,21 @@ elif False:
135
136
  @pulumi.input_type
136
137
  class FirewallRuleArgs:
137
138
  def __init__(__self__, *,
138
- direction: pulumi.Input[builtins.str],
139
- protocol: pulumi.Input[builtins.str],
140
- description: Optional[pulumi.Input[builtins.str]] = None,
141
- destination_ips: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
142
- port: Optional[pulumi.Input[builtins.str]] = None,
143
- source_ips: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
144
- """
145
- :param pulumi.Input[builtins.str] direction: Direction of the Firewall Rule. `in`
146
- :param pulumi.Input[builtins.str] protocol: Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
147
- :param pulumi.Input[builtins.str] description: Description of the firewall rule
148
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] destination_ips: List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
139
+ direction: pulumi.Input[_builtins.str],
140
+ protocol: pulumi.Input[_builtins.str],
141
+ description: Optional[pulumi.Input[_builtins.str]] = None,
142
+ destination_ips: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
143
+ port: Optional[pulumi.Input[_builtins.str]] = None,
144
+ source_ips: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None):
145
+ """
146
+ :param pulumi.Input[_builtins.str] direction: Direction of the Firewall Rule. `in`
147
+ :param pulumi.Input[_builtins.str] protocol: Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
148
+ :param pulumi.Input[_builtins.str] description: Description of the firewall rule
149
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] destination_ips: List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
149
150
  is `out`)
150
- :param pulumi.Input[builtins.str] port: Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`. You can use `any`
151
+ :param pulumi.Input[_builtins.str] port: Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`. You can use `any`
151
152
  to allow all ports for the specific protocol. Port ranges are also possible: `80-85` allows all ports between 80 and 85.
152
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] source_ips: List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
153
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] source_ips: List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
153
154
  is `in`)
154
155
  """
155
156
  pulumi.set(__self__, "direction", direction)
@@ -163,45 +164,45 @@ class FirewallRuleArgs:
163
164
  if source_ips is not None:
164
165
  pulumi.set(__self__, "source_ips", source_ips)
165
166
 
166
- @property
167
+ @_builtins.property
167
168
  @pulumi.getter
168
- def direction(self) -> pulumi.Input[builtins.str]:
169
+ def direction(self) -> pulumi.Input[_builtins.str]:
169
170
  """
170
171
  Direction of the Firewall Rule. `in`
171
172
  """
172
173
  return pulumi.get(self, "direction")
173
174
 
174
175
  @direction.setter
175
- def direction(self, value: pulumi.Input[builtins.str]):
176
+ def direction(self, value: pulumi.Input[_builtins.str]):
176
177
  pulumi.set(self, "direction", value)
177
178
 
178
- @property
179
+ @_builtins.property
179
180
  @pulumi.getter
180
- def protocol(self) -> pulumi.Input[builtins.str]:
181
+ def protocol(self) -> pulumi.Input[_builtins.str]:
181
182
  """
182
183
  Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
183
184
  """
184
185
  return pulumi.get(self, "protocol")
185
186
 
186
187
  @protocol.setter
187
- def protocol(self, value: pulumi.Input[builtins.str]):
188
+ def protocol(self, value: pulumi.Input[_builtins.str]):
188
189
  pulumi.set(self, "protocol", value)
189
190
 
190
- @property
191
+ @_builtins.property
191
192
  @pulumi.getter
192
- def description(self) -> Optional[pulumi.Input[builtins.str]]:
193
+ def description(self) -> Optional[pulumi.Input[_builtins.str]]:
193
194
  """
194
195
  Description of the firewall rule
195
196
  """
196
197
  return pulumi.get(self, "description")
197
198
 
198
199
  @description.setter
199
- def description(self, value: Optional[pulumi.Input[builtins.str]]):
200
+ def description(self, value: Optional[pulumi.Input[_builtins.str]]):
200
201
  pulumi.set(self, "description", value)
201
202
 
202
- @property
203
+ @_builtins.property
203
204
  @pulumi.getter(name="destinationIps")
204
- def destination_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
205
+ def destination_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
205
206
  """
206
207
  List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
207
208
  is `out`)
@@ -209,12 +210,12 @@ class FirewallRuleArgs:
209
210
  return pulumi.get(self, "destination_ips")
210
211
 
211
212
  @destination_ips.setter
212
- def destination_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
213
+ def destination_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
213
214
  pulumi.set(self, "destination_ips", value)
214
215
 
215
- @property
216
+ @_builtins.property
216
217
  @pulumi.getter
217
- def port(self) -> Optional[pulumi.Input[builtins.str]]:
218
+ def port(self) -> Optional[pulumi.Input[_builtins.str]]:
218
219
  """
219
220
  Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`. You can use `any`
220
221
  to allow all ports for the specific protocol. Port ranges are also possible: `80-85` allows all ports between 80 and 85.
@@ -222,12 +223,12 @@ class FirewallRuleArgs:
222
223
  return pulumi.get(self, "port")
223
224
 
224
225
  @port.setter
225
- def port(self, value: Optional[pulumi.Input[builtins.str]]):
226
+ def port(self, value: Optional[pulumi.Input[_builtins.str]]):
226
227
  pulumi.set(self, "port", value)
227
228
 
228
- @property
229
+ @_builtins.property
229
230
  @pulumi.getter(name="sourceIps")
230
- def source_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
231
+ def source_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
231
232
  """
232
233
  List of IPs or CIDRs that are allowed within this Firewall Rule (when `direction`
233
234
  is `in`)
@@ -235,13 +236,13 @@ class FirewallRuleArgs:
235
236
  return pulumi.get(self, "source_ips")
236
237
 
237
238
  @source_ips.setter
238
- def source_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
239
+ def source_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
239
240
  pulumi.set(self, "source_ips", value)
240
241
 
241
242
 
242
243
  if not MYPY:
243
244
  class LoadBalancerAlgorithmArgsDict(TypedDict):
244
- type: NotRequired[pulumi.Input[builtins.str]]
245
+ type: NotRequired[pulumi.Input[_builtins.str]]
245
246
  """
246
247
  Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
247
248
  """
@@ -251,41 +252,41 @@ elif False:
251
252
  @pulumi.input_type
252
253
  class LoadBalancerAlgorithmArgs:
253
254
  def __init__(__self__, *,
254
- type: Optional[pulumi.Input[builtins.str]] = None):
255
+ type: Optional[pulumi.Input[_builtins.str]] = None):
255
256
  """
256
- :param pulumi.Input[builtins.str] type: Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
257
+ :param pulumi.Input[_builtins.str] type: Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
257
258
  """
258
259
  if type is not None:
259
260
  pulumi.set(__self__, "type", type)
260
261
 
261
- @property
262
+ @_builtins.property
262
263
  @pulumi.getter
263
- def type(self) -> Optional[pulumi.Input[builtins.str]]:
264
+ def type(self) -> Optional[pulumi.Input[_builtins.str]]:
264
265
  """
265
266
  Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
266
267
  """
267
268
  return pulumi.get(self, "type")
268
269
 
269
270
  @type.setter
270
- def type(self, value: Optional[pulumi.Input[builtins.str]]):
271
+ def type(self, value: Optional[pulumi.Input[_builtins.str]]):
271
272
  pulumi.set(self, "type", value)
272
273
 
273
274
 
274
275
  if not MYPY:
275
276
  class LoadBalancerServiceHealthCheckArgsDict(TypedDict):
276
- interval: pulumi.Input[builtins.int]
277
+ interval: pulumi.Input[_builtins.int]
277
278
  """
278
279
  Interval how often the health check will be performed, in seconds.
279
280
  """
280
- port: pulumi.Input[builtins.int]
281
+ port: pulumi.Input[_builtins.int]
281
282
  """
282
283
  Port the health check tries to connect to, required if protocol is `tcp`. Can be everything between `1` and `65535`. Must be unique per Load Balancer.
283
284
  """
284
- protocol: pulumi.Input[builtins.str]
285
+ protocol: pulumi.Input[_builtins.str]
285
286
  """
286
287
  Protocol the health check uses. `http` or `tcp`
287
288
  """
288
- timeout: pulumi.Input[builtins.int]
289
+ timeout: pulumi.Input[_builtins.int]
289
290
  """
290
291
  Timeout when a health check try will be canceled if there is no response, in seconds.
291
292
  """
@@ -293,7 +294,7 @@ if not MYPY:
293
294
  """
294
295
  HTTP configuration. Required if `protocol` is `http`.
295
296
  """
296
- retries: NotRequired[pulumi.Input[builtins.int]]
297
+ retries: NotRequired[pulumi.Input[_builtins.int]]
297
298
  """
298
299
  Number of tries a health check will be performed until a target will be listed as `unhealthy`.
299
300
  """
@@ -303,19 +304,19 @@ elif False:
303
304
  @pulumi.input_type
304
305
  class LoadBalancerServiceHealthCheckArgs:
305
306
  def __init__(__self__, *,
306
- interval: pulumi.Input[builtins.int],
307
- port: pulumi.Input[builtins.int],
308
- protocol: pulumi.Input[builtins.str],
309
- timeout: pulumi.Input[builtins.int],
307
+ interval: pulumi.Input[_builtins.int],
308
+ port: pulumi.Input[_builtins.int],
309
+ protocol: pulumi.Input[_builtins.str],
310
+ timeout: pulumi.Input[_builtins.int],
310
311
  http: Optional[pulumi.Input['LoadBalancerServiceHealthCheckHttpArgs']] = None,
311
- retries: Optional[pulumi.Input[builtins.int]] = None):
312
+ retries: Optional[pulumi.Input[_builtins.int]] = None):
312
313
  """
313
- :param pulumi.Input[builtins.int] interval: Interval how often the health check will be performed, in seconds.
314
- :param pulumi.Input[builtins.int] port: Port the health check tries to connect to, required if protocol is `tcp`. Can be everything between `1` and `65535`. Must be unique per Load Balancer.
315
- :param pulumi.Input[builtins.str] protocol: Protocol the health check uses. `http` or `tcp`
316
- :param pulumi.Input[builtins.int] timeout: Timeout when a health check try will be canceled if there is no response, in seconds.
314
+ :param pulumi.Input[_builtins.int] interval: Interval how often the health check will be performed, in seconds.
315
+ :param pulumi.Input[_builtins.int] port: Port the health check tries to connect to, required if protocol is `tcp`. Can be everything between `1` and `65535`. Must be unique per Load Balancer.
316
+ :param pulumi.Input[_builtins.str] protocol: Protocol the health check uses. `http` or `tcp`
317
+ :param pulumi.Input[_builtins.int] timeout: Timeout when a health check try will be canceled if there is no response, in seconds.
317
318
  :param pulumi.Input['LoadBalancerServiceHealthCheckHttpArgs'] http: HTTP configuration. Required if `protocol` is `http`.
318
- :param pulumi.Input[builtins.int] retries: Number of tries a health check will be performed until a target will be listed as `unhealthy`.
319
+ :param pulumi.Input[_builtins.int] retries: Number of tries a health check will be performed until a target will be listed as `unhealthy`.
319
320
  """
320
321
  pulumi.set(__self__, "interval", interval)
321
322
  pulumi.set(__self__, "port", port)
@@ -326,55 +327,55 @@ class LoadBalancerServiceHealthCheckArgs:
326
327
  if retries is not None:
327
328
  pulumi.set(__self__, "retries", retries)
328
329
 
329
- @property
330
+ @_builtins.property
330
331
  @pulumi.getter
331
- def interval(self) -> pulumi.Input[builtins.int]:
332
+ def interval(self) -> pulumi.Input[_builtins.int]:
332
333
  """
333
334
  Interval how often the health check will be performed, in seconds.
334
335
  """
335
336
  return pulumi.get(self, "interval")
336
337
 
337
338
  @interval.setter
338
- def interval(self, value: pulumi.Input[builtins.int]):
339
+ def interval(self, value: pulumi.Input[_builtins.int]):
339
340
  pulumi.set(self, "interval", value)
340
341
 
341
- @property
342
+ @_builtins.property
342
343
  @pulumi.getter
343
- def port(self) -> pulumi.Input[builtins.int]:
344
+ def port(self) -> pulumi.Input[_builtins.int]:
344
345
  """
345
346
  Port the health check tries to connect to, required if protocol is `tcp`. Can be everything between `1` and `65535`. Must be unique per Load Balancer.
346
347
  """
347
348
  return pulumi.get(self, "port")
348
349
 
349
350
  @port.setter
350
- def port(self, value: pulumi.Input[builtins.int]):
351
+ def port(self, value: pulumi.Input[_builtins.int]):
351
352
  pulumi.set(self, "port", value)
352
353
 
353
- @property
354
+ @_builtins.property
354
355
  @pulumi.getter
355
- def protocol(self) -> pulumi.Input[builtins.str]:
356
+ def protocol(self) -> pulumi.Input[_builtins.str]:
356
357
  """
357
358
  Protocol the health check uses. `http` or `tcp`
358
359
  """
359
360
  return pulumi.get(self, "protocol")
360
361
 
361
362
  @protocol.setter
362
- def protocol(self, value: pulumi.Input[builtins.str]):
363
+ def protocol(self, value: pulumi.Input[_builtins.str]):
363
364
  pulumi.set(self, "protocol", value)
364
365
 
365
- @property
366
+ @_builtins.property
366
367
  @pulumi.getter
367
- def timeout(self) -> pulumi.Input[builtins.int]:
368
+ def timeout(self) -> pulumi.Input[_builtins.int]:
368
369
  """
369
370
  Timeout when a health check try will be canceled if there is no response, in seconds.
370
371
  """
371
372
  return pulumi.get(self, "timeout")
372
373
 
373
374
  @timeout.setter
374
- def timeout(self, value: pulumi.Input[builtins.int]):
375
+ def timeout(self, value: pulumi.Input[_builtins.int]):
375
376
  pulumi.set(self, "timeout", value)
376
377
 
377
- @property
378
+ @_builtins.property
378
379
  @pulumi.getter
379
380
  def http(self) -> Optional[pulumi.Input['LoadBalancerServiceHealthCheckHttpArgs']]:
380
381
  """
@@ -386,38 +387,38 @@ class LoadBalancerServiceHealthCheckArgs:
386
387
  def http(self, value: Optional[pulumi.Input['LoadBalancerServiceHealthCheckHttpArgs']]):
387
388
  pulumi.set(self, "http", value)
388
389
 
389
- @property
390
+ @_builtins.property
390
391
  @pulumi.getter
391
- def retries(self) -> Optional[pulumi.Input[builtins.int]]:
392
+ def retries(self) -> Optional[pulumi.Input[_builtins.int]]:
392
393
  """
393
394
  Number of tries a health check will be performed until a target will be listed as `unhealthy`.
394
395
  """
395
396
  return pulumi.get(self, "retries")
396
397
 
397
398
  @retries.setter
398
- def retries(self, value: Optional[pulumi.Input[builtins.int]]):
399
+ def retries(self, value: Optional[pulumi.Input[_builtins.int]]):
399
400
  pulumi.set(self, "retries", value)
400
401
 
401
402
 
402
403
  if not MYPY:
403
404
  class LoadBalancerServiceHealthCheckHttpArgsDict(TypedDict):
404
- domain: NotRequired[pulumi.Input[builtins.str]]
405
+ domain: NotRequired[pulumi.Input[_builtins.str]]
405
406
  """
406
407
  Domain we try to access when performing the Health Check.
407
408
  """
408
- path: NotRequired[pulumi.Input[builtins.str]]
409
+ path: NotRequired[pulumi.Input[_builtins.str]]
409
410
  """
410
411
  Path we try to access when performing the Health Check.
411
412
  """
412
- response: NotRequired[pulumi.Input[builtins.str]]
413
+ response: NotRequired[pulumi.Input[_builtins.str]]
413
414
  """
414
415
  Response we expect to be included in the Target response when a Health Check was performed.
415
416
  """
416
- status_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
417
+ status_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
417
418
  """
418
419
  We expect that the target answers with these status codes. If not the target is marked as `unhealthy`.
419
420
  """
420
- tls: NotRequired[pulumi.Input[builtins.bool]]
421
+ tls: NotRequired[pulumi.Input[_builtins.bool]]
421
422
  """
422
423
  Enable TLS certificate checking.
423
424
  """
@@ -427,17 +428,17 @@ elif False:
427
428
  @pulumi.input_type
428
429
  class LoadBalancerServiceHealthCheckHttpArgs:
429
430
  def __init__(__self__, *,
430
- domain: Optional[pulumi.Input[builtins.str]] = None,
431
- path: Optional[pulumi.Input[builtins.str]] = None,
432
- response: Optional[pulumi.Input[builtins.str]] = None,
433
- status_codes: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
434
- tls: Optional[pulumi.Input[builtins.bool]] = None):
435
- """
436
- :param pulumi.Input[builtins.str] domain: Domain we try to access when performing the Health Check.
437
- :param pulumi.Input[builtins.str] path: Path we try to access when performing the Health Check.
438
- :param pulumi.Input[builtins.str] response: Response we expect to be included in the Target response when a Health Check was performed.
439
- :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] status_codes: We expect that the target answers with these status codes. If not the target is marked as `unhealthy`.
440
- :param pulumi.Input[builtins.bool] tls: Enable TLS certificate checking.
431
+ domain: Optional[pulumi.Input[_builtins.str]] = None,
432
+ path: Optional[pulumi.Input[_builtins.str]] = None,
433
+ response: Optional[pulumi.Input[_builtins.str]] = None,
434
+ status_codes: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
435
+ tls: Optional[pulumi.Input[_builtins.bool]] = None):
436
+ """
437
+ :param pulumi.Input[_builtins.str] domain: Domain we try to access when performing the Health Check.
438
+ :param pulumi.Input[_builtins.str] path: Path we try to access when performing the Health Check.
439
+ :param pulumi.Input[_builtins.str] response: Response we expect to be included in the Target response when a Health Check was performed.
440
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.str]]] status_codes: We expect that the target answers with these status codes. If not the target is marked as `unhealthy`.
441
+ :param pulumi.Input[_builtins.bool] tls: Enable TLS certificate checking.
441
442
  """
442
443
  if domain is not None:
443
444
  pulumi.set(__self__, "domain", domain)
@@ -450,86 +451,86 @@ class LoadBalancerServiceHealthCheckHttpArgs:
450
451
  if tls is not None:
451
452
  pulumi.set(__self__, "tls", tls)
452
453
 
453
- @property
454
+ @_builtins.property
454
455
  @pulumi.getter
455
- def domain(self) -> Optional[pulumi.Input[builtins.str]]:
456
+ def domain(self) -> Optional[pulumi.Input[_builtins.str]]:
456
457
  """
457
458
  Domain we try to access when performing the Health Check.
458
459
  """
459
460
  return pulumi.get(self, "domain")
460
461
 
461
462
  @domain.setter
462
- def domain(self, value: Optional[pulumi.Input[builtins.str]]):
463
+ def domain(self, value: Optional[pulumi.Input[_builtins.str]]):
463
464
  pulumi.set(self, "domain", value)
464
465
 
465
- @property
466
+ @_builtins.property
466
467
  @pulumi.getter
467
- def path(self) -> Optional[pulumi.Input[builtins.str]]:
468
+ def path(self) -> Optional[pulumi.Input[_builtins.str]]:
468
469
  """
469
470
  Path we try to access when performing the Health Check.
470
471
  """
471
472
  return pulumi.get(self, "path")
472
473
 
473
474
  @path.setter
474
- def path(self, value: Optional[pulumi.Input[builtins.str]]):
475
+ def path(self, value: Optional[pulumi.Input[_builtins.str]]):
475
476
  pulumi.set(self, "path", value)
476
477
 
477
- @property
478
+ @_builtins.property
478
479
  @pulumi.getter
479
- def response(self) -> Optional[pulumi.Input[builtins.str]]:
480
+ def response(self) -> Optional[pulumi.Input[_builtins.str]]:
480
481
  """
481
482
  Response we expect to be included in the Target response when a Health Check was performed.
482
483
  """
483
484
  return pulumi.get(self, "response")
484
485
 
485
486
  @response.setter
486
- def response(self, value: Optional[pulumi.Input[builtins.str]]):
487
+ def response(self, value: Optional[pulumi.Input[_builtins.str]]):
487
488
  pulumi.set(self, "response", value)
488
489
 
489
- @property
490
+ @_builtins.property
490
491
  @pulumi.getter(name="statusCodes")
491
- def status_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
492
+ def status_codes(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
492
493
  """
493
494
  We expect that the target answers with these status codes. If not the target is marked as `unhealthy`.
494
495
  """
495
496
  return pulumi.get(self, "status_codes")
496
497
 
497
498
  @status_codes.setter
498
- def status_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
499
+ def status_codes(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
499
500
  pulumi.set(self, "status_codes", value)
500
501
 
501
- @property
502
+ @_builtins.property
502
503
  @pulumi.getter
503
- def tls(self) -> Optional[pulumi.Input[builtins.bool]]:
504
+ def tls(self) -> Optional[pulumi.Input[_builtins.bool]]:
504
505
  """
505
506
  Enable TLS certificate checking.
506
507
  """
507
508
  return pulumi.get(self, "tls")
508
509
 
509
510
  @tls.setter
510
- def tls(self, value: Optional[pulumi.Input[builtins.bool]]):
511
+ def tls(self, value: Optional[pulumi.Input[_builtins.bool]]):
511
512
  pulumi.set(self, "tls", value)
512
513
 
513
514
 
514
515
  if not MYPY:
515
516
  class LoadBalancerServiceHttpArgsDict(TypedDict):
516
- certificates: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]]
517
+ certificates: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]
517
518
  """
518
519
  List of IDs from certificates which the Load Balancer has.
519
520
  """
520
- cookie_lifetime: NotRequired[pulumi.Input[builtins.int]]
521
+ cookie_lifetime: NotRequired[pulumi.Input[_builtins.int]]
521
522
  """
522
523
  Lifetime of the cookie for sticky session (in seconds). Default: `300`
523
524
  """
524
- cookie_name: NotRequired[pulumi.Input[builtins.str]]
525
+ cookie_name: NotRequired[pulumi.Input[_builtins.str]]
525
526
  """
526
527
  Name of the cookie for sticky session. Default: `HCLBSTICKY`
527
528
  """
528
- redirect_http: NotRequired[pulumi.Input[builtins.bool]]
529
+ redirect_http: NotRequired[pulumi.Input[_builtins.bool]]
529
530
  """
530
531
  Redirect HTTP to HTTPS traffic. Only supported for services with `protocol` `https` using the default HTTP port `80`.
531
532
  """
532
- sticky_sessions: NotRequired[pulumi.Input[builtins.bool]]
533
+ sticky_sessions: NotRequired[pulumi.Input[_builtins.bool]]
533
534
  """
534
535
  Enable sticky sessions
535
536
  """
@@ -539,17 +540,17 @@ elif False:
539
540
  @pulumi.input_type
540
541
  class LoadBalancerServiceHttpArgs:
541
542
  def __init__(__self__, *,
542
- certificates: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]] = None,
543
- cookie_lifetime: Optional[pulumi.Input[builtins.int]] = None,
544
- cookie_name: Optional[pulumi.Input[builtins.str]] = None,
545
- redirect_http: Optional[pulumi.Input[builtins.bool]] = None,
546
- sticky_sessions: Optional[pulumi.Input[builtins.bool]] = None):
547
- """
548
- :param pulumi.Input[Sequence[pulumi.Input[builtins.int]]] certificates: List of IDs from certificates which the Load Balancer has.
549
- :param pulumi.Input[builtins.int] cookie_lifetime: Lifetime of the cookie for sticky session (in seconds). Default: `300`
550
- :param pulumi.Input[builtins.str] cookie_name: Name of the cookie for sticky session. Default: `HCLBSTICKY`
551
- :param pulumi.Input[builtins.bool] redirect_http: Redirect HTTP to HTTPS traffic. Only supported for services with `protocol` `https` using the default HTTP port `80`.
552
- :param pulumi.Input[builtins.bool] sticky_sessions: Enable sticky sessions
543
+ certificates: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]] = None,
544
+ cookie_lifetime: Optional[pulumi.Input[_builtins.int]] = None,
545
+ cookie_name: Optional[pulumi.Input[_builtins.str]] = None,
546
+ redirect_http: Optional[pulumi.Input[_builtins.bool]] = None,
547
+ sticky_sessions: Optional[pulumi.Input[_builtins.bool]] = None):
548
+ """
549
+ :param pulumi.Input[Sequence[pulumi.Input[_builtins.int]]] certificates: List of IDs from certificates which the Load Balancer has.
550
+ :param pulumi.Input[_builtins.int] cookie_lifetime: Lifetime of the cookie for sticky session (in seconds). Default: `300`
551
+ :param pulumi.Input[_builtins.str] cookie_name: Name of the cookie for sticky session. Default: `HCLBSTICKY`
552
+ :param pulumi.Input[_builtins.bool] redirect_http: Redirect HTTP to HTTPS traffic. Only supported for services with `protocol` `https` using the default HTTP port `80`.
553
+ :param pulumi.Input[_builtins.bool] sticky_sessions: Enable sticky sessions
553
554
  """
554
555
  if certificates is not None:
555
556
  pulumi.set(__self__, "certificates", certificates)
@@ -562,86 +563,86 @@ class LoadBalancerServiceHttpArgs:
562
563
  if sticky_sessions is not None:
563
564
  pulumi.set(__self__, "sticky_sessions", sticky_sessions)
564
565
 
565
- @property
566
+ @_builtins.property
566
567
  @pulumi.getter
567
- def certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]]:
568
+ def certificates(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]:
568
569
  """
569
570
  List of IDs from certificates which the Load Balancer has.
570
571
  """
571
572
  return pulumi.get(self, "certificates")
572
573
 
573
574
  @certificates.setter
574
- def certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.int]]]]):
575
+ def certificates(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.int]]]]):
575
576
  pulumi.set(self, "certificates", value)
576
577
 
577
- @property
578
+ @_builtins.property
578
579
  @pulumi.getter(name="cookieLifetime")
579
- def cookie_lifetime(self) -> Optional[pulumi.Input[builtins.int]]:
580
+ def cookie_lifetime(self) -> Optional[pulumi.Input[_builtins.int]]:
580
581
  """
581
582
  Lifetime of the cookie for sticky session (in seconds). Default: `300`
582
583
  """
583
584
  return pulumi.get(self, "cookie_lifetime")
584
585
 
585
586
  @cookie_lifetime.setter
586
- def cookie_lifetime(self, value: Optional[pulumi.Input[builtins.int]]):
587
+ def cookie_lifetime(self, value: Optional[pulumi.Input[_builtins.int]]):
587
588
  pulumi.set(self, "cookie_lifetime", value)
588
589
 
589
- @property
590
+ @_builtins.property
590
591
  @pulumi.getter(name="cookieName")
591
- def cookie_name(self) -> Optional[pulumi.Input[builtins.str]]:
592
+ def cookie_name(self) -> Optional[pulumi.Input[_builtins.str]]:
592
593
  """
593
594
  Name of the cookie for sticky session. Default: `HCLBSTICKY`
594
595
  """
595
596
  return pulumi.get(self, "cookie_name")
596
597
 
597
598
  @cookie_name.setter
598
- def cookie_name(self, value: Optional[pulumi.Input[builtins.str]]):
599
+ def cookie_name(self, value: Optional[pulumi.Input[_builtins.str]]):
599
600
  pulumi.set(self, "cookie_name", value)
600
601
 
601
- @property
602
+ @_builtins.property
602
603
  @pulumi.getter(name="redirectHttp")
603
- def redirect_http(self) -> Optional[pulumi.Input[builtins.bool]]:
604
+ def redirect_http(self) -> Optional[pulumi.Input[_builtins.bool]]:
604
605
  """
605
606
  Redirect HTTP to HTTPS traffic. Only supported for services with `protocol` `https` using the default HTTP port `80`.
606
607
  """
607
608
  return pulumi.get(self, "redirect_http")
608
609
 
609
610
  @redirect_http.setter
610
- def redirect_http(self, value: Optional[pulumi.Input[builtins.bool]]):
611
+ def redirect_http(self, value: Optional[pulumi.Input[_builtins.bool]]):
611
612
  pulumi.set(self, "redirect_http", value)
612
613
 
613
- @property
614
+ @_builtins.property
614
615
  @pulumi.getter(name="stickySessions")
615
- def sticky_sessions(self) -> Optional[pulumi.Input[builtins.bool]]:
616
+ def sticky_sessions(self) -> Optional[pulumi.Input[_builtins.bool]]:
616
617
  """
617
618
  Enable sticky sessions
618
619
  """
619
620
  return pulumi.get(self, "sticky_sessions")
620
621
 
621
622
  @sticky_sessions.setter
622
- def sticky_sessions(self, value: Optional[pulumi.Input[builtins.bool]]):
623
+ def sticky_sessions(self, value: Optional[pulumi.Input[_builtins.bool]]):
623
624
  pulumi.set(self, "sticky_sessions", value)
624
625
 
625
626
 
626
627
  if not MYPY:
627
628
  class LoadBalancerTargetArgsDict(TypedDict):
628
- type: pulumi.Input[builtins.str]
629
+ type: pulumi.Input[_builtins.str]
629
630
  """
630
631
  (string) Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
631
632
  """
632
- server_id: NotRequired[pulumi.Input[builtins.int]]
633
- use_private_ip: NotRequired[pulumi.Input[builtins.bool]]
633
+ server_id: NotRequired[pulumi.Input[_builtins.int]]
634
+ use_private_ip: NotRequired[pulumi.Input[_builtins.bool]]
634
635
  elif False:
635
636
  LoadBalancerTargetArgsDict: TypeAlias = Mapping[str, Any]
636
637
 
637
638
  @pulumi.input_type
638
639
  class LoadBalancerTargetArgs:
639
640
  def __init__(__self__, *,
640
- type: pulumi.Input[builtins.str],
641
- server_id: Optional[pulumi.Input[builtins.int]] = None,
642
- use_private_ip: Optional[pulumi.Input[builtins.bool]] = None):
641
+ type: pulumi.Input[_builtins.str],
642
+ server_id: Optional[pulumi.Input[_builtins.int]] = None,
643
+ use_private_ip: Optional[pulumi.Input[_builtins.bool]] = None):
643
644
  """
644
- :param pulumi.Input[builtins.str] type: (string) Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
645
+ :param pulumi.Input[_builtins.str] type: (string) Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
645
646
  """
646
647
  pulumi.set(__self__, "type", type)
647
648
  if server_id is not None:
@@ -652,50 +653,50 @@ class LoadBalancerTargetArgs:
652
653
  if use_private_ip is not None:
653
654
  pulumi.set(__self__, "use_private_ip", use_private_ip)
654
655
 
655
- @property
656
+ @_builtins.property
656
657
  @pulumi.getter
657
- def type(self) -> pulumi.Input[builtins.str]:
658
+ def type(self) -> pulumi.Input[_builtins.str]:
658
659
  """
659
660
  (string) Type of the Load Balancer Algorithm. `round_robin` or `least_connections`
660
661
  """
661
662
  return pulumi.get(self, "type")
662
663
 
663
664
  @type.setter
664
- def type(self, value: pulumi.Input[builtins.str]):
665
+ def type(self, value: pulumi.Input[_builtins.str]):
665
666
  pulumi.set(self, "type", value)
666
667
 
667
- @property
668
+ @_builtins.property
668
669
  @pulumi.getter(name="serverId")
669
- def server_id(self) -> Optional[pulumi.Input[builtins.int]]:
670
+ def server_id(self) -> Optional[pulumi.Input[_builtins.int]]:
670
671
  return pulumi.get(self, "server_id")
671
672
 
672
673
  @server_id.setter
673
- def server_id(self, value: Optional[pulumi.Input[builtins.int]]):
674
+ def server_id(self, value: Optional[pulumi.Input[_builtins.int]]):
674
675
  pulumi.set(self, "server_id", value)
675
676
 
676
- @property
677
+ @_builtins.property
677
678
  @pulumi.getter(name="usePrivateIp")
678
679
  @_utilities.deprecated("""Does not work. Use the LoadBalancerTarget resource instead.""")
679
- def use_private_ip(self) -> Optional[pulumi.Input[builtins.bool]]:
680
+ def use_private_ip(self) -> Optional[pulumi.Input[_builtins.bool]]:
680
681
  return pulumi.get(self, "use_private_ip")
681
682
 
682
683
  @use_private_ip.setter
683
- def use_private_ip(self, value: Optional[pulumi.Input[builtins.bool]]):
684
+ def use_private_ip(self, value: Optional[pulumi.Input[_builtins.bool]]):
684
685
  pulumi.set(self, "use_private_ip", value)
685
686
 
686
687
 
687
688
  if not MYPY:
688
689
  class ServerNetworkArgsDict(TypedDict):
689
- network_id: pulumi.Input[builtins.int]
690
+ network_id: pulumi.Input[_builtins.int]
690
691
  """
691
692
  ID of the network
692
693
  """
693
- alias_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
694
- ip: NotRequired[pulumi.Input[builtins.str]]
694
+ alias_ips: NotRequired[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]
695
+ ip: NotRequired[pulumi.Input[_builtins.str]]
695
696
  """
696
697
  Specify the IP the server should get in the network
697
698
  """
698
- mac_address: NotRequired[pulumi.Input[builtins.str]]
699
+ mac_address: NotRequired[pulumi.Input[_builtins.str]]
699
700
  """
700
701
  (Optional, string) The MAC address the private interface of the server has
701
702
  """
@@ -705,14 +706,14 @@ elif False:
705
706
  @pulumi.input_type
706
707
  class ServerNetworkArgs:
707
708
  def __init__(__self__, *,
708
- network_id: pulumi.Input[builtins.int],
709
- alias_ips: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
710
- ip: Optional[pulumi.Input[builtins.str]] = None,
711
- mac_address: Optional[pulumi.Input[builtins.str]] = None):
709
+ network_id: pulumi.Input[_builtins.int],
710
+ alias_ips: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]] = None,
711
+ ip: Optional[pulumi.Input[_builtins.str]] = None,
712
+ mac_address: Optional[pulumi.Input[_builtins.str]] = None):
712
713
  """
713
- :param pulumi.Input[builtins.int] network_id: ID of the network
714
- :param pulumi.Input[builtins.str] ip: Specify the IP the server should get in the network
715
- :param pulumi.Input[builtins.str] mac_address: (Optional, string) The MAC address the private interface of the server has
714
+ :param pulumi.Input[_builtins.int] network_id: ID of the network
715
+ :param pulumi.Input[_builtins.str] ip: Specify the IP the server should get in the network
716
+ :param pulumi.Input[_builtins.str] mac_address: (Optional, string) The MAC address the private interface of the server has
716
717
  """
717
718
  pulumi.set(__self__, "network_id", network_id)
718
719
  if alias_ips is not None:
@@ -722,68 +723,68 @@ class ServerNetworkArgs:
722
723
  if mac_address is not None:
723
724
  pulumi.set(__self__, "mac_address", mac_address)
724
725
 
725
- @property
726
+ @_builtins.property
726
727
  @pulumi.getter(name="networkId")
727
- def network_id(self) -> pulumi.Input[builtins.int]:
728
+ def network_id(self) -> pulumi.Input[_builtins.int]:
728
729
  """
729
730
  ID of the network
730
731
  """
731
732
  return pulumi.get(self, "network_id")
732
733
 
733
734
  @network_id.setter
734
- def network_id(self, value: pulumi.Input[builtins.int]):
735
+ def network_id(self, value: pulumi.Input[_builtins.int]):
735
736
  pulumi.set(self, "network_id", value)
736
737
 
737
- @property
738
+ @_builtins.property
738
739
  @pulumi.getter(name="aliasIps")
739
- def alias_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
740
+ def alias_ips(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]:
740
741
  return pulumi.get(self, "alias_ips")
741
742
 
742
743
  @alias_ips.setter
743
- def alias_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
744
+ def alias_ips(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[_builtins.str]]]]):
744
745
  pulumi.set(self, "alias_ips", value)
745
746
 
746
- @property
747
+ @_builtins.property
747
748
  @pulumi.getter
748
- def ip(self) -> Optional[pulumi.Input[builtins.str]]:
749
+ def ip(self) -> Optional[pulumi.Input[_builtins.str]]:
749
750
  """
750
751
  Specify the IP the server should get in the network
751
752
  """
752
753
  return pulumi.get(self, "ip")
753
754
 
754
755
  @ip.setter
755
- def ip(self, value: Optional[pulumi.Input[builtins.str]]):
756
+ def ip(self, value: Optional[pulumi.Input[_builtins.str]]):
756
757
  pulumi.set(self, "ip", value)
757
758
 
758
- @property
759
+ @_builtins.property
759
760
  @pulumi.getter(name="macAddress")
760
- def mac_address(self) -> Optional[pulumi.Input[builtins.str]]:
761
+ def mac_address(self) -> Optional[pulumi.Input[_builtins.str]]:
761
762
  """
762
763
  (Optional, string) The MAC address the private interface of the server has
763
764
  """
764
765
  return pulumi.get(self, "mac_address")
765
766
 
766
767
  @mac_address.setter
767
- def mac_address(self, value: Optional[pulumi.Input[builtins.str]]):
768
+ def mac_address(self, value: Optional[pulumi.Input[_builtins.str]]):
768
769
  pulumi.set(self, "mac_address", value)
769
770
 
770
771
 
771
772
  if not MYPY:
772
773
  class ServerPublicNetArgsDict(TypedDict):
773
- ipv4: NotRequired[pulumi.Input[builtins.int]]
774
- ipv4_enabled: NotRequired[pulumi.Input[builtins.bool]]
775
- ipv6: NotRequired[pulumi.Input[builtins.int]]
776
- ipv6_enabled: NotRequired[pulumi.Input[builtins.bool]]
774
+ ipv4: NotRequired[pulumi.Input[_builtins.int]]
775
+ ipv4_enabled: NotRequired[pulumi.Input[_builtins.bool]]
776
+ ipv6: NotRequired[pulumi.Input[_builtins.int]]
777
+ ipv6_enabled: NotRequired[pulumi.Input[_builtins.bool]]
777
778
  elif False:
778
779
  ServerPublicNetArgsDict: TypeAlias = Mapping[str, Any]
779
780
 
780
781
  @pulumi.input_type
781
782
  class ServerPublicNetArgs:
782
783
  def __init__(__self__, *,
783
- ipv4: Optional[pulumi.Input[builtins.int]] = None,
784
- ipv4_enabled: Optional[pulumi.Input[builtins.bool]] = None,
785
- ipv6: Optional[pulumi.Input[builtins.int]] = None,
786
- ipv6_enabled: Optional[pulumi.Input[builtins.bool]] = None):
784
+ ipv4: Optional[pulumi.Input[_builtins.int]] = None,
785
+ ipv4_enabled: Optional[pulumi.Input[_builtins.bool]] = None,
786
+ ipv6: Optional[pulumi.Input[_builtins.int]] = None,
787
+ ipv6_enabled: Optional[pulumi.Input[_builtins.bool]] = None):
787
788
  if ipv4 is not None:
788
789
  pulumi.set(__self__, "ipv4", ipv4)
789
790
  if ipv4_enabled is not None:
@@ -793,51 +794,51 @@ class ServerPublicNetArgs:
793
794
  if ipv6_enabled is not None:
794
795
  pulumi.set(__self__, "ipv6_enabled", ipv6_enabled)
795
796
 
796
- @property
797
+ @_builtins.property
797
798
  @pulumi.getter
798
- def ipv4(self) -> Optional[pulumi.Input[builtins.int]]:
799
+ def ipv4(self) -> Optional[pulumi.Input[_builtins.int]]:
799
800
  return pulumi.get(self, "ipv4")
800
801
 
801
802
  @ipv4.setter
802
- def ipv4(self, value: Optional[pulumi.Input[builtins.int]]):
803
+ def ipv4(self, value: Optional[pulumi.Input[_builtins.int]]):
803
804
  pulumi.set(self, "ipv4", value)
804
805
 
805
- @property
806
+ @_builtins.property
806
807
  @pulumi.getter(name="ipv4Enabled")
807
- def ipv4_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
808
+ def ipv4_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
808
809
  return pulumi.get(self, "ipv4_enabled")
809
810
 
810
811
  @ipv4_enabled.setter
811
- def ipv4_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
812
+ def ipv4_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
812
813
  pulumi.set(self, "ipv4_enabled", value)
813
814
 
814
- @property
815
+ @_builtins.property
815
816
  @pulumi.getter
816
- def ipv6(self) -> Optional[pulumi.Input[builtins.int]]:
817
+ def ipv6(self) -> Optional[pulumi.Input[_builtins.int]]:
817
818
  return pulumi.get(self, "ipv6")
818
819
 
819
820
  @ipv6.setter
820
- def ipv6(self, value: Optional[pulumi.Input[builtins.int]]):
821
+ def ipv6(self, value: Optional[pulumi.Input[_builtins.int]]):
821
822
  pulumi.set(self, "ipv6", value)
822
823
 
823
- @property
824
+ @_builtins.property
824
825
  @pulumi.getter(name="ipv6Enabled")
825
- def ipv6_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
826
+ def ipv6_enabled(self) -> Optional[pulumi.Input[_builtins.bool]]:
826
827
  return pulumi.get(self, "ipv6_enabled")
827
828
 
828
829
  @ipv6_enabled.setter
829
- def ipv6_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
830
+ def ipv6_enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
830
831
  pulumi.set(self, "ipv6_enabled", value)
831
832
 
832
833
 
833
834
  if not MYPY:
834
835
  class GetFirewallApplyToArgsDict(TypedDict):
835
- label_selector: builtins.str
836
+ label_selector: _builtins.str
836
837
  """
837
838
  (string) Label Selector to select servers the firewall is applied to. Empty if a server is directly
838
839
  referenced
839
840
  """
840
- server: builtins.int
841
+ server: _builtins.int
841
842
  """
842
843
  (int) ID of a server where the firewall is applied to. `0` if applied to a label_selector
843
844
  """
@@ -847,19 +848,19 @@ elif False:
847
848
  @pulumi.input_type
848
849
  class GetFirewallApplyToArgs:
849
850
  def __init__(__self__, *,
850
- label_selector: builtins.str,
851
- server: builtins.int):
851
+ label_selector: _builtins.str,
852
+ server: _builtins.int):
852
853
  """
853
- :param builtins.str label_selector: (string) Label Selector to select servers the firewall is applied to. Empty if a server is directly
854
+ :param _builtins.str label_selector: (string) Label Selector to select servers the firewall is applied to. Empty if a server is directly
854
855
  referenced
855
- :param builtins.int server: (int) ID of a server where the firewall is applied to. `0` if applied to a label_selector
856
+ :param _builtins.int server: (int) ID of a server where the firewall is applied to. `0` if applied to a label_selector
856
857
  """
857
858
  pulumi.set(__self__, "label_selector", label_selector)
858
859
  pulumi.set(__self__, "server", server)
859
860
 
860
- @property
861
+ @_builtins.property
861
862
  @pulumi.getter(name="labelSelector")
862
- def label_selector(self) -> builtins.str:
863
+ def label_selector(self) -> _builtins.str:
863
864
  """
864
865
  (string) Label Selector to select servers the firewall is applied to. Empty if a server is directly
865
866
  referenced
@@ -867,45 +868,45 @@ class GetFirewallApplyToArgs:
867
868
  return pulumi.get(self, "label_selector")
868
869
 
869
870
  @label_selector.setter
870
- def label_selector(self, value: builtins.str):
871
+ def label_selector(self, value: _builtins.str):
871
872
  pulumi.set(self, "label_selector", value)
872
873
 
873
- @property
874
+ @_builtins.property
874
875
  @pulumi.getter
875
- def server(self) -> builtins.int:
876
+ def server(self) -> _builtins.int:
876
877
  """
877
878
  (int) ID of a server where the firewall is applied to. `0` if applied to a label_selector
878
879
  """
879
880
  return pulumi.get(self, "server")
880
881
 
881
882
  @server.setter
882
- def server(self, value: builtins.int):
883
+ def server(self, value: _builtins.int):
883
884
  pulumi.set(self, "server", value)
884
885
 
885
886
 
886
887
  if not MYPY:
887
888
  class GetFirewallRuleArgsDict(TypedDict):
888
- direction: builtins.str
889
+ direction: _builtins.str
889
890
  """
890
891
  (Required, string) Direction of the Firewall Rule. `in`, `out`
891
892
  """
892
- description: NotRequired[builtins.str]
893
+ description: NotRequired[_builtins.str]
893
894
  """
894
895
  (Optional, string) Description of the firewall rule
895
896
  """
896
- destination_ips: NotRequired[Sequence[builtins.str]]
897
+ destination_ips: NotRequired[Sequence[_builtins.str]]
897
898
  """
898
899
  (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `out`)
899
900
  """
900
- port: NotRequired[builtins.str]
901
+ port: NotRequired[_builtins.str]
901
902
  """
902
903
  (Required, string) Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`
903
904
  """
904
- protocol: NotRequired[builtins.str]
905
+ protocol: NotRequired[_builtins.str]
905
906
  """
906
907
  (Required, string) Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
907
908
  """
908
- source_ips: NotRequired[Sequence[builtins.str]]
909
+ source_ips: NotRequired[Sequence[_builtins.str]]
909
910
  """
910
911
  (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `in`)
911
912
  """
@@ -915,19 +916,19 @@ elif False:
915
916
  @pulumi.input_type
916
917
  class GetFirewallRuleArgs:
917
918
  def __init__(__self__, *,
918
- direction: builtins.str,
919
- description: Optional[builtins.str] = None,
920
- destination_ips: Optional[Sequence[builtins.str]] = None,
921
- port: Optional[builtins.str] = None,
922
- protocol: Optional[builtins.str] = None,
923
- source_ips: Optional[Sequence[builtins.str]] = None):
924
- """
925
- :param builtins.str direction: (Required, string) Direction of the Firewall Rule. `in`, `out`
926
- :param builtins.str description: (Optional, string) Description of the firewall rule
927
- :param Sequence[builtins.str] destination_ips: (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `out`)
928
- :param builtins.str port: (Required, string) Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`
929
- :param builtins.str protocol: (Required, string) Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
930
- :param Sequence[builtins.str] source_ips: (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `in`)
919
+ direction: _builtins.str,
920
+ description: Optional[_builtins.str] = None,
921
+ destination_ips: Optional[Sequence[_builtins.str]] = None,
922
+ port: Optional[_builtins.str] = None,
923
+ protocol: Optional[_builtins.str] = None,
924
+ source_ips: Optional[Sequence[_builtins.str]] = None):
925
+ """
926
+ :param _builtins.str direction: (Required, string) Direction of the Firewall Rule. `in`, `out`
927
+ :param _builtins.str description: (Optional, string) Description of the firewall rule
928
+ :param Sequence[_builtins.str] destination_ips: (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `out`)
929
+ :param _builtins.str port: (Required, string) Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`
930
+ :param _builtins.str protocol: (Required, string) Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
931
+ :param Sequence[_builtins.str] source_ips: (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `in`)
931
932
  """
932
933
  pulumi.set(__self__, "direction", direction)
933
934
  if description is not None:
@@ -941,76 +942,164 @@ class GetFirewallRuleArgs:
941
942
  if source_ips is not None:
942
943
  pulumi.set(__self__, "source_ips", source_ips)
943
944
 
944
- @property
945
+ @_builtins.property
945
946
  @pulumi.getter
946
- def direction(self) -> builtins.str:
947
+ def direction(self) -> _builtins.str:
947
948
  """
948
949
  (Required, string) Direction of the Firewall Rule. `in`, `out`
949
950
  """
950
951
  return pulumi.get(self, "direction")
951
952
 
952
953
  @direction.setter
953
- def direction(self, value: builtins.str):
954
+ def direction(self, value: _builtins.str):
954
955
  pulumi.set(self, "direction", value)
955
956
 
956
- @property
957
+ @_builtins.property
957
958
  @pulumi.getter
958
- def description(self) -> Optional[builtins.str]:
959
+ def description(self) -> Optional[_builtins.str]:
959
960
  """
960
961
  (Optional, string) Description of the firewall rule
961
962
  """
962
963
  return pulumi.get(self, "description")
963
964
 
964
965
  @description.setter
965
- def description(self, value: Optional[builtins.str]):
966
+ def description(self, value: Optional[_builtins.str]):
966
967
  pulumi.set(self, "description", value)
967
968
 
968
- @property
969
+ @_builtins.property
969
970
  @pulumi.getter(name="destinationIps")
970
- def destination_ips(self) -> Optional[Sequence[builtins.str]]:
971
+ def destination_ips(self) -> Optional[Sequence[_builtins.str]]:
971
972
  """
972
973
  (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `out`)
973
974
  """
974
975
  return pulumi.get(self, "destination_ips")
975
976
 
976
977
  @destination_ips.setter
977
- def destination_ips(self, value: Optional[Sequence[builtins.str]]):
978
+ def destination_ips(self, value: Optional[Sequence[_builtins.str]]):
978
979
  pulumi.set(self, "destination_ips", value)
979
980
 
980
- @property
981
+ @_builtins.property
981
982
  @pulumi.getter
982
- def port(self) -> Optional[builtins.str]:
983
+ def port(self) -> Optional[_builtins.str]:
983
984
  """
984
985
  (Required, string) Port of the Firewall Rule. Required when `protocol` is `tcp` or `udp`
985
986
  """
986
987
  return pulumi.get(self, "port")
987
988
 
988
989
  @port.setter
989
- def port(self, value: Optional[builtins.str]):
990
+ def port(self, value: Optional[_builtins.str]):
990
991
  pulumi.set(self, "port", value)
991
992
 
992
- @property
993
+ @_builtins.property
993
994
  @pulumi.getter
994
- def protocol(self) -> Optional[builtins.str]:
995
+ def protocol(self) -> Optional[_builtins.str]:
995
996
  """
996
997
  (Required, string) Protocol of the Firewall Rule. `tcp`, `icmp`, `udp`, `gre`, `esp`
997
998
  """
998
999
  return pulumi.get(self, "protocol")
999
1000
 
1000
1001
  @protocol.setter
1001
- def protocol(self, value: Optional[builtins.str]):
1002
+ def protocol(self, value: Optional[_builtins.str]):
1002
1003
  pulumi.set(self, "protocol", value)
1003
1004
 
1004
- @property
1005
+ @_builtins.property
1005
1006
  @pulumi.getter(name="sourceIps")
1006
- def source_ips(self) -> Optional[Sequence[builtins.str]]:
1007
+ def source_ips(self) -> Optional[Sequence[_builtins.str]]:
1007
1008
  """
1008
1009
  (Required, List) List of CIDRs that are allowed within this Firewall Rule (when `direction` is `in`)
1009
1010
  """
1010
1011
  return pulumi.get(self, "source_ips")
1011
1012
 
1012
1013
  @source_ips.setter
1013
- def source_ips(self, value: Optional[Sequence[builtins.str]]):
1014
+ def source_ips(self, value: Optional[Sequence[_builtins.str]]):
1014
1015
  pulumi.set(self, "source_ips", value)
1015
1016
 
1016
1017
 
1018
+ if not MYPY:
1019
+ class GetServerNetworkArgsDict(TypedDict):
1020
+ alias_ips: Sequence[_builtins.str]
1021
+ """
1022
+ (list) A list of alias IP addresses assigned to the server in the network.
1023
+ """
1024
+ ip: _builtins.str
1025
+ """
1026
+ (string) The server's IP address within the network.
1027
+ """
1028
+ mac_address: _builtins.str
1029
+ """
1030
+ (string) The MAC address associated with the server's private network interface.
1031
+ """
1032
+ network_id: _builtins.int
1033
+ """
1034
+ (int) The unique identifier for the network.
1035
+ """
1036
+ elif False:
1037
+ GetServerNetworkArgsDict: TypeAlias = Mapping[str, Any]
1038
+
1039
+ @pulumi.input_type
1040
+ class GetServerNetworkArgs:
1041
+ def __init__(__self__, *,
1042
+ alias_ips: Sequence[_builtins.str],
1043
+ ip: _builtins.str,
1044
+ mac_address: _builtins.str,
1045
+ network_id: _builtins.int):
1046
+ """
1047
+ :param Sequence[_builtins.str] alias_ips: (list) A list of alias IP addresses assigned to the server in the network.
1048
+ :param _builtins.str ip: (string) The server's IP address within the network.
1049
+ :param _builtins.str mac_address: (string) The MAC address associated with the server's private network interface.
1050
+ :param _builtins.int network_id: (int) The unique identifier for the network.
1051
+ """
1052
+ pulumi.set(__self__, "alias_ips", alias_ips)
1053
+ pulumi.set(__self__, "ip", ip)
1054
+ pulumi.set(__self__, "mac_address", mac_address)
1055
+ pulumi.set(__self__, "network_id", network_id)
1056
+
1057
+ @_builtins.property
1058
+ @pulumi.getter(name="aliasIps")
1059
+ def alias_ips(self) -> Sequence[_builtins.str]:
1060
+ """
1061
+ (list) A list of alias IP addresses assigned to the server in the network.
1062
+ """
1063
+ return pulumi.get(self, "alias_ips")
1064
+
1065
+ @alias_ips.setter
1066
+ def alias_ips(self, value: Sequence[_builtins.str]):
1067
+ pulumi.set(self, "alias_ips", value)
1068
+
1069
+ @_builtins.property
1070
+ @pulumi.getter
1071
+ def ip(self) -> _builtins.str:
1072
+ """
1073
+ (string) The server's IP address within the network.
1074
+ """
1075
+ return pulumi.get(self, "ip")
1076
+
1077
+ @ip.setter
1078
+ def ip(self, value: _builtins.str):
1079
+ pulumi.set(self, "ip", value)
1080
+
1081
+ @_builtins.property
1082
+ @pulumi.getter(name="macAddress")
1083
+ def mac_address(self) -> _builtins.str:
1084
+ """
1085
+ (string) The MAC address associated with the server's private network interface.
1086
+ """
1087
+ return pulumi.get(self, "mac_address")
1088
+
1089
+ @mac_address.setter
1090
+ def mac_address(self, value: _builtins.str):
1091
+ pulumi.set(self, "mac_address", value)
1092
+
1093
+ @_builtins.property
1094
+ @pulumi.getter(name="networkId")
1095
+ def network_id(self) -> _builtins.int:
1096
+ """
1097
+ (int) The unique identifier for the network.
1098
+ """
1099
+ return pulumi.get(self, "network_id")
1100
+
1101
+ @network_id.setter
1102
+ def network_id(self, value: _builtins.int):
1103
+ pulumi.set(self, "network_id", value)
1104
+
1105
+