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