pulumi-spotinst 3.117.0a1743575538__py3-none-any.whl → 3.117.0a1744183551__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.


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

Files changed (75) hide show
  1. pulumi_spotinst/__init__.py +1 -0
  2. pulumi_spotinst/_inputs.py +1181 -1180
  3. pulumi_spotinst/account.py +15 -14
  4. pulumi_spotinst/aws/__init__.py +1 -0
  5. pulumi_spotinst/aws/_inputs.py +2919 -2918
  6. pulumi_spotinst/aws/account.py +15 -14
  7. pulumi_spotinst/aws/beanstalk.py +137 -136
  8. pulumi_spotinst/aws/credentials.py +29 -28
  9. pulumi_spotinst/aws/elastigroup.py +681 -680
  10. pulumi_spotinst/aws/managed_instance.py +361 -360
  11. pulumi_spotinst/aws/mr_scalar.py +470 -469
  12. pulumi_spotinst/aws/ocean.py +399 -398
  13. pulumi_spotinst/aws/ocean_extended_resource_definition.py +29 -28
  14. pulumi_spotinst/aws/ocean_launch_spec.py +197 -196
  15. pulumi_spotinst/aws/outputs.py +1673 -1672
  16. pulumi_spotinst/aws/suspension.py +15 -14
  17. pulumi_spotinst/azure/__init__.py +1 -0
  18. pulumi_spotinst/azure/_inputs.py +489 -488
  19. pulumi_spotinst/azure/ocean_np.py +289 -288
  20. pulumi_spotinst/azure/ocean_np_virtual_node_group.py +249 -248
  21. pulumi_spotinst/azure/outputs.py +293 -292
  22. pulumi_spotinst/config/__init__.py +1 -0
  23. pulumi_spotinst/config/__init__.pyi +1 -0
  24. pulumi_spotinst/config/vars.py +1 -0
  25. pulumi_spotinst/credentials_azure.py +71 -70
  26. pulumi_spotinst/credentials_gcp.py +155 -154
  27. pulumi_spotinst/data_integration.py +29 -28
  28. pulumi_spotinst/ecs/__init__.py +1 -0
  29. pulumi_spotinst/ecs/_inputs.py +475 -474
  30. pulumi_spotinst/ecs/ocean.py +315 -314
  31. pulumi_spotinst/ecs/ocean_launch_spec.py +141 -140
  32. pulumi_spotinst/ecs/outputs.py +285 -284
  33. pulumi_spotinst/elastigroup_azure_v3.py +201 -200
  34. pulumi_spotinst/gcp/__init__.py +1 -0
  35. pulumi_spotinst/gcp/_inputs.py +400 -399
  36. pulumi_spotinst/gcp/elastigroup.py +355 -354
  37. pulumi_spotinst/gcp/outputs.py +234 -233
  38. pulumi_spotinst/gke/__init__.py +1 -0
  39. pulumi_spotinst/gke/_inputs.py +726 -725
  40. pulumi_spotinst/gke/elastigroup.py +231 -230
  41. pulumi_spotinst/gke/ocean_import.py +146 -145
  42. pulumi_spotinst/gke/ocean_launch_spec.py +141 -140
  43. pulumi_spotinst/gke/ocean_launch_spec_import.py +29 -28
  44. pulumi_spotinst/gke/outputs.py +410 -409
  45. pulumi_spotinst/health_check.py +89 -48
  46. pulumi_spotinst/ocean_right_sizing_rule.py +41 -40
  47. pulumi_spotinst/oceancd/__init__.py +1 -0
  48. pulumi_spotinst/oceancd/_inputs.py +594 -593
  49. pulumi_spotinst/oceancd/outputs.py +356 -355
  50. pulumi_spotinst/oceancd/rollout_spec.py +15 -14
  51. pulumi_spotinst/oceancd/strategy.py +11 -10
  52. pulumi_spotinst/oceancd/verification_provider.py +29 -28
  53. pulumi_spotinst/oceancd/verification_template.py +15 -14
  54. pulumi_spotinst/organization/__init__.py +1 -0
  55. pulumi_spotinst/organization/_inputs.py +55 -54
  56. pulumi_spotinst/organization/outputs.py +33 -32
  57. pulumi_spotinst/organization/policy.py +29 -28
  58. pulumi_spotinst/organization/programmatic_user.py +43 -42
  59. pulumi_spotinst/organization/user.py +85 -84
  60. pulumi_spotinst/organization/user_group.py +43 -42
  61. pulumi_spotinst/outputs.py +595 -594
  62. pulumi_spotinst/provider.py +32 -31
  63. pulumi_spotinst/pulumi-plugin.json +1 -1
  64. pulumi_spotinst/spark/__init__.py +1 -0
  65. pulumi_spotinst/spark/_inputs.py +81 -80
  66. pulumi_spotinst/spark/ocean.py +15 -14
  67. pulumi_spotinst/spark/ocean_virtual_node_group.py +21 -20
  68. pulumi_spotinst/spark/outputs.py +49 -48
  69. pulumi_spotinst/stateful_node_azure.py +191 -190
  70. pulumi_spotinst/subscription.py +71 -70
  71. {pulumi_spotinst-3.117.0a1743575538.dist-info → pulumi_spotinst-3.117.0a1744183551.dist-info}/METADATA +1 -1
  72. pulumi_spotinst-3.117.0a1744183551.dist-info/RECORD +76 -0
  73. pulumi_spotinst-3.117.0a1743575538.dist-info/RECORD +0 -76
  74. {pulumi_spotinst-3.117.0a1743575538.dist-info → pulumi_spotinst-3.117.0a1744183551.dist-info}/WHEEL +0 -0
  75. {pulumi_spotinst-3.117.0a1743575538.dist-info → pulumi_spotinst-3.117.0a1744183551.dist-info}/top_level.txt +0 -0
@@ -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
@@ -99,7 +100,7 @@ if not MYPY:
99
100
  """
100
101
  Spare resource capacity management enabling fast assignment of pods without waiting for new resources to launch.
101
102
  """
102
- autoscale_is_enabled: NotRequired[pulumi.Input[bool]]
103
+ autoscale_is_enabled: NotRequired[pulumi.Input[builtins.bool]]
103
104
  """
104
105
  Enable the Ocean Kubernetes Autoscaler.
105
106
  """
@@ -115,12 +116,12 @@ class OceanNpAutoscalerArgs:
115
116
  def __init__(__self__, *,
116
117
  autoscale_down: Optional[pulumi.Input['OceanNpAutoscalerAutoscaleDownArgs']] = None,
117
118
  autoscale_headroom: Optional[pulumi.Input['OceanNpAutoscalerAutoscaleHeadroomArgs']] = None,
118
- autoscale_is_enabled: Optional[pulumi.Input[bool]] = None,
119
+ autoscale_is_enabled: Optional[pulumi.Input[builtins.bool]] = None,
119
120
  resource_limits: Optional[pulumi.Input['OceanNpAutoscalerResourceLimitsArgs']] = None):
120
121
  """
121
122
  :param pulumi.Input['OceanNpAutoscalerAutoscaleDownArgs'] autoscale_down: Auto Scaling scale down operations.
122
123
  :param pulumi.Input['OceanNpAutoscalerAutoscaleHeadroomArgs'] autoscale_headroom: Spare resource capacity management enabling fast assignment of pods without waiting for new resources to launch.
123
- :param pulumi.Input[bool] autoscale_is_enabled: Enable the Ocean Kubernetes Autoscaler.
124
+ :param pulumi.Input[builtins.bool] autoscale_is_enabled: Enable the Ocean Kubernetes Autoscaler.
124
125
  :param pulumi.Input['OceanNpAutoscalerResourceLimitsArgs'] resource_limits: Optionally set upper and lower bounds on the resource usage of the cluster.
125
126
  """
126
127
  if autoscale_down is not None:
@@ -158,14 +159,14 @@ class OceanNpAutoscalerArgs:
158
159
 
159
160
  @property
160
161
  @pulumi.getter(name="autoscaleIsEnabled")
161
- def autoscale_is_enabled(self) -> Optional[pulumi.Input[bool]]:
162
+ def autoscale_is_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
162
163
  """
163
164
  Enable the Ocean Kubernetes Autoscaler.
164
165
  """
165
166
  return pulumi.get(self, "autoscale_is_enabled")
166
167
 
167
168
  @autoscale_is_enabled.setter
168
- def autoscale_is_enabled(self, value: Optional[pulumi.Input[bool]]):
169
+ def autoscale_is_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
169
170
  pulumi.set(self, "autoscale_is_enabled", value)
170
171
 
171
172
  @property
@@ -183,7 +184,7 @@ class OceanNpAutoscalerArgs:
183
184
 
184
185
  if not MYPY:
185
186
  class OceanNpAutoscalerAutoscaleDownArgsDict(TypedDict):
186
- max_scale_down_percentage: NotRequired[pulumi.Input[int]]
187
+ max_scale_down_percentage: NotRequired[pulumi.Input[builtins.int]]
187
188
  """
188
189
  The maximum percentage allowed to scale down in a single scaling action.
189
190
  """
@@ -193,23 +194,23 @@ elif False:
193
194
  @pulumi.input_type
194
195
  class OceanNpAutoscalerAutoscaleDownArgs:
195
196
  def __init__(__self__, *,
196
- max_scale_down_percentage: Optional[pulumi.Input[int]] = None):
197
+ max_scale_down_percentage: Optional[pulumi.Input[builtins.int]] = None):
197
198
  """
198
- :param pulumi.Input[int] max_scale_down_percentage: The maximum percentage allowed to scale down in a single scaling action.
199
+ :param pulumi.Input[builtins.int] max_scale_down_percentage: The maximum percentage allowed to scale down in a single scaling action.
199
200
  """
200
201
  if max_scale_down_percentage is not None:
201
202
  pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
202
203
 
203
204
  @property
204
205
  @pulumi.getter(name="maxScaleDownPercentage")
205
- def max_scale_down_percentage(self) -> Optional[pulumi.Input[int]]:
206
+ def max_scale_down_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
206
207
  """
207
208
  The maximum percentage allowed to scale down in a single scaling action.
208
209
  """
209
210
  return pulumi.get(self, "max_scale_down_percentage")
210
211
 
211
212
  @max_scale_down_percentage.setter
212
- def max_scale_down_percentage(self, value: Optional[pulumi.Input[int]]):
213
+ def max_scale_down_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
213
214
  pulumi.set(self, "max_scale_down_percentage", value)
214
215
 
215
216
 
@@ -247,11 +248,11 @@ class OceanNpAutoscalerAutoscaleHeadroomArgs:
247
248
 
248
249
  if not MYPY:
249
250
  class OceanNpAutoscalerAutoscaleHeadroomAutomaticArgsDict(TypedDict):
250
- is_enabled: NotRequired[pulumi.Input[bool]]
251
+ is_enabled: NotRequired[pulumi.Input[builtins.bool]]
251
252
  """
252
253
  Enable automatic headroom. When set to `true`, Ocean configures and optimizes headroom automatically.
253
254
  """
254
- percentage: NotRequired[pulumi.Input[int]]
255
+ percentage: NotRequired[pulumi.Input[builtins.int]]
255
256
  """
256
257
  Optionally set a number between 0-100 to control the percentage of total cluster resources dedicated to headroom.
257
258
  """
@@ -261,11 +262,11 @@ elif False:
261
262
  @pulumi.input_type
262
263
  class OceanNpAutoscalerAutoscaleHeadroomAutomaticArgs:
263
264
  def __init__(__self__, *,
264
- is_enabled: Optional[pulumi.Input[bool]] = None,
265
- percentage: Optional[pulumi.Input[int]] = None):
265
+ is_enabled: Optional[pulumi.Input[builtins.bool]] = None,
266
+ percentage: Optional[pulumi.Input[builtins.int]] = None):
266
267
  """
267
- :param pulumi.Input[bool] is_enabled: Enable automatic headroom. When set to `true`, Ocean configures and optimizes headroom automatically.
268
- :param pulumi.Input[int] percentage: Optionally set a number between 0-100 to control the percentage of total cluster resources dedicated to headroom.
268
+ :param pulumi.Input[builtins.bool] is_enabled: Enable automatic headroom. When set to `true`, Ocean configures and optimizes headroom automatically.
269
+ :param pulumi.Input[builtins.int] percentage: Optionally set a number between 0-100 to control the percentage of total cluster resources dedicated to headroom.
269
270
  """
270
271
  if is_enabled is not None:
271
272
  pulumi.set(__self__, "is_enabled", is_enabled)
@@ -274,36 +275,36 @@ class OceanNpAutoscalerAutoscaleHeadroomAutomaticArgs:
274
275
 
275
276
  @property
276
277
  @pulumi.getter(name="isEnabled")
277
- def is_enabled(self) -> Optional[pulumi.Input[bool]]:
278
+ def is_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
278
279
  """
279
280
  Enable automatic headroom. When set to `true`, Ocean configures and optimizes headroom automatically.
280
281
  """
281
282
  return pulumi.get(self, "is_enabled")
282
283
 
283
284
  @is_enabled.setter
284
- def is_enabled(self, value: Optional[pulumi.Input[bool]]):
285
+ def is_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
285
286
  pulumi.set(self, "is_enabled", value)
286
287
 
287
288
  @property
288
289
  @pulumi.getter
289
- def percentage(self) -> Optional[pulumi.Input[int]]:
290
+ def percentage(self) -> Optional[pulumi.Input[builtins.int]]:
290
291
  """
291
292
  Optionally set a number between 0-100 to control the percentage of total cluster resources dedicated to headroom.
292
293
  """
293
294
  return pulumi.get(self, "percentage")
294
295
 
295
296
  @percentage.setter
296
- def percentage(self, value: Optional[pulumi.Input[int]]):
297
+ def percentage(self, value: Optional[pulumi.Input[builtins.int]]):
297
298
  pulumi.set(self, "percentage", value)
298
299
 
299
300
 
300
301
  if not MYPY:
301
302
  class OceanNpAutoscalerResourceLimitsArgsDict(TypedDict):
302
- max_memory_gib: NotRequired[pulumi.Input[int]]
303
+ max_memory_gib: NotRequired[pulumi.Input[builtins.int]]
303
304
  """
304
305
  The maximum memory in GiB units that can be allocated to the cluster.
305
306
  """
306
- max_vcpu: NotRequired[pulumi.Input[int]]
307
+ max_vcpu: NotRequired[pulumi.Input[builtins.int]]
307
308
  """
308
309
  The maximum cpu in vCpu units that can be allocated to the cluster.
309
310
  """
@@ -313,11 +314,11 @@ elif False:
313
314
  @pulumi.input_type
314
315
  class OceanNpAutoscalerResourceLimitsArgs:
315
316
  def __init__(__self__, *,
316
- max_memory_gib: Optional[pulumi.Input[int]] = None,
317
- max_vcpu: Optional[pulumi.Input[int]] = None):
317
+ max_memory_gib: Optional[pulumi.Input[builtins.int]] = None,
318
+ max_vcpu: Optional[pulumi.Input[builtins.int]] = None):
318
319
  """
319
- :param pulumi.Input[int] max_memory_gib: The maximum memory in GiB units that can be allocated to the cluster.
320
- :param pulumi.Input[int] max_vcpu: The maximum cpu in vCpu units that can be allocated to the cluster.
320
+ :param pulumi.Input[builtins.int] max_memory_gib: The maximum memory in GiB units that can be allocated to the cluster.
321
+ :param pulumi.Input[builtins.int] max_vcpu: The maximum cpu in vCpu units that can be allocated to the cluster.
321
322
  """
322
323
  if max_memory_gib is not None:
323
324
  pulumi.set(__self__, "max_memory_gib", max_memory_gib)
@@ -326,88 +327,88 @@ class OceanNpAutoscalerResourceLimitsArgs:
326
327
 
327
328
  @property
328
329
  @pulumi.getter(name="maxMemoryGib")
329
- def max_memory_gib(self) -> Optional[pulumi.Input[int]]:
330
+ def max_memory_gib(self) -> Optional[pulumi.Input[builtins.int]]:
330
331
  """
331
332
  The maximum memory in GiB units that can be allocated to the cluster.
332
333
  """
333
334
  return pulumi.get(self, "max_memory_gib")
334
335
 
335
336
  @max_memory_gib.setter
336
- def max_memory_gib(self, value: Optional[pulumi.Input[int]]):
337
+ def max_memory_gib(self, value: Optional[pulumi.Input[builtins.int]]):
337
338
  pulumi.set(self, "max_memory_gib", value)
338
339
 
339
340
  @property
340
341
  @pulumi.getter(name="maxVcpu")
341
- def max_vcpu(self) -> Optional[pulumi.Input[int]]:
342
+ def max_vcpu(self) -> Optional[pulumi.Input[builtins.int]]:
342
343
  """
343
344
  The maximum cpu in vCpu units that can be allocated to the cluster.
344
345
  """
345
346
  return pulumi.get(self, "max_vcpu")
346
347
 
347
348
  @max_vcpu.setter
348
- def max_vcpu(self, value: Optional[pulumi.Input[int]]):
349
+ def max_vcpu(self, value: Optional[pulumi.Input[builtins.int]]):
349
350
  pulumi.set(self, "max_vcpu", value)
350
351
 
351
352
 
352
353
  if not MYPY:
353
354
  class OceanNpFiltersArgsDict(TypedDict):
354
- accelerated_networking: NotRequired[pulumi.Input[str]]
355
+ accelerated_networking: NotRequired[pulumi.Input[builtins.str]]
355
356
  """
356
357
  In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
357
358
  """
358
- architectures: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
359
+ architectures: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
359
360
  """
360
361
  The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
361
362
  """
362
- disk_performance: NotRequired[pulumi.Input[str]]
363
+ disk_performance: NotRequired[pulumi.Input[builtins.str]]
363
364
  """
364
365
  The filtered vm sizes will support at least one of the classes from this list.
365
366
  """
366
- exclude_series: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
367
+ exclude_series: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
367
368
  """
368
369
  Vm sizes belonging to a series from the list will not be available for scaling
369
370
  """
370
- gpu_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
371
+ gpu_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
371
372
  """
372
373
  The filtered gpu types will belong to one of the gpu types from this list.
373
374
  """
374
- max_gpu: NotRequired[pulumi.Input[float]]
375
+ max_gpu: NotRequired[pulumi.Input[builtins.float]]
375
376
  """
376
377
  Maximum number of GPUs available.
377
378
  """
378
- max_memory_gib: NotRequired[pulumi.Input[float]]
379
+ max_memory_gib: NotRequired[pulumi.Input[builtins.float]]
379
380
  """
380
381
  Maximum amount of Memory (GiB).
381
382
  """
382
- max_vcpu: NotRequired[pulumi.Input[int]]
383
+ max_vcpu: NotRequired[pulumi.Input[builtins.int]]
383
384
  """
384
385
  Maximum number of vcpus available.
385
386
  """
386
- min_disk: NotRequired[pulumi.Input[int]]
387
+ min_disk: NotRequired[pulumi.Input[builtins.int]]
387
388
  """
388
389
  Minimum number of data disks available.
389
390
  """
390
- min_gpu: NotRequired[pulumi.Input[float]]
391
+ min_gpu: NotRequired[pulumi.Input[builtins.float]]
391
392
  """
392
393
  Minimum number of GPUs available.
393
394
  """
394
- min_memory_gib: NotRequired[pulumi.Input[float]]
395
+ min_memory_gib: NotRequired[pulumi.Input[builtins.float]]
395
396
  """
396
397
  Minimum amount of Memory (GiB).
397
398
  """
398
- min_nics: NotRequired[pulumi.Input[int]]
399
+ min_nics: NotRequired[pulumi.Input[builtins.int]]
399
400
  """
400
401
  Minimum number of network interfaces.
401
402
  """
402
- min_vcpu: NotRequired[pulumi.Input[int]]
403
+ min_vcpu: NotRequired[pulumi.Input[builtins.int]]
403
404
  """
404
405
  Minimum number of vcpus available.
405
406
  """
406
- series: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
407
+ series: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
407
408
  """
408
409
  Vm sizes belonging to a series from the list will be available for scaling. We can specify include list and series can be specified with capital or small letters, with space, without space or with underscore '_' . For example all of these "DSv2", "Ds v2", "ds_v2" refer to same DS_v2 series.
409
410
  """
410
- vm_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
411
+ vm_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
411
412
  """
412
413
  The filtered vm types will belong to one of the vm types from this list.
413
414
  """
@@ -417,37 +418,37 @@ elif False:
417
418
  @pulumi.input_type
418
419
  class OceanNpFiltersArgs:
419
420
  def __init__(__self__, *,
420
- accelerated_networking: Optional[pulumi.Input[str]] = None,
421
- architectures: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
422
- disk_performance: Optional[pulumi.Input[str]] = None,
423
- exclude_series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
424
- gpu_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
425
- max_gpu: Optional[pulumi.Input[float]] = None,
426
- max_memory_gib: Optional[pulumi.Input[float]] = None,
427
- max_vcpu: Optional[pulumi.Input[int]] = None,
428
- min_disk: Optional[pulumi.Input[int]] = None,
429
- min_gpu: Optional[pulumi.Input[float]] = None,
430
- min_memory_gib: Optional[pulumi.Input[float]] = None,
431
- min_nics: Optional[pulumi.Input[int]] = None,
432
- min_vcpu: Optional[pulumi.Input[int]] = None,
433
- series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
434
- vm_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
435
- """
436
- :param pulumi.Input[str] accelerated_networking: In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
437
- :param pulumi.Input[Sequence[pulumi.Input[str]]] architectures: The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
438
- :param pulumi.Input[str] disk_performance: The filtered vm sizes will support at least one of the classes from this list.
439
- :param pulumi.Input[Sequence[pulumi.Input[str]]] exclude_series: Vm sizes belonging to a series from the list will not be available for scaling
440
- :param pulumi.Input[Sequence[pulumi.Input[str]]] gpu_types: The filtered gpu types will belong to one of the gpu types from this list.
441
- :param pulumi.Input[float] max_gpu: Maximum number of GPUs available.
442
- :param pulumi.Input[float] max_memory_gib: Maximum amount of Memory (GiB).
443
- :param pulumi.Input[int] max_vcpu: Maximum number of vcpus available.
444
- :param pulumi.Input[int] min_disk: Minimum number of data disks available.
445
- :param pulumi.Input[float] min_gpu: Minimum number of GPUs available.
446
- :param pulumi.Input[float] min_memory_gib: Minimum amount of Memory (GiB).
447
- :param pulumi.Input[int] min_nics: Minimum number of network interfaces.
448
- :param pulumi.Input[int] min_vcpu: Minimum number of vcpus available.
449
- :param pulumi.Input[Sequence[pulumi.Input[str]]] series: Vm sizes belonging to a series from the list will be available for scaling. We can specify include list and series can be specified with capital or small letters, with space, without space or with underscore '_' . For example all of these "DSv2", "Ds v2", "ds_v2" refer to same DS_v2 series.
450
- :param pulumi.Input[Sequence[pulumi.Input[str]]] vm_types: The filtered vm types will belong to one of the vm types from this list.
421
+ accelerated_networking: Optional[pulumi.Input[builtins.str]] = None,
422
+ architectures: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
423
+ disk_performance: Optional[pulumi.Input[builtins.str]] = None,
424
+ exclude_series: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
425
+ gpu_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
426
+ max_gpu: Optional[pulumi.Input[builtins.float]] = None,
427
+ max_memory_gib: Optional[pulumi.Input[builtins.float]] = None,
428
+ max_vcpu: Optional[pulumi.Input[builtins.int]] = None,
429
+ min_disk: Optional[pulumi.Input[builtins.int]] = None,
430
+ min_gpu: Optional[pulumi.Input[builtins.float]] = None,
431
+ min_memory_gib: Optional[pulumi.Input[builtins.float]] = None,
432
+ min_nics: Optional[pulumi.Input[builtins.int]] = None,
433
+ min_vcpu: Optional[pulumi.Input[builtins.int]] = None,
434
+ series: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
435
+ vm_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
436
+ """
437
+ :param pulumi.Input[builtins.str] accelerated_networking: In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
438
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] architectures: The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
439
+ :param pulumi.Input[builtins.str] disk_performance: The filtered vm sizes will support at least one of the classes from this list.
440
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] exclude_series: Vm sizes belonging to a series from the list will not be available for scaling
441
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] gpu_types: The filtered gpu types will belong to one of the gpu types from this list.
442
+ :param pulumi.Input[builtins.float] max_gpu: Maximum number of GPUs available.
443
+ :param pulumi.Input[builtins.float] max_memory_gib: Maximum amount of Memory (GiB).
444
+ :param pulumi.Input[builtins.int] max_vcpu: Maximum number of vcpus available.
445
+ :param pulumi.Input[builtins.int] min_disk: Minimum number of data disks available.
446
+ :param pulumi.Input[builtins.float] min_gpu: Minimum number of GPUs available.
447
+ :param pulumi.Input[builtins.float] min_memory_gib: Minimum amount of Memory (GiB).
448
+ :param pulumi.Input[builtins.int] min_nics: Minimum number of network interfaces.
449
+ :param pulumi.Input[builtins.int] min_vcpu: Minimum number of vcpus available.
450
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] series: Vm sizes belonging to a series from the list will be available for scaling. We can specify include list and series can be specified with capital or small letters, with space, without space or with underscore '_' . For example all of these "DSv2", "Ds v2", "ds_v2" refer to same DS_v2 series.
451
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] vm_types: The filtered vm types will belong to one of the vm types from this list.
451
452
  """
452
453
  if accelerated_networking is not None:
453
454
  pulumi.set(__self__, "accelerated_networking", accelerated_networking)
@@ -482,200 +483,200 @@ class OceanNpFiltersArgs:
482
483
 
483
484
  @property
484
485
  @pulumi.getter(name="acceleratedNetworking")
485
- def accelerated_networking(self) -> Optional[pulumi.Input[str]]:
486
+ def accelerated_networking(self) -> Optional[pulumi.Input[builtins.str]]:
486
487
  """
487
488
  In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
488
489
  """
489
490
  return pulumi.get(self, "accelerated_networking")
490
491
 
491
492
  @accelerated_networking.setter
492
- def accelerated_networking(self, value: Optional[pulumi.Input[str]]):
493
+ def accelerated_networking(self, value: Optional[pulumi.Input[builtins.str]]):
493
494
  pulumi.set(self, "accelerated_networking", value)
494
495
 
495
496
  @property
496
497
  @pulumi.getter
497
- def architectures(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
498
+ def architectures(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
498
499
  """
499
500
  The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
500
501
  """
501
502
  return pulumi.get(self, "architectures")
502
503
 
503
504
  @architectures.setter
504
- def architectures(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
505
+ def architectures(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
505
506
  pulumi.set(self, "architectures", value)
506
507
 
507
508
  @property
508
509
  @pulumi.getter(name="diskPerformance")
509
- def disk_performance(self) -> Optional[pulumi.Input[str]]:
510
+ def disk_performance(self) -> Optional[pulumi.Input[builtins.str]]:
510
511
  """
511
512
  The filtered vm sizes will support at least one of the classes from this list.
512
513
  """
513
514
  return pulumi.get(self, "disk_performance")
514
515
 
515
516
  @disk_performance.setter
516
- def disk_performance(self, value: Optional[pulumi.Input[str]]):
517
+ def disk_performance(self, value: Optional[pulumi.Input[builtins.str]]):
517
518
  pulumi.set(self, "disk_performance", value)
518
519
 
519
520
  @property
520
521
  @pulumi.getter(name="excludeSeries")
521
- def exclude_series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
522
+ def exclude_series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
522
523
  """
523
524
  Vm sizes belonging to a series from the list will not be available for scaling
524
525
  """
525
526
  return pulumi.get(self, "exclude_series")
526
527
 
527
528
  @exclude_series.setter
528
- def exclude_series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
529
+ def exclude_series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
529
530
  pulumi.set(self, "exclude_series", value)
530
531
 
531
532
  @property
532
533
  @pulumi.getter(name="gpuTypes")
533
- def gpu_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
534
+ def gpu_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
534
535
  """
535
536
  The filtered gpu types will belong to one of the gpu types from this list.
536
537
  """
537
538
  return pulumi.get(self, "gpu_types")
538
539
 
539
540
  @gpu_types.setter
540
- def gpu_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
541
+ def gpu_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
541
542
  pulumi.set(self, "gpu_types", value)
542
543
 
543
544
  @property
544
545
  @pulumi.getter(name="maxGpu")
545
- def max_gpu(self) -> Optional[pulumi.Input[float]]:
546
+ def max_gpu(self) -> Optional[pulumi.Input[builtins.float]]:
546
547
  """
547
548
  Maximum number of GPUs available.
548
549
  """
549
550
  return pulumi.get(self, "max_gpu")
550
551
 
551
552
  @max_gpu.setter
552
- def max_gpu(self, value: Optional[pulumi.Input[float]]):
553
+ def max_gpu(self, value: Optional[pulumi.Input[builtins.float]]):
553
554
  pulumi.set(self, "max_gpu", value)
554
555
 
555
556
  @property
556
557
  @pulumi.getter(name="maxMemoryGib")
557
- def max_memory_gib(self) -> Optional[pulumi.Input[float]]:
558
+ def max_memory_gib(self) -> Optional[pulumi.Input[builtins.float]]:
558
559
  """
559
560
  Maximum amount of Memory (GiB).
560
561
  """
561
562
  return pulumi.get(self, "max_memory_gib")
562
563
 
563
564
  @max_memory_gib.setter
564
- def max_memory_gib(self, value: Optional[pulumi.Input[float]]):
565
+ def max_memory_gib(self, value: Optional[pulumi.Input[builtins.float]]):
565
566
  pulumi.set(self, "max_memory_gib", value)
566
567
 
567
568
  @property
568
569
  @pulumi.getter(name="maxVcpu")
569
- def max_vcpu(self) -> Optional[pulumi.Input[int]]:
570
+ def max_vcpu(self) -> Optional[pulumi.Input[builtins.int]]:
570
571
  """
571
572
  Maximum number of vcpus available.
572
573
  """
573
574
  return pulumi.get(self, "max_vcpu")
574
575
 
575
576
  @max_vcpu.setter
576
- def max_vcpu(self, value: Optional[pulumi.Input[int]]):
577
+ def max_vcpu(self, value: Optional[pulumi.Input[builtins.int]]):
577
578
  pulumi.set(self, "max_vcpu", value)
578
579
 
579
580
  @property
580
581
  @pulumi.getter(name="minDisk")
581
- def min_disk(self) -> Optional[pulumi.Input[int]]:
582
+ def min_disk(self) -> Optional[pulumi.Input[builtins.int]]:
582
583
  """
583
584
  Minimum number of data disks available.
584
585
  """
585
586
  return pulumi.get(self, "min_disk")
586
587
 
587
588
  @min_disk.setter
588
- def min_disk(self, value: Optional[pulumi.Input[int]]):
589
+ def min_disk(self, value: Optional[pulumi.Input[builtins.int]]):
589
590
  pulumi.set(self, "min_disk", value)
590
591
 
591
592
  @property
592
593
  @pulumi.getter(name="minGpu")
593
- def min_gpu(self) -> Optional[pulumi.Input[float]]:
594
+ def min_gpu(self) -> Optional[pulumi.Input[builtins.float]]:
594
595
  """
595
596
  Minimum number of GPUs available.
596
597
  """
597
598
  return pulumi.get(self, "min_gpu")
598
599
 
599
600
  @min_gpu.setter
600
- def min_gpu(self, value: Optional[pulumi.Input[float]]):
601
+ def min_gpu(self, value: Optional[pulumi.Input[builtins.float]]):
601
602
  pulumi.set(self, "min_gpu", value)
602
603
 
603
604
  @property
604
605
  @pulumi.getter(name="minMemoryGib")
605
- def min_memory_gib(self) -> Optional[pulumi.Input[float]]:
606
+ def min_memory_gib(self) -> Optional[pulumi.Input[builtins.float]]:
606
607
  """
607
608
  Minimum amount of Memory (GiB).
608
609
  """
609
610
  return pulumi.get(self, "min_memory_gib")
610
611
 
611
612
  @min_memory_gib.setter
612
- def min_memory_gib(self, value: Optional[pulumi.Input[float]]):
613
+ def min_memory_gib(self, value: Optional[pulumi.Input[builtins.float]]):
613
614
  pulumi.set(self, "min_memory_gib", value)
614
615
 
615
616
  @property
616
617
  @pulumi.getter(name="minNics")
617
- def min_nics(self) -> Optional[pulumi.Input[int]]:
618
+ def min_nics(self) -> Optional[pulumi.Input[builtins.int]]:
618
619
  """
619
620
  Minimum number of network interfaces.
620
621
  """
621
622
  return pulumi.get(self, "min_nics")
622
623
 
623
624
  @min_nics.setter
624
- def min_nics(self, value: Optional[pulumi.Input[int]]):
625
+ def min_nics(self, value: Optional[pulumi.Input[builtins.int]]):
625
626
  pulumi.set(self, "min_nics", value)
626
627
 
627
628
  @property
628
629
  @pulumi.getter(name="minVcpu")
629
- def min_vcpu(self) -> Optional[pulumi.Input[int]]:
630
+ def min_vcpu(self) -> Optional[pulumi.Input[builtins.int]]:
630
631
  """
631
632
  Minimum number of vcpus available.
632
633
  """
633
634
  return pulumi.get(self, "min_vcpu")
634
635
 
635
636
  @min_vcpu.setter
636
- def min_vcpu(self, value: Optional[pulumi.Input[int]]):
637
+ def min_vcpu(self, value: Optional[pulumi.Input[builtins.int]]):
637
638
  pulumi.set(self, "min_vcpu", value)
638
639
 
639
640
  @property
640
641
  @pulumi.getter
641
- def series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
642
+ def series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
642
643
  """
643
644
  Vm sizes belonging to a series from the list will be available for scaling. We can specify include list and series can be specified with capital or small letters, with space, without space or with underscore '_' . For example all of these "DSv2", "Ds v2", "ds_v2" refer to same DS_v2 series.
644
645
  """
645
646
  return pulumi.get(self, "series")
646
647
 
647
648
  @series.setter
648
- def series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
649
+ def series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
649
650
  pulumi.set(self, "series", value)
650
651
 
651
652
  @property
652
653
  @pulumi.getter(name="vmTypes")
653
- def vm_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
654
+ def vm_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
654
655
  """
655
656
  The filtered vm types will belong to one of the vm types from this list.
656
657
  """
657
658
  return pulumi.get(self, "vm_types")
658
659
 
659
660
  @vm_types.setter
660
- def vm_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
661
+ def vm_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
661
662
  pulumi.set(self, "vm_types", value)
662
663
 
663
664
 
664
665
  if not MYPY:
665
666
  class OceanNpHeadroomArgsDict(TypedDict):
666
- cpu_per_unit: NotRequired[pulumi.Input[int]]
667
+ cpu_per_unit: NotRequired[pulumi.Input[builtins.int]]
667
668
  """
668
669
  Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
669
670
  """
670
- gpu_per_unit: NotRequired[pulumi.Input[int]]
671
+ gpu_per_unit: NotRequired[pulumi.Input[builtins.int]]
671
672
  """
672
673
  Amount of GPU to allocate for headroom unit.
673
674
  """
674
- memory_per_unit: NotRequired[pulumi.Input[int]]
675
+ memory_per_unit: NotRequired[pulumi.Input[builtins.int]]
675
676
  """
676
677
  Configure the amount of memory (MiB) to allocate the headroom.
677
678
  """
678
- num_of_units: NotRequired[pulumi.Input[int]]
679
+ num_of_units: NotRequired[pulumi.Input[builtins.int]]
679
680
  """
680
681
  The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
681
682
  """
@@ -685,15 +686,15 @@ elif False:
685
686
  @pulumi.input_type
686
687
  class OceanNpHeadroomArgs:
687
688
  def __init__(__self__, *,
688
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
689
- gpu_per_unit: Optional[pulumi.Input[int]] = None,
690
- memory_per_unit: Optional[pulumi.Input[int]] = None,
691
- num_of_units: Optional[pulumi.Input[int]] = None):
689
+ cpu_per_unit: Optional[pulumi.Input[builtins.int]] = None,
690
+ gpu_per_unit: Optional[pulumi.Input[builtins.int]] = None,
691
+ memory_per_unit: Optional[pulumi.Input[builtins.int]] = None,
692
+ num_of_units: Optional[pulumi.Input[builtins.int]] = None):
692
693
  """
693
- :param pulumi.Input[int] cpu_per_unit: Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
694
- :param pulumi.Input[int] gpu_per_unit: Amount of GPU to allocate for headroom unit.
695
- :param pulumi.Input[int] memory_per_unit: Configure the amount of memory (MiB) to allocate the headroom.
696
- :param pulumi.Input[int] num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
694
+ :param pulumi.Input[builtins.int] cpu_per_unit: Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
695
+ :param pulumi.Input[builtins.int] gpu_per_unit: Amount of GPU to allocate for headroom unit.
696
+ :param pulumi.Input[builtins.int] memory_per_unit: Configure the amount of memory (MiB) to allocate the headroom.
697
+ :param pulumi.Input[builtins.int] num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
697
698
  """
698
699
  if cpu_per_unit is not None:
699
700
  pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
@@ -706,56 +707,56 @@ class OceanNpHeadroomArgs:
706
707
 
707
708
  @property
708
709
  @pulumi.getter(name="cpuPerUnit")
709
- def cpu_per_unit(self) -> Optional[pulumi.Input[int]]:
710
+ def cpu_per_unit(self) -> Optional[pulumi.Input[builtins.int]]:
710
711
  """
711
712
  Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
712
713
  """
713
714
  return pulumi.get(self, "cpu_per_unit")
714
715
 
715
716
  @cpu_per_unit.setter
716
- def cpu_per_unit(self, value: Optional[pulumi.Input[int]]):
717
+ def cpu_per_unit(self, value: Optional[pulumi.Input[builtins.int]]):
717
718
  pulumi.set(self, "cpu_per_unit", value)
718
719
 
719
720
  @property
720
721
  @pulumi.getter(name="gpuPerUnit")
721
- def gpu_per_unit(self) -> Optional[pulumi.Input[int]]:
722
+ def gpu_per_unit(self) -> Optional[pulumi.Input[builtins.int]]:
722
723
  """
723
724
  Amount of GPU to allocate for headroom unit.
724
725
  """
725
726
  return pulumi.get(self, "gpu_per_unit")
726
727
 
727
728
  @gpu_per_unit.setter
728
- def gpu_per_unit(self, value: Optional[pulumi.Input[int]]):
729
+ def gpu_per_unit(self, value: Optional[pulumi.Input[builtins.int]]):
729
730
  pulumi.set(self, "gpu_per_unit", value)
730
731
 
731
732
  @property
732
733
  @pulumi.getter(name="memoryPerUnit")
733
- def memory_per_unit(self) -> Optional[pulumi.Input[int]]:
734
+ def memory_per_unit(self) -> Optional[pulumi.Input[builtins.int]]:
734
735
  """
735
736
  Configure the amount of memory (MiB) to allocate the headroom.
736
737
  """
737
738
  return pulumi.get(self, "memory_per_unit")
738
739
 
739
740
  @memory_per_unit.setter
740
- def memory_per_unit(self, value: Optional[pulumi.Input[int]]):
741
+ def memory_per_unit(self, value: Optional[pulumi.Input[builtins.int]]):
741
742
  pulumi.set(self, "memory_per_unit", value)
742
743
 
743
744
  @property
744
745
  @pulumi.getter(name="numOfUnits")
745
- def num_of_units(self) -> Optional[pulumi.Input[int]]:
746
+ def num_of_units(self) -> Optional[pulumi.Input[builtins.int]]:
746
747
  """
747
748
  The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
748
749
  """
749
750
  return pulumi.get(self, "num_of_units")
750
751
 
751
752
  @num_of_units.setter
752
- def num_of_units(self, value: Optional[pulumi.Input[int]]):
753
+ def num_of_units(self, value: Optional[pulumi.Input[builtins.int]]):
753
754
  pulumi.set(self, "num_of_units", value)
754
755
 
755
756
 
756
757
  if not MYPY:
757
758
  class OceanNpHealthArgsDict(TypedDict):
758
- grace_period: NotRequired[pulumi.Input[int]]
759
+ grace_period: NotRequired[pulumi.Input[builtins.int]]
759
760
  """
760
761
  The amount of time to wait, in seconds, from the moment the instance has launched until monitoring of its health checks begins.
761
762
  """
@@ -765,23 +766,23 @@ elif False:
765
766
  @pulumi.input_type
766
767
  class OceanNpHealthArgs:
767
768
  def __init__(__self__, *,
768
- grace_period: Optional[pulumi.Input[int]] = None):
769
+ grace_period: Optional[pulumi.Input[builtins.int]] = None):
769
770
  """
770
- :param pulumi.Input[int] grace_period: The amount of time to wait, in seconds, from the moment the instance has launched until monitoring of its health checks begins.
771
+ :param pulumi.Input[builtins.int] grace_period: The amount of time to wait, in seconds, from the moment the instance has launched until monitoring of its health checks begins.
771
772
  """
772
773
  if grace_period is not None:
773
774
  pulumi.set(__self__, "grace_period", grace_period)
774
775
 
775
776
  @property
776
777
  @pulumi.getter(name="gracePeriod")
777
- def grace_period(self) -> Optional[pulumi.Input[int]]:
778
+ def grace_period(self) -> Optional[pulumi.Input[builtins.int]]:
778
779
  """
779
780
  The amount of time to wait, in seconds, from the moment the instance has launched until monitoring of its health checks begins.
780
781
  """
781
782
  return pulumi.get(self, "grace_period")
782
783
 
783
784
  @grace_period.setter
784
- def grace_period(self, value: Optional[pulumi.Input[int]]):
785
+ def grace_period(self, value: Optional[pulumi.Input[builtins.int]]):
785
786
  pulumi.set(self, "grace_period", value)
786
787
 
787
788
 
@@ -819,7 +820,7 @@ class OceanNpLinuxOsConfigArgs:
819
820
 
820
821
  if not MYPY:
821
822
  class OceanNpLinuxOsConfigSysctlArgsDict(TypedDict):
822
- vm_max_map_count: NotRequired[pulumi.Input[int]]
823
+ vm_max_map_count: NotRequired[pulumi.Input[builtins.int]]
823
824
  """
824
825
  Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
825
826
  """
@@ -829,23 +830,23 @@ elif False:
829
830
  @pulumi.input_type
830
831
  class OceanNpLinuxOsConfigSysctlArgs:
831
832
  def __init__(__self__, *,
832
- vm_max_map_count: Optional[pulumi.Input[int]] = None):
833
+ vm_max_map_count: Optional[pulumi.Input[builtins.int]] = None):
833
834
  """
834
- :param pulumi.Input[int] vm_max_map_count: Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
835
+ :param pulumi.Input[builtins.int] vm_max_map_count: Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
835
836
  """
836
837
  if vm_max_map_count is not None:
837
838
  pulumi.set(__self__, "vm_max_map_count", vm_max_map_count)
838
839
 
839
840
  @property
840
841
  @pulumi.getter(name="vmMaxMapCount")
841
- def vm_max_map_count(self) -> Optional[pulumi.Input[int]]:
842
+ def vm_max_map_count(self) -> Optional[pulumi.Input[builtins.int]]:
842
843
  """
843
844
  Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
844
845
  """
845
846
  return pulumi.get(self, "vm_max_map_count")
846
847
 
847
848
  @vm_max_map_count.setter
848
- def vm_max_map_count(self, value: Optional[pulumi.Input[int]]):
849
+ def vm_max_map_count(self, value: Optional[pulumi.Input[builtins.int]]):
849
850
  pulumi.set(self, "vm_max_map_count", value)
850
851
 
851
852
 
@@ -915,7 +916,7 @@ class OceanNpLoggingExportArgs:
915
916
 
916
917
  if not MYPY:
917
918
  class OceanNpLoggingExportAzureBlobArgsDict(TypedDict):
918
- id: NotRequired[pulumi.Input[str]]
919
+ id: NotRequired[pulumi.Input[builtins.str]]
919
920
  """
920
921
  The identifier of The Azure Blob data integration to export the logs to.
921
922
  """
@@ -925,23 +926,23 @@ elif False:
925
926
  @pulumi.input_type
926
927
  class OceanNpLoggingExportAzureBlobArgs:
927
928
  def __init__(__self__, *,
928
- id: Optional[pulumi.Input[str]] = None):
929
+ id: Optional[pulumi.Input[builtins.str]] = None):
929
930
  """
930
- :param pulumi.Input[str] id: The identifier of The Azure Blob data integration to export the logs to.
931
+ :param pulumi.Input[builtins.str] id: The identifier of The Azure Blob data integration to export the logs to.
931
932
  """
932
933
  if id is not None:
933
934
  pulumi.set(__self__, "id", id)
934
935
 
935
936
  @property
936
937
  @pulumi.getter
937
- def id(self) -> Optional[pulumi.Input[str]]:
938
+ def id(self) -> Optional[pulumi.Input[builtins.str]]:
938
939
  """
939
940
  The identifier of The Azure Blob data integration to export the logs to.
940
941
  """
941
942
  return pulumi.get(self, "id")
942
943
 
943
944
  @id.setter
944
- def id(self, value: Optional[pulumi.Input[str]]):
945
+ def id(self, value: Optional[pulumi.Input[builtins.str]]):
945
946
  pulumi.set(self, "id", value)
946
947
 
947
948
 
@@ -1005,8 +1006,8 @@ class OceanNpSchedulingArgs:
1005
1006
 
1006
1007
  if not MYPY:
1007
1008
  class OceanNpSchedulingShutdownHoursArgsDict(TypedDict):
1008
- is_enabled: NotRequired[pulumi.Input[bool]]
1009
- time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
1009
+ is_enabled: NotRequired[pulumi.Input[builtins.bool]]
1010
+ time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
1010
1011
  """
1011
1012
  The times that the shutdown hours will apply. Required if `is_enabled` is true.
1012
1013
  """
@@ -1016,10 +1017,10 @@ elif False:
1016
1017
  @pulumi.input_type
1017
1018
  class OceanNpSchedulingShutdownHoursArgs:
1018
1019
  def __init__(__self__, *,
1019
- is_enabled: Optional[pulumi.Input[bool]] = None,
1020
- time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
1020
+ is_enabled: Optional[pulumi.Input[builtins.bool]] = None,
1021
+ time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
1021
1022
  """
1022
- :param pulumi.Input[Sequence[pulumi.Input[str]]] time_windows: The times that the shutdown hours will apply. Required if `is_enabled` is true.
1023
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] time_windows: The times that the shutdown hours will apply. Required if `is_enabled` is true.
1023
1024
  """
1024
1025
  if is_enabled is not None:
1025
1026
  pulumi.set(__self__, "is_enabled", is_enabled)
@@ -1028,30 +1029,30 @@ class OceanNpSchedulingShutdownHoursArgs:
1028
1029
 
1029
1030
  @property
1030
1031
  @pulumi.getter(name="isEnabled")
1031
- def is_enabled(self) -> Optional[pulumi.Input[bool]]:
1032
+ def is_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
1032
1033
  return pulumi.get(self, "is_enabled")
1033
1034
 
1034
1035
  @is_enabled.setter
1035
- def is_enabled(self, value: Optional[pulumi.Input[bool]]):
1036
+ def is_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
1036
1037
  pulumi.set(self, "is_enabled", value)
1037
1038
 
1038
1039
  @property
1039
1040
  @pulumi.getter(name="timeWindows")
1040
- def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
1041
+ def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
1041
1042
  """
1042
1043
  The times that the shutdown hours will apply. Required if `is_enabled` is true.
1043
1044
  """
1044
1045
  return pulumi.get(self, "time_windows")
1045
1046
 
1046
1047
  @time_windows.setter
1047
- def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
1048
+ def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
1048
1049
  pulumi.set(self, "time_windows", value)
1049
1050
 
1050
1051
 
1051
1052
  if not MYPY:
1052
1053
  class OceanNpSchedulingSuspensionHoursArgsDict(TypedDict):
1053
- is_enabled: NotRequired[pulumi.Input[bool]]
1054
- time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
1054
+ is_enabled: NotRequired[pulumi.Input[builtins.bool]]
1055
+ time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
1055
1056
  """
1056
1057
  The times that the shutdown hours will apply. Required if `is_enabled` is true.
1057
1058
  """
@@ -1061,10 +1062,10 @@ elif False:
1061
1062
  @pulumi.input_type
1062
1063
  class OceanNpSchedulingSuspensionHoursArgs:
1063
1064
  def __init__(__self__, *,
1064
- is_enabled: Optional[pulumi.Input[bool]] = None,
1065
- time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
1065
+ is_enabled: Optional[pulumi.Input[builtins.bool]] = None,
1066
+ time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
1066
1067
  """
1067
- :param pulumi.Input[Sequence[pulumi.Input[str]]] time_windows: The times that the shutdown hours will apply. Required if `is_enabled` is true.
1068
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] time_windows: The times that the shutdown hours will apply. Required if `is_enabled` is true.
1068
1069
  """
1069
1070
  if is_enabled is not None:
1070
1071
  pulumi.set(__self__, "is_enabled", is_enabled)
@@ -1073,31 +1074,31 @@ class OceanNpSchedulingSuspensionHoursArgs:
1073
1074
 
1074
1075
  @property
1075
1076
  @pulumi.getter(name="isEnabled")
1076
- def is_enabled(self) -> Optional[pulumi.Input[bool]]:
1077
+ def is_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
1077
1078
  return pulumi.get(self, "is_enabled")
1078
1079
 
1079
1080
  @is_enabled.setter
1080
- def is_enabled(self, value: Optional[pulumi.Input[bool]]):
1081
+ def is_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
1081
1082
  pulumi.set(self, "is_enabled", value)
1082
1083
 
1083
1084
  @property
1084
1085
  @pulumi.getter(name="timeWindows")
1085
- def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
1086
+ def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
1086
1087
  """
1087
1088
  The times that the shutdown hours will apply. Required if `is_enabled` is true.
1088
1089
  """
1089
1090
  return pulumi.get(self, "time_windows")
1090
1091
 
1091
1092
  @time_windows.setter
1092
- def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
1093
+ def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
1093
1094
  pulumi.set(self, "time_windows", value)
1094
1095
 
1095
1096
 
1096
1097
  if not MYPY:
1097
1098
  class OceanNpSchedulingTaskArgsDict(TypedDict):
1098
- cron_expression: pulumi.Input[str]
1099
- is_enabled: pulumi.Input[bool]
1100
- task_type: pulumi.Input[str]
1099
+ cron_expression: pulumi.Input[builtins.str]
1100
+ is_enabled: pulumi.Input[builtins.bool]
1101
+ task_type: pulumi.Input[builtins.str]
1101
1102
  parameters: NotRequired[pulumi.Input['OceanNpSchedulingTaskParametersArgsDict']]
1102
1103
  elif False:
1103
1104
  OceanNpSchedulingTaskArgsDict: TypeAlias = Mapping[str, Any]
@@ -1105,9 +1106,9 @@ elif False:
1105
1106
  @pulumi.input_type
1106
1107
  class OceanNpSchedulingTaskArgs:
1107
1108
  def __init__(__self__, *,
1108
- cron_expression: pulumi.Input[str],
1109
- is_enabled: pulumi.Input[bool],
1110
- task_type: pulumi.Input[str],
1109
+ cron_expression: pulumi.Input[builtins.str],
1110
+ is_enabled: pulumi.Input[builtins.bool],
1111
+ task_type: pulumi.Input[builtins.str],
1111
1112
  parameters: Optional[pulumi.Input['OceanNpSchedulingTaskParametersArgs']] = None):
1112
1113
  pulumi.set(__self__, "cron_expression", cron_expression)
1113
1114
  pulumi.set(__self__, "is_enabled", is_enabled)
@@ -1117,29 +1118,29 @@ class OceanNpSchedulingTaskArgs:
1117
1118
 
1118
1119
  @property
1119
1120
  @pulumi.getter(name="cronExpression")
1120
- def cron_expression(self) -> pulumi.Input[str]:
1121
+ def cron_expression(self) -> pulumi.Input[builtins.str]:
1121
1122
  return pulumi.get(self, "cron_expression")
1122
1123
 
1123
1124
  @cron_expression.setter
1124
- def cron_expression(self, value: pulumi.Input[str]):
1125
+ def cron_expression(self, value: pulumi.Input[builtins.str]):
1125
1126
  pulumi.set(self, "cron_expression", value)
1126
1127
 
1127
1128
  @property
1128
1129
  @pulumi.getter(name="isEnabled")
1129
- def is_enabled(self) -> pulumi.Input[bool]:
1130
+ def is_enabled(self) -> pulumi.Input[builtins.bool]:
1130
1131
  return pulumi.get(self, "is_enabled")
1131
1132
 
1132
1133
  @is_enabled.setter
1133
- def is_enabled(self, value: pulumi.Input[bool]):
1134
+ def is_enabled(self, value: pulumi.Input[builtins.bool]):
1134
1135
  pulumi.set(self, "is_enabled", value)
1135
1136
 
1136
1137
  @property
1137
1138
  @pulumi.getter(name="taskType")
1138
- def task_type(self) -> pulumi.Input[str]:
1139
+ def task_type(self) -> pulumi.Input[builtins.str]:
1139
1140
  return pulumi.get(self, "task_type")
1140
1141
 
1141
1142
  @task_type.setter
1142
- def task_type(self, value: pulumi.Input[str]):
1143
+ def task_type(self, value: pulumi.Input[builtins.str]):
1143
1144
  pulumi.set(self, "task_type", value)
1144
1145
 
1145
1146
  @property
@@ -1190,27 +1191,27 @@ class OceanNpSchedulingTaskParametersArgs:
1190
1191
 
1191
1192
  if not MYPY:
1192
1193
  class OceanNpSchedulingTaskParametersParametersClusterRollArgsDict(TypedDict):
1193
- batch_min_healthy_percentage: NotRequired[pulumi.Input[int]]
1194
+ batch_min_healthy_percentage: NotRequired[pulumi.Input[builtins.int]]
1194
1195
  """
1195
1196
  Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
1196
1197
  """
1197
- batch_size_percentage: NotRequired[pulumi.Input[int]]
1198
+ batch_size_percentage: NotRequired[pulumi.Input[builtins.int]]
1198
1199
  """
1199
1200
  Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
1200
1201
  """
1201
- comment: NotRequired[pulumi.Input[str]]
1202
+ comment: NotRequired[pulumi.Input[builtins.str]]
1202
1203
  """
1203
1204
  Add a comment description for the roll. The comment is limited to 256 chars and optional.
1204
1205
  """
1205
- respect_pdb: NotRequired[pulumi.Input[bool]]
1206
+ respect_pdb: NotRequired[pulumi.Input[builtins.bool]]
1206
1207
  """
1207
1208
  During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
1208
1209
  """
1209
- respect_restrict_scale_down: NotRequired[pulumi.Input[bool]]
1210
+ respect_restrict_scale_down: NotRequired[pulumi.Input[builtins.bool]]
1210
1211
  """
1211
1212
  During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
1212
1213
  """
1213
- vng_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
1214
+ vng_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
1214
1215
  """
1215
1216
  List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
1216
1217
  """
@@ -1220,19 +1221,19 @@ elif False:
1220
1221
  @pulumi.input_type
1221
1222
  class OceanNpSchedulingTaskParametersParametersClusterRollArgs:
1222
1223
  def __init__(__self__, *,
1223
- batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
1224
- batch_size_percentage: Optional[pulumi.Input[int]] = None,
1225
- comment: Optional[pulumi.Input[str]] = None,
1226
- respect_pdb: Optional[pulumi.Input[bool]] = None,
1227
- respect_restrict_scale_down: Optional[pulumi.Input[bool]] = None,
1228
- vng_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
1229
- """
1230
- :param pulumi.Input[int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
1231
- :param pulumi.Input[int] batch_size_percentage: Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
1232
- :param pulumi.Input[str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
1233
- :param pulumi.Input[bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
1234
- :param pulumi.Input[bool] respect_restrict_scale_down: During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
1235
- :param pulumi.Input[Sequence[pulumi.Input[str]]] vng_ids: List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
1224
+ batch_min_healthy_percentage: Optional[pulumi.Input[builtins.int]] = None,
1225
+ batch_size_percentage: Optional[pulumi.Input[builtins.int]] = None,
1226
+ comment: Optional[pulumi.Input[builtins.str]] = None,
1227
+ respect_pdb: Optional[pulumi.Input[builtins.bool]] = None,
1228
+ respect_restrict_scale_down: Optional[pulumi.Input[builtins.bool]] = None,
1229
+ vng_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
1230
+ """
1231
+ :param pulumi.Input[builtins.int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
1232
+ :param pulumi.Input[builtins.int] batch_size_percentage: Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
1233
+ :param pulumi.Input[builtins.str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
1234
+ :param pulumi.Input[builtins.bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
1235
+ :param pulumi.Input[builtins.bool] respect_restrict_scale_down: During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
1236
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] vng_ids: List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
1236
1237
  """
1237
1238
  if batch_min_healthy_percentage is not None:
1238
1239
  pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
@@ -1249,91 +1250,91 @@ class OceanNpSchedulingTaskParametersParametersClusterRollArgs:
1249
1250
 
1250
1251
  @property
1251
1252
  @pulumi.getter(name="batchMinHealthyPercentage")
1252
- def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[int]]:
1253
+ def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
1253
1254
  """
1254
1255
  Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
1255
1256
  """
1256
1257
  return pulumi.get(self, "batch_min_healthy_percentage")
1257
1258
 
1258
1259
  @batch_min_healthy_percentage.setter
1259
- def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[int]]):
1260
+ def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
1260
1261
  pulumi.set(self, "batch_min_healthy_percentage", value)
1261
1262
 
1262
1263
  @property
1263
1264
  @pulumi.getter(name="batchSizePercentage")
1264
- def batch_size_percentage(self) -> Optional[pulumi.Input[int]]:
1265
+ def batch_size_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
1265
1266
  """
1266
1267
  Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
1267
1268
  """
1268
1269
  return pulumi.get(self, "batch_size_percentage")
1269
1270
 
1270
1271
  @batch_size_percentage.setter
1271
- def batch_size_percentage(self, value: Optional[pulumi.Input[int]]):
1272
+ def batch_size_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
1272
1273
  pulumi.set(self, "batch_size_percentage", value)
1273
1274
 
1274
1275
  @property
1275
1276
  @pulumi.getter
1276
- def comment(self) -> Optional[pulumi.Input[str]]:
1277
+ def comment(self) -> Optional[pulumi.Input[builtins.str]]:
1277
1278
  """
1278
1279
  Add a comment description for the roll. The comment is limited to 256 chars and optional.
1279
1280
  """
1280
1281
  return pulumi.get(self, "comment")
1281
1282
 
1282
1283
  @comment.setter
1283
- def comment(self, value: Optional[pulumi.Input[str]]):
1284
+ def comment(self, value: Optional[pulumi.Input[builtins.str]]):
1284
1285
  pulumi.set(self, "comment", value)
1285
1286
 
1286
1287
  @property
1287
1288
  @pulumi.getter(name="respectPdb")
1288
- def respect_pdb(self) -> Optional[pulumi.Input[bool]]:
1289
+ def respect_pdb(self) -> Optional[pulumi.Input[builtins.bool]]:
1289
1290
  """
1290
1291
  During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
1291
1292
  """
1292
1293
  return pulumi.get(self, "respect_pdb")
1293
1294
 
1294
1295
  @respect_pdb.setter
1295
- def respect_pdb(self, value: Optional[pulumi.Input[bool]]):
1296
+ def respect_pdb(self, value: Optional[pulumi.Input[builtins.bool]]):
1296
1297
  pulumi.set(self, "respect_pdb", value)
1297
1298
 
1298
1299
  @property
1299
1300
  @pulumi.getter(name="respectRestrictScaleDown")
1300
- def respect_restrict_scale_down(self) -> Optional[pulumi.Input[bool]]:
1301
+ def respect_restrict_scale_down(self) -> Optional[pulumi.Input[builtins.bool]]:
1301
1302
  """
1302
1303
  During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
1303
1304
  """
1304
1305
  return pulumi.get(self, "respect_restrict_scale_down")
1305
1306
 
1306
1307
  @respect_restrict_scale_down.setter
1307
- def respect_restrict_scale_down(self, value: Optional[pulumi.Input[bool]]):
1308
+ def respect_restrict_scale_down(self, value: Optional[pulumi.Input[builtins.bool]]):
1308
1309
  pulumi.set(self, "respect_restrict_scale_down", value)
1309
1310
 
1310
1311
  @property
1311
1312
  @pulumi.getter(name="vngIds")
1312
- def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
1313
+ def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
1313
1314
  """
1314
1315
  List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
1315
1316
  """
1316
1317
  return pulumi.get(self, "vng_ids")
1317
1318
 
1318
1319
  @vng_ids.setter
1319
- def vng_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
1320
+ def vng_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
1320
1321
  pulumi.set(self, "vng_ids", value)
1321
1322
 
1322
1323
 
1323
1324
  if not MYPY:
1324
1325
  class OceanNpSchedulingTaskParametersParametersUpgradeConfigArgsDict(TypedDict):
1325
- apply_roll: NotRequired[pulumi.Input[bool]]
1326
+ apply_roll: NotRequired[pulumi.Input[builtins.bool]]
1326
1327
  roll_parameters: NotRequired[pulumi.Input['OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgsDict']]
1327
- scope_version: NotRequired[pulumi.Input[str]]
1328
+ scope_version: NotRequired[pulumi.Input[builtins.str]]
1328
1329
  elif False:
1329
1330
  OceanNpSchedulingTaskParametersParametersUpgradeConfigArgsDict: TypeAlias = Mapping[str, Any]
1330
1331
 
1331
1332
  @pulumi.input_type
1332
1333
  class OceanNpSchedulingTaskParametersParametersUpgradeConfigArgs:
1333
1334
  def __init__(__self__, *,
1334
- apply_roll: Optional[pulumi.Input[bool]] = None,
1335
+ apply_roll: Optional[pulumi.Input[builtins.bool]] = None,
1335
1336
  roll_parameters: Optional[pulumi.Input['OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgs']] = None,
1336
- scope_version: Optional[pulumi.Input[str]] = None):
1337
+ scope_version: Optional[pulumi.Input[builtins.str]] = None):
1337
1338
  if apply_roll is not None:
1338
1339
  pulumi.set(__self__, "apply_roll", apply_roll)
1339
1340
  if roll_parameters is not None:
@@ -1343,11 +1344,11 @@ class OceanNpSchedulingTaskParametersParametersUpgradeConfigArgs:
1343
1344
 
1344
1345
  @property
1345
1346
  @pulumi.getter(name="applyRoll")
1346
- def apply_roll(self) -> Optional[pulumi.Input[bool]]:
1347
+ def apply_roll(self) -> Optional[pulumi.Input[builtins.bool]]:
1347
1348
  return pulumi.get(self, "apply_roll")
1348
1349
 
1349
1350
  @apply_roll.setter
1350
- def apply_roll(self, value: Optional[pulumi.Input[bool]]):
1351
+ def apply_roll(self, value: Optional[pulumi.Input[builtins.bool]]):
1351
1352
  pulumi.set(self, "apply_roll", value)
1352
1353
 
1353
1354
  @property
@@ -1361,33 +1362,33 @@ class OceanNpSchedulingTaskParametersParametersUpgradeConfigArgs:
1361
1362
 
1362
1363
  @property
1363
1364
  @pulumi.getter(name="scopeVersion")
1364
- def scope_version(self) -> Optional[pulumi.Input[str]]:
1365
+ def scope_version(self) -> Optional[pulumi.Input[builtins.str]]:
1365
1366
  return pulumi.get(self, "scope_version")
1366
1367
 
1367
1368
  @scope_version.setter
1368
- def scope_version(self, value: Optional[pulumi.Input[str]]):
1369
+ def scope_version(self, value: Optional[pulumi.Input[builtins.str]]):
1369
1370
  pulumi.set(self, "scope_version", value)
1370
1371
 
1371
1372
 
1372
1373
  if not MYPY:
1373
1374
  class OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgsDict(TypedDict):
1374
- batch_min_healthy_percentage: NotRequired[pulumi.Input[int]]
1375
+ batch_min_healthy_percentage: NotRequired[pulumi.Input[builtins.int]]
1375
1376
  """
1376
1377
  Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
1377
1378
  """
1378
- batch_size_percentage: NotRequired[pulumi.Input[int]]
1379
+ batch_size_percentage: NotRequired[pulumi.Input[builtins.int]]
1379
1380
  """
1380
1381
  Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
1381
1382
  """
1382
- comment: NotRequired[pulumi.Input[str]]
1383
+ comment: NotRequired[pulumi.Input[builtins.str]]
1383
1384
  """
1384
1385
  Add a comment description for the roll. The comment is limited to 256 chars and optional.
1385
1386
  """
1386
- respect_pdb: NotRequired[pulumi.Input[bool]]
1387
+ respect_pdb: NotRequired[pulumi.Input[builtins.bool]]
1387
1388
  """
1388
1389
  During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
1389
1390
  """
1390
- respect_restrict_scale_down: NotRequired[pulumi.Input[bool]]
1391
+ respect_restrict_scale_down: NotRequired[pulumi.Input[builtins.bool]]
1391
1392
  """
1392
1393
  During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
1393
1394
  """
@@ -1397,17 +1398,17 @@ elif False:
1397
1398
  @pulumi.input_type
1398
1399
  class OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgs:
1399
1400
  def __init__(__self__, *,
1400
- batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
1401
- batch_size_percentage: Optional[pulumi.Input[int]] = None,
1402
- comment: Optional[pulumi.Input[str]] = None,
1403
- respect_pdb: Optional[pulumi.Input[bool]] = None,
1404
- respect_restrict_scale_down: Optional[pulumi.Input[bool]] = None):
1405
- """
1406
- :param pulumi.Input[int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
1407
- :param pulumi.Input[int] batch_size_percentage: Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
1408
- :param pulumi.Input[str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
1409
- :param pulumi.Input[bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
1410
- :param pulumi.Input[bool] respect_restrict_scale_down: During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
1401
+ batch_min_healthy_percentage: Optional[pulumi.Input[builtins.int]] = None,
1402
+ batch_size_percentage: Optional[pulumi.Input[builtins.int]] = None,
1403
+ comment: Optional[pulumi.Input[builtins.str]] = None,
1404
+ respect_pdb: Optional[pulumi.Input[builtins.bool]] = None,
1405
+ respect_restrict_scale_down: Optional[pulumi.Input[builtins.bool]] = None):
1406
+ """
1407
+ :param pulumi.Input[builtins.int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
1408
+ :param pulumi.Input[builtins.int] batch_size_percentage: Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
1409
+ :param pulumi.Input[builtins.str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
1410
+ :param pulumi.Input[builtins.bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
1411
+ :param pulumi.Input[builtins.bool] respect_restrict_scale_down: During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
1411
1412
  """
1412
1413
  if batch_min_healthy_percentage is not None:
1413
1414
  pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
@@ -1422,76 +1423,76 @@ class OceanNpSchedulingTaskParametersParametersUpgradeConfigRollParametersArgs:
1422
1423
 
1423
1424
  @property
1424
1425
  @pulumi.getter(name="batchMinHealthyPercentage")
1425
- def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[int]]:
1426
+ def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
1426
1427
  """
1427
1428
  Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
1428
1429
  """
1429
1430
  return pulumi.get(self, "batch_min_healthy_percentage")
1430
1431
 
1431
1432
  @batch_min_healthy_percentage.setter
1432
- def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[int]]):
1433
+ def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
1433
1434
  pulumi.set(self, "batch_min_healthy_percentage", value)
1434
1435
 
1435
1436
  @property
1436
1437
  @pulumi.getter(name="batchSizePercentage")
1437
- def batch_size_percentage(self) -> Optional[pulumi.Input[int]]:
1438
+ def batch_size_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
1438
1439
  """
1439
1440
  Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
1440
1441
  """
1441
1442
  return pulumi.get(self, "batch_size_percentage")
1442
1443
 
1443
1444
  @batch_size_percentage.setter
1444
- def batch_size_percentage(self, value: Optional[pulumi.Input[int]]):
1445
+ def batch_size_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
1445
1446
  pulumi.set(self, "batch_size_percentage", value)
1446
1447
 
1447
1448
  @property
1448
1449
  @pulumi.getter
1449
- def comment(self) -> Optional[pulumi.Input[str]]:
1450
+ def comment(self) -> Optional[pulumi.Input[builtins.str]]:
1450
1451
  """
1451
1452
  Add a comment description for the roll. The comment is limited to 256 chars and optional.
1452
1453
  """
1453
1454
  return pulumi.get(self, "comment")
1454
1455
 
1455
1456
  @comment.setter
1456
- def comment(self, value: Optional[pulumi.Input[str]]):
1457
+ def comment(self, value: Optional[pulumi.Input[builtins.str]]):
1457
1458
  pulumi.set(self, "comment", value)
1458
1459
 
1459
1460
  @property
1460
1461
  @pulumi.getter(name="respectPdb")
1461
- def respect_pdb(self) -> Optional[pulumi.Input[bool]]:
1462
+ def respect_pdb(self) -> Optional[pulumi.Input[builtins.bool]]:
1462
1463
  """
1463
1464
  During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
1464
1465
  """
1465
1466
  return pulumi.get(self, "respect_pdb")
1466
1467
 
1467
1468
  @respect_pdb.setter
1468
- def respect_pdb(self, value: Optional[pulumi.Input[bool]]):
1469
+ def respect_pdb(self, value: Optional[pulumi.Input[builtins.bool]]):
1469
1470
  pulumi.set(self, "respect_pdb", value)
1470
1471
 
1471
1472
  @property
1472
1473
  @pulumi.getter(name="respectRestrictScaleDown")
1473
- def respect_restrict_scale_down(self) -> Optional[pulumi.Input[bool]]:
1474
+ def respect_restrict_scale_down(self) -> Optional[pulumi.Input[builtins.bool]]:
1474
1475
  """
1475
1476
  During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
1476
1477
  """
1477
1478
  return pulumi.get(self, "respect_restrict_scale_down")
1478
1479
 
1479
1480
  @respect_restrict_scale_down.setter
1480
- def respect_restrict_scale_down(self, value: Optional[pulumi.Input[bool]]):
1481
+ def respect_restrict_scale_down(self, value: Optional[pulumi.Input[builtins.bool]]):
1481
1482
  pulumi.set(self, "respect_restrict_scale_down", value)
1482
1483
 
1483
1484
 
1484
1485
  if not MYPY:
1485
1486
  class OceanNpTaintArgsDict(TypedDict):
1486
- effect: pulumi.Input[str]
1487
+ effect: pulumi.Input[builtins.str]
1487
1488
  """
1488
1489
  Set taint effect.
1489
1490
  """
1490
- key: pulumi.Input[str]
1491
+ key: pulumi.Input[builtins.str]
1491
1492
  """
1492
1493
  Set taint key. The following taint keys are not allowed: ["node.kubernetes.io/not-ready", "node.kubernetes.io/unreachable", "node.kubernetes.io/unschedulable", "node.kubernetes.io/memory-pressure", "node.kubernetes.io/disk-pressure", "node.kubernetes.io/network-unavailable", "node.kubernetes.io/pid-pressure", "node.kubernetes.io/out-of-service", "node.cloudprovider.kubernetes.io/uninitialized", "node.cloudprovider.kubernetes.io/shutdown", "kubernetes.azure.com/scalesetpriority"]
1493
1494
  """
1494
- value: pulumi.Input[str]
1495
+ value: pulumi.Input[builtins.str]
1495
1496
  """
1496
1497
  Set taint value.
1497
1498
  """
@@ -1501,13 +1502,13 @@ elif False:
1501
1502
  @pulumi.input_type
1502
1503
  class OceanNpTaintArgs:
1503
1504
  def __init__(__self__, *,
1504
- effect: pulumi.Input[str],
1505
- key: pulumi.Input[str],
1506
- value: pulumi.Input[str]):
1505
+ effect: pulumi.Input[builtins.str],
1506
+ key: pulumi.Input[builtins.str],
1507
+ value: pulumi.Input[builtins.str]):
1507
1508
  """
1508
- :param pulumi.Input[str] effect: Set taint effect.
1509
- :param pulumi.Input[str] key: Set taint key. The following taint keys are not allowed: ["node.kubernetes.io/not-ready", "node.kubernetes.io/unreachable", "node.kubernetes.io/unschedulable", "node.kubernetes.io/memory-pressure", "node.kubernetes.io/disk-pressure", "node.kubernetes.io/network-unavailable", "node.kubernetes.io/pid-pressure", "node.kubernetes.io/out-of-service", "node.cloudprovider.kubernetes.io/uninitialized", "node.cloudprovider.kubernetes.io/shutdown", "kubernetes.azure.com/scalesetpriority"]
1510
- :param pulumi.Input[str] value: Set taint value.
1509
+ :param pulumi.Input[builtins.str] effect: Set taint effect.
1510
+ :param pulumi.Input[builtins.str] key: Set taint key. The following taint keys are not allowed: ["node.kubernetes.io/not-ready", "node.kubernetes.io/unreachable", "node.kubernetes.io/unschedulable", "node.kubernetes.io/memory-pressure", "node.kubernetes.io/disk-pressure", "node.kubernetes.io/network-unavailable", "node.kubernetes.io/pid-pressure", "node.kubernetes.io/out-of-service", "node.cloudprovider.kubernetes.io/uninitialized", "node.cloudprovider.kubernetes.io/shutdown", "kubernetes.azure.com/scalesetpriority"]
1511
+ :param pulumi.Input[builtins.str] value: Set taint value.
1511
1512
  """
1512
1513
  pulumi.set(__self__, "effect", effect)
1513
1514
  pulumi.set(__self__, "key", key)
@@ -1515,48 +1516,48 @@ class OceanNpTaintArgs:
1515
1516
 
1516
1517
  @property
1517
1518
  @pulumi.getter
1518
- def effect(self) -> pulumi.Input[str]:
1519
+ def effect(self) -> pulumi.Input[builtins.str]:
1519
1520
  """
1520
1521
  Set taint effect.
1521
1522
  """
1522
1523
  return pulumi.get(self, "effect")
1523
1524
 
1524
1525
  @effect.setter
1525
- def effect(self, value: pulumi.Input[str]):
1526
+ def effect(self, value: pulumi.Input[builtins.str]):
1526
1527
  pulumi.set(self, "effect", value)
1527
1528
 
1528
1529
  @property
1529
1530
  @pulumi.getter
1530
- def key(self) -> pulumi.Input[str]:
1531
+ def key(self) -> pulumi.Input[builtins.str]:
1531
1532
  """
1532
1533
  Set taint key. The following taint keys are not allowed: ["node.kubernetes.io/not-ready", "node.kubernetes.io/unreachable", "node.kubernetes.io/unschedulable", "node.kubernetes.io/memory-pressure", "node.kubernetes.io/disk-pressure", "node.kubernetes.io/network-unavailable", "node.kubernetes.io/pid-pressure", "node.kubernetes.io/out-of-service", "node.cloudprovider.kubernetes.io/uninitialized", "node.cloudprovider.kubernetes.io/shutdown", "kubernetes.azure.com/scalesetpriority"]
1533
1534
  """
1534
1535
  return pulumi.get(self, "key")
1535
1536
 
1536
1537
  @key.setter
1537
- def key(self, value: pulumi.Input[str]):
1538
+ def key(self, value: pulumi.Input[builtins.str]):
1538
1539
  pulumi.set(self, "key", value)
1539
1540
 
1540
1541
  @property
1541
1542
  @pulumi.getter
1542
- def value(self) -> pulumi.Input[str]:
1543
+ def value(self) -> pulumi.Input[builtins.str]:
1543
1544
  """
1544
1545
  Set taint value.
1545
1546
  """
1546
1547
  return pulumi.get(self, "value")
1547
1548
 
1548
1549
  @value.setter
1549
- def value(self, value: pulumi.Input[str]):
1550
+ def value(self, value: pulumi.Input[builtins.str]):
1550
1551
  pulumi.set(self, "value", value)
1551
1552
 
1552
1553
 
1553
1554
  if not MYPY:
1554
1555
  class OceanNpUpdatePolicyArgsDict(TypedDict):
1555
- should_roll: pulumi.Input[bool]
1556
+ should_roll: pulumi.Input[builtins.bool]
1556
1557
  """
1557
1558
  If set to true along with the cluster update, roll will be triggered.
1558
1559
  """
1559
- conditioned_roll: NotRequired[pulumi.Input[bool]]
1560
+ conditioned_roll: NotRequired[pulumi.Input[builtins.bool]]
1560
1561
  """
1561
1562
  Spot will perform a cluster Roll in accordance with a relevant modification of the cluster’s settings. When set to true , only specific changes in the cluster’s configuration will trigger a cluster roll (such as availability_zones, max_pods_per_node, enable_node_public_ip, os_disk_size_gb, os_disk_type, os_sku, kubernetes_version, vnet_subnet_ids, pod_subnet_ids, labels, taints and tags).
1562
1563
  """
@@ -1570,12 +1571,12 @@ elif False:
1570
1571
  @pulumi.input_type
1571
1572
  class OceanNpUpdatePolicyArgs:
1572
1573
  def __init__(__self__, *,
1573
- should_roll: pulumi.Input[bool],
1574
- conditioned_roll: Optional[pulumi.Input[bool]] = None,
1574
+ should_roll: pulumi.Input[builtins.bool],
1575
+ conditioned_roll: Optional[pulumi.Input[builtins.bool]] = None,
1575
1576
  roll_config: Optional[pulumi.Input['OceanNpUpdatePolicyRollConfigArgs']] = None):
1576
1577
  """
1577
- :param pulumi.Input[bool] should_roll: If set to true along with the cluster update, roll will be triggered.
1578
- :param pulumi.Input[bool] conditioned_roll: Spot will perform a cluster Roll in accordance with a relevant modification of the cluster’s settings. When set to true , only specific changes in the cluster’s configuration will trigger a cluster roll (such as availability_zones, max_pods_per_node, enable_node_public_ip, os_disk_size_gb, os_disk_type, os_sku, kubernetes_version, vnet_subnet_ids, pod_subnet_ids, labels, taints and tags).
1578
+ :param pulumi.Input[builtins.bool] should_roll: If set to true along with the cluster update, roll will be triggered.
1579
+ :param pulumi.Input[builtins.bool] conditioned_roll: Spot will perform a cluster Roll in accordance with a relevant modification of the cluster’s settings. When set to true , only specific changes in the cluster’s configuration will trigger a cluster roll (such as availability_zones, max_pods_per_node, enable_node_public_ip, os_disk_size_gb, os_disk_type, os_sku, kubernetes_version, vnet_subnet_ids, pod_subnet_ids, labels, taints and tags).
1579
1580
  :param pulumi.Input['OceanNpUpdatePolicyRollConfigArgs'] roll_config: While used, you can control whether the group should perform a deployment after an update to the configuration.
1580
1581
  """
1581
1582
  pulumi.set(__self__, "should_roll", should_roll)
@@ -1586,26 +1587,26 @@ class OceanNpUpdatePolicyArgs:
1586
1587
 
1587
1588
  @property
1588
1589
  @pulumi.getter(name="shouldRoll")
1589
- def should_roll(self) -> pulumi.Input[bool]:
1590
+ def should_roll(self) -> pulumi.Input[builtins.bool]:
1590
1591
  """
1591
1592
  If set to true along with the cluster update, roll will be triggered.
1592
1593
  """
1593
1594
  return pulumi.get(self, "should_roll")
1594
1595
 
1595
1596
  @should_roll.setter
1596
- def should_roll(self, value: pulumi.Input[bool]):
1597
+ def should_roll(self, value: pulumi.Input[builtins.bool]):
1597
1598
  pulumi.set(self, "should_roll", value)
1598
1599
 
1599
1600
  @property
1600
1601
  @pulumi.getter(name="conditionedRoll")
1601
- def conditioned_roll(self) -> Optional[pulumi.Input[bool]]:
1602
+ def conditioned_roll(self) -> Optional[pulumi.Input[builtins.bool]]:
1602
1603
  """
1603
1604
  Spot will perform a cluster Roll in accordance with a relevant modification of the cluster’s settings. When set to true , only specific changes in the cluster’s configuration will trigger a cluster roll (such as availability_zones, max_pods_per_node, enable_node_public_ip, os_disk_size_gb, os_disk_type, os_sku, kubernetes_version, vnet_subnet_ids, pod_subnet_ids, labels, taints and tags).
1604
1605
  """
1605
1606
  return pulumi.get(self, "conditioned_roll")
1606
1607
 
1607
1608
  @conditioned_roll.setter
1608
- def conditioned_roll(self, value: Optional[pulumi.Input[bool]]):
1609
+ def conditioned_roll(self, value: Optional[pulumi.Input[builtins.bool]]):
1609
1610
  pulumi.set(self, "conditioned_roll", value)
1610
1611
 
1611
1612
  @property
@@ -1623,35 +1624,35 @@ class OceanNpUpdatePolicyArgs:
1623
1624
 
1624
1625
  if not MYPY:
1625
1626
  class OceanNpUpdatePolicyRollConfigArgsDict(TypedDict):
1626
- batch_min_healthy_percentage: NotRequired[pulumi.Input[int]]
1627
+ batch_min_healthy_percentage: NotRequired[pulumi.Input[builtins.int]]
1627
1628
  """
1628
1629
  Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
1629
1630
  """
1630
- batch_size_percentage: NotRequired[pulumi.Input[int]]
1631
+ batch_size_percentage: NotRequired[pulumi.Input[builtins.int]]
1631
1632
  """
1632
1633
  Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
1633
1634
  """
1634
- comment: NotRequired[pulumi.Input[str]]
1635
+ comment: NotRequired[pulumi.Input[builtins.str]]
1635
1636
  """
1636
1637
  Add a comment description for the roll. The comment is limited to 256 chars and optional.
1637
1638
  """
1638
- node_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
1639
+ node_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
1639
1640
  """
1640
1641
  List of node names to be rolled. Each identifier is a string. nodeNames can be null, and cannot be used together with nodePoolNames and vngIds.
1641
1642
  """
1642
- node_pool_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
1643
+ node_pool_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
1643
1644
  """
1644
1645
  List of node pools to be rolled. Each node pool name is a string. nodePoolNames can be null, and cannot be used together with nodeNames and vngIds.
1645
1646
  """
1646
- respect_pdb: NotRequired[pulumi.Input[bool]]
1647
+ respect_pdb: NotRequired[pulumi.Input[builtins.bool]]
1647
1648
  """
1648
1649
  During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
1649
1650
  """
1650
- respect_restrict_scale_down: NotRequired[pulumi.Input[bool]]
1651
+ respect_restrict_scale_down: NotRequired[pulumi.Input[builtins.bool]]
1651
1652
  """
1652
1653
  During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
1653
1654
  """
1654
- vng_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
1655
+ vng_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
1655
1656
  """
1656
1657
  List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
1657
1658
  """
@@ -1661,23 +1662,23 @@ elif False:
1661
1662
  @pulumi.input_type
1662
1663
  class OceanNpUpdatePolicyRollConfigArgs:
1663
1664
  def __init__(__self__, *,
1664
- batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
1665
- batch_size_percentage: Optional[pulumi.Input[int]] = None,
1666
- comment: Optional[pulumi.Input[str]] = None,
1667
- node_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
1668
- node_pool_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
1669
- respect_pdb: Optional[pulumi.Input[bool]] = None,
1670
- respect_restrict_scale_down: Optional[pulumi.Input[bool]] = None,
1671
- vng_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
1672
- """
1673
- :param pulumi.Input[int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
1674
- :param pulumi.Input[int] batch_size_percentage: Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
1675
- :param pulumi.Input[str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
1676
- :param pulumi.Input[Sequence[pulumi.Input[str]]] node_names: List of node names to be rolled. Each identifier is a string. nodeNames can be null, and cannot be used together with nodePoolNames and vngIds.
1677
- :param pulumi.Input[Sequence[pulumi.Input[str]]] node_pool_names: List of node pools to be rolled. Each node pool name is a string. nodePoolNames can be null, and cannot be used together with nodeNames and vngIds.
1678
- :param pulumi.Input[bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
1679
- :param pulumi.Input[bool] respect_restrict_scale_down: During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
1680
- :param pulumi.Input[Sequence[pulumi.Input[str]]] vng_ids: List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
1665
+ batch_min_healthy_percentage: Optional[pulumi.Input[builtins.int]] = None,
1666
+ batch_size_percentage: Optional[pulumi.Input[builtins.int]] = None,
1667
+ comment: Optional[pulumi.Input[builtins.str]] = None,
1668
+ node_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
1669
+ node_pool_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
1670
+ respect_pdb: Optional[pulumi.Input[builtins.bool]] = None,
1671
+ respect_restrict_scale_down: Optional[pulumi.Input[builtins.bool]] = None,
1672
+ vng_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
1673
+ """
1674
+ :param pulumi.Input[builtins.int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
1675
+ :param pulumi.Input[builtins.int] batch_size_percentage: Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
1676
+ :param pulumi.Input[builtins.str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
1677
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_names: List of node names to be rolled. Each identifier is a string. nodeNames can be null, and cannot be used together with nodePoolNames and vngIds.
1678
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_pool_names: List of node pools to be rolled. Each node pool name is a string. nodePoolNames can be null, and cannot be used together with nodeNames and vngIds.
1679
+ :param pulumi.Input[builtins.bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
1680
+ :param pulumi.Input[builtins.bool] respect_restrict_scale_down: During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
1681
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] vng_ids: List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
1681
1682
  """
1682
1683
  if batch_min_healthy_percentage is not None:
1683
1684
  pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
@@ -1698,160 +1699,160 @@ class OceanNpUpdatePolicyRollConfigArgs:
1698
1699
 
1699
1700
  @property
1700
1701
  @pulumi.getter(name="batchMinHealthyPercentage")
1701
- def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[int]]:
1702
+ def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
1702
1703
  """
1703
1704
  Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
1704
1705
  """
1705
1706
  return pulumi.get(self, "batch_min_healthy_percentage")
1706
1707
 
1707
1708
  @batch_min_healthy_percentage.setter
1708
- def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[int]]):
1709
+ def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
1709
1710
  pulumi.set(self, "batch_min_healthy_percentage", value)
1710
1711
 
1711
1712
  @property
1712
1713
  @pulumi.getter(name="batchSizePercentage")
1713
- def batch_size_percentage(self) -> Optional[pulumi.Input[int]]:
1714
+ def batch_size_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
1714
1715
  """
1715
1716
  Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
1716
1717
  """
1717
1718
  return pulumi.get(self, "batch_size_percentage")
1718
1719
 
1719
1720
  @batch_size_percentage.setter
1720
- def batch_size_percentage(self, value: Optional[pulumi.Input[int]]):
1721
+ def batch_size_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
1721
1722
  pulumi.set(self, "batch_size_percentage", value)
1722
1723
 
1723
1724
  @property
1724
1725
  @pulumi.getter
1725
- def comment(self) -> Optional[pulumi.Input[str]]:
1726
+ def comment(self) -> Optional[pulumi.Input[builtins.str]]:
1726
1727
  """
1727
1728
  Add a comment description for the roll. The comment is limited to 256 chars and optional.
1728
1729
  """
1729
1730
  return pulumi.get(self, "comment")
1730
1731
 
1731
1732
  @comment.setter
1732
- def comment(self, value: Optional[pulumi.Input[str]]):
1733
+ def comment(self, value: Optional[pulumi.Input[builtins.str]]):
1733
1734
  pulumi.set(self, "comment", value)
1734
1735
 
1735
1736
  @property
1736
1737
  @pulumi.getter(name="nodeNames")
1737
- def node_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
1738
+ def node_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
1738
1739
  """
1739
1740
  List of node names to be rolled. Each identifier is a string. nodeNames can be null, and cannot be used together with nodePoolNames and vngIds.
1740
1741
  """
1741
1742
  return pulumi.get(self, "node_names")
1742
1743
 
1743
1744
  @node_names.setter
1744
- def node_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
1745
+ def node_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
1745
1746
  pulumi.set(self, "node_names", value)
1746
1747
 
1747
1748
  @property
1748
1749
  @pulumi.getter(name="nodePoolNames")
1749
- def node_pool_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
1750
+ def node_pool_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
1750
1751
  """
1751
1752
  List of node pools to be rolled. Each node pool name is a string. nodePoolNames can be null, and cannot be used together with nodeNames and vngIds.
1752
1753
  """
1753
1754
  return pulumi.get(self, "node_pool_names")
1754
1755
 
1755
1756
  @node_pool_names.setter
1756
- def node_pool_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
1757
+ def node_pool_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
1757
1758
  pulumi.set(self, "node_pool_names", value)
1758
1759
 
1759
1760
  @property
1760
1761
  @pulumi.getter(name="respectPdb")
1761
- def respect_pdb(self) -> Optional[pulumi.Input[bool]]:
1762
+ def respect_pdb(self) -> Optional[pulumi.Input[builtins.bool]]:
1762
1763
  """
1763
1764
  During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
1764
1765
  """
1765
1766
  return pulumi.get(self, "respect_pdb")
1766
1767
 
1767
1768
  @respect_pdb.setter
1768
- def respect_pdb(self, value: Optional[pulumi.Input[bool]]):
1769
+ def respect_pdb(self, value: Optional[pulumi.Input[builtins.bool]]):
1769
1770
  pulumi.set(self, "respect_pdb", value)
1770
1771
 
1771
1772
  @property
1772
1773
  @pulumi.getter(name="respectRestrictScaleDown")
1773
- def respect_restrict_scale_down(self) -> Optional[pulumi.Input[bool]]:
1774
+ def respect_restrict_scale_down(self) -> Optional[pulumi.Input[builtins.bool]]:
1774
1775
  """
1775
1776
  During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
1776
1777
  """
1777
1778
  return pulumi.get(self, "respect_restrict_scale_down")
1778
1779
 
1779
1780
  @respect_restrict_scale_down.setter
1780
- def respect_restrict_scale_down(self, value: Optional[pulumi.Input[bool]]):
1781
+ def respect_restrict_scale_down(self, value: Optional[pulumi.Input[builtins.bool]]):
1781
1782
  pulumi.set(self, "respect_restrict_scale_down", value)
1782
1783
 
1783
1784
  @property
1784
1785
  @pulumi.getter(name="vngIds")
1785
- def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
1786
+ def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
1786
1787
  """
1787
1788
  List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
1788
1789
  """
1789
1790
  return pulumi.get(self, "vng_ids")
1790
1791
 
1791
1792
  @vng_ids.setter
1792
- def vng_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
1793
+ def vng_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
1793
1794
  pulumi.set(self, "vng_ids", value)
1794
1795
 
1795
1796
 
1796
1797
  if not MYPY:
1797
1798
  class OceanNpVirtualNodeGroupFiltersArgsDict(TypedDict):
1798
- accelerated_networking: NotRequired[pulumi.Input[str]]
1799
+ accelerated_networking: NotRequired[pulumi.Input[builtins.str]]
1799
1800
  """
1800
1801
  In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
1801
1802
  """
1802
- architectures: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
1803
+ architectures: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
1803
1804
  """
1804
1805
  The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
1805
1806
  """
1806
- disk_performance: NotRequired[pulumi.Input[str]]
1807
+ disk_performance: NotRequired[pulumi.Input[builtins.str]]
1807
1808
  """
1808
1809
  The filtered vm sizes will support at least one of the classes from this list.
1809
1810
  """
1810
- exclude_series: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
1811
+ exclude_series: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
1811
1812
  """
1812
1813
  Vm sizes belonging to a series from the list will not be available for scaling.
1813
1814
  """
1814
- gpu_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
1815
+ gpu_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
1815
1816
  """
1816
1817
  The filtered gpu types will belong to one of the gpu types from this list.
1817
1818
  """
1818
- max_gpu: NotRequired[pulumi.Input[float]]
1819
+ max_gpu: NotRequired[pulumi.Input[builtins.float]]
1819
1820
  """
1820
1821
  Maximum number of GPUs available.
1821
1822
  """
1822
- max_memory_gib: NotRequired[pulumi.Input[float]]
1823
+ max_memory_gib: NotRequired[pulumi.Input[builtins.float]]
1823
1824
  """
1824
1825
  Maximum amount of Memory (GiB).
1825
1826
  """
1826
- max_vcpu: NotRequired[pulumi.Input[int]]
1827
+ max_vcpu: NotRequired[pulumi.Input[builtins.int]]
1827
1828
  """
1828
1829
  Maximum number of vcpus available.
1829
1830
  """
1830
- min_disk: NotRequired[pulumi.Input[int]]
1831
+ min_disk: NotRequired[pulumi.Input[builtins.int]]
1831
1832
  """
1832
1833
  Minimum number of data disks available.
1833
1834
  """
1834
- min_gpu: NotRequired[pulumi.Input[float]]
1835
+ min_gpu: NotRequired[pulumi.Input[builtins.float]]
1835
1836
  """
1836
1837
  Minimum number of GPUs available.
1837
1838
  """
1838
- min_memory_gib: NotRequired[pulumi.Input[float]]
1839
+ min_memory_gib: NotRequired[pulumi.Input[builtins.float]]
1839
1840
  """
1840
1841
  Minimum amount of Memory (GiB).
1841
1842
  """
1842
- min_nics: NotRequired[pulumi.Input[int]]
1843
+ min_nics: NotRequired[pulumi.Input[builtins.int]]
1843
1844
  """
1844
1845
  Minimum number of network interfaces.
1845
1846
  """
1846
- min_vcpu: NotRequired[pulumi.Input[int]]
1847
+ min_vcpu: NotRequired[pulumi.Input[builtins.int]]
1847
1848
  """
1848
1849
  Minimum number of vcpus available.
1849
1850
  """
1850
- series: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
1851
+ series: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
1851
1852
  """
1852
1853
  Vm sizes belonging to a series from the list will be available for scaling.
1853
1854
  """
1854
- vm_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
1855
+ vm_types: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
1855
1856
  """
1856
1857
  The filtered vm types will belong to one of the vm types from this list.
1857
1858
  """
@@ -1861,37 +1862,37 @@ elif False:
1861
1862
  @pulumi.input_type
1862
1863
  class OceanNpVirtualNodeGroupFiltersArgs:
1863
1864
  def __init__(__self__, *,
1864
- accelerated_networking: Optional[pulumi.Input[str]] = None,
1865
- architectures: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
1866
- disk_performance: Optional[pulumi.Input[str]] = None,
1867
- exclude_series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
1868
- gpu_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
1869
- max_gpu: Optional[pulumi.Input[float]] = None,
1870
- max_memory_gib: Optional[pulumi.Input[float]] = None,
1871
- max_vcpu: Optional[pulumi.Input[int]] = None,
1872
- min_disk: Optional[pulumi.Input[int]] = None,
1873
- min_gpu: Optional[pulumi.Input[float]] = None,
1874
- min_memory_gib: Optional[pulumi.Input[float]] = None,
1875
- min_nics: Optional[pulumi.Input[int]] = None,
1876
- min_vcpu: Optional[pulumi.Input[int]] = None,
1877
- series: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
1878
- vm_types: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
1879
- """
1880
- :param pulumi.Input[str] accelerated_networking: In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
1881
- :param pulumi.Input[Sequence[pulumi.Input[str]]] architectures: The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
1882
- :param pulumi.Input[str] disk_performance: The filtered vm sizes will support at least one of the classes from this list.
1883
- :param pulumi.Input[Sequence[pulumi.Input[str]]] exclude_series: Vm sizes belonging to a series from the list will not be available for scaling.
1884
- :param pulumi.Input[Sequence[pulumi.Input[str]]] gpu_types: The filtered gpu types will belong to one of the gpu types from this list.
1885
- :param pulumi.Input[float] max_gpu: Maximum number of GPUs available.
1886
- :param pulumi.Input[float] max_memory_gib: Maximum amount of Memory (GiB).
1887
- :param pulumi.Input[int] max_vcpu: Maximum number of vcpus available.
1888
- :param pulumi.Input[int] min_disk: Minimum number of data disks available.
1889
- :param pulumi.Input[float] min_gpu: Minimum number of GPUs available.
1890
- :param pulumi.Input[float] min_memory_gib: Minimum amount of Memory (GiB).
1891
- :param pulumi.Input[int] min_nics: Minimum number of network interfaces.
1892
- :param pulumi.Input[int] min_vcpu: Minimum number of vcpus available.
1893
- :param pulumi.Input[Sequence[pulumi.Input[str]]] series: Vm sizes belonging to a series from the list will be available for scaling.
1894
- :param pulumi.Input[Sequence[pulumi.Input[str]]] vm_types: The filtered vm types will belong to one of the vm types from this list.
1865
+ accelerated_networking: Optional[pulumi.Input[builtins.str]] = None,
1866
+ architectures: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
1867
+ disk_performance: Optional[pulumi.Input[builtins.str]] = None,
1868
+ exclude_series: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
1869
+ gpu_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
1870
+ max_gpu: Optional[pulumi.Input[builtins.float]] = None,
1871
+ max_memory_gib: Optional[pulumi.Input[builtins.float]] = None,
1872
+ max_vcpu: Optional[pulumi.Input[builtins.int]] = None,
1873
+ min_disk: Optional[pulumi.Input[builtins.int]] = None,
1874
+ min_gpu: Optional[pulumi.Input[builtins.float]] = None,
1875
+ min_memory_gib: Optional[pulumi.Input[builtins.float]] = None,
1876
+ min_nics: Optional[pulumi.Input[builtins.int]] = None,
1877
+ min_vcpu: Optional[pulumi.Input[builtins.int]] = None,
1878
+ series: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
1879
+ vm_types: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
1880
+ """
1881
+ :param pulumi.Input[builtins.str] accelerated_networking: In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
1882
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] architectures: The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
1883
+ :param pulumi.Input[builtins.str] disk_performance: The filtered vm sizes will support at least one of the classes from this list.
1884
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] exclude_series: Vm sizes belonging to a series from the list will not be available for scaling.
1885
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] gpu_types: The filtered gpu types will belong to one of the gpu types from this list.
1886
+ :param pulumi.Input[builtins.float] max_gpu: Maximum number of GPUs available.
1887
+ :param pulumi.Input[builtins.float] max_memory_gib: Maximum amount of Memory (GiB).
1888
+ :param pulumi.Input[builtins.int] max_vcpu: Maximum number of vcpus available.
1889
+ :param pulumi.Input[builtins.int] min_disk: Minimum number of data disks available.
1890
+ :param pulumi.Input[builtins.float] min_gpu: Minimum number of GPUs available.
1891
+ :param pulumi.Input[builtins.float] min_memory_gib: Minimum amount of Memory (GiB).
1892
+ :param pulumi.Input[builtins.int] min_nics: Minimum number of network interfaces.
1893
+ :param pulumi.Input[builtins.int] min_vcpu: Minimum number of vcpus available.
1894
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] series: Vm sizes belonging to a series from the list will be available for scaling.
1895
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] vm_types: The filtered vm types will belong to one of the vm types from this list.
1895
1896
  """
1896
1897
  if accelerated_networking is not None:
1897
1898
  pulumi.set(__self__, "accelerated_networking", accelerated_networking)
@@ -1926,200 +1927,200 @@ class OceanNpVirtualNodeGroupFiltersArgs:
1926
1927
 
1927
1928
  @property
1928
1929
  @pulumi.getter(name="acceleratedNetworking")
1929
- def accelerated_networking(self) -> Optional[pulumi.Input[str]]:
1930
+ def accelerated_networking(self) -> Optional[pulumi.Input[builtins.str]]:
1930
1931
  """
1931
1932
  In case acceleratedNetworking is set to Enabled, accelerated networking applies only to the VM that enables it.
1932
1933
  """
1933
1934
  return pulumi.get(self, "accelerated_networking")
1934
1935
 
1935
1936
  @accelerated_networking.setter
1936
- def accelerated_networking(self, value: Optional[pulumi.Input[str]]):
1937
+ def accelerated_networking(self, value: Optional[pulumi.Input[builtins.str]]):
1937
1938
  pulumi.set(self, "accelerated_networking", value)
1938
1939
 
1939
1940
  @property
1940
1941
  @pulumi.getter
1941
- def architectures(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
1942
+ def architectures(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
1942
1943
  """
1943
1944
  The filtered vm sizes will support at least one of the architectures from this list. x86_64 includes both intel64 and amd64.
1944
1945
  """
1945
1946
  return pulumi.get(self, "architectures")
1946
1947
 
1947
1948
  @architectures.setter
1948
- def architectures(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
1949
+ def architectures(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
1949
1950
  pulumi.set(self, "architectures", value)
1950
1951
 
1951
1952
  @property
1952
1953
  @pulumi.getter(name="diskPerformance")
1953
- def disk_performance(self) -> Optional[pulumi.Input[str]]:
1954
+ def disk_performance(self) -> Optional[pulumi.Input[builtins.str]]:
1954
1955
  """
1955
1956
  The filtered vm sizes will support at least one of the classes from this list.
1956
1957
  """
1957
1958
  return pulumi.get(self, "disk_performance")
1958
1959
 
1959
1960
  @disk_performance.setter
1960
- def disk_performance(self, value: Optional[pulumi.Input[str]]):
1961
+ def disk_performance(self, value: Optional[pulumi.Input[builtins.str]]):
1961
1962
  pulumi.set(self, "disk_performance", value)
1962
1963
 
1963
1964
  @property
1964
1965
  @pulumi.getter(name="excludeSeries")
1965
- def exclude_series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
1966
+ def exclude_series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
1966
1967
  """
1967
1968
  Vm sizes belonging to a series from the list will not be available for scaling.
1968
1969
  """
1969
1970
  return pulumi.get(self, "exclude_series")
1970
1971
 
1971
1972
  @exclude_series.setter
1972
- def exclude_series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
1973
+ def exclude_series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
1973
1974
  pulumi.set(self, "exclude_series", value)
1974
1975
 
1975
1976
  @property
1976
1977
  @pulumi.getter(name="gpuTypes")
1977
- def gpu_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
1978
+ def gpu_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
1978
1979
  """
1979
1980
  The filtered gpu types will belong to one of the gpu types from this list.
1980
1981
  """
1981
1982
  return pulumi.get(self, "gpu_types")
1982
1983
 
1983
1984
  @gpu_types.setter
1984
- def gpu_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
1985
+ def gpu_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
1985
1986
  pulumi.set(self, "gpu_types", value)
1986
1987
 
1987
1988
  @property
1988
1989
  @pulumi.getter(name="maxGpu")
1989
- def max_gpu(self) -> Optional[pulumi.Input[float]]:
1990
+ def max_gpu(self) -> Optional[pulumi.Input[builtins.float]]:
1990
1991
  """
1991
1992
  Maximum number of GPUs available.
1992
1993
  """
1993
1994
  return pulumi.get(self, "max_gpu")
1994
1995
 
1995
1996
  @max_gpu.setter
1996
- def max_gpu(self, value: Optional[pulumi.Input[float]]):
1997
+ def max_gpu(self, value: Optional[pulumi.Input[builtins.float]]):
1997
1998
  pulumi.set(self, "max_gpu", value)
1998
1999
 
1999
2000
  @property
2000
2001
  @pulumi.getter(name="maxMemoryGib")
2001
- def max_memory_gib(self) -> Optional[pulumi.Input[float]]:
2002
+ def max_memory_gib(self) -> Optional[pulumi.Input[builtins.float]]:
2002
2003
  """
2003
2004
  Maximum amount of Memory (GiB).
2004
2005
  """
2005
2006
  return pulumi.get(self, "max_memory_gib")
2006
2007
 
2007
2008
  @max_memory_gib.setter
2008
- def max_memory_gib(self, value: Optional[pulumi.Input[float]]):
2009
+ def max_memory_gib(self, value: Optional[pulumi.Input[builtins.float]]):
2009
2010
  pulumi.set(self, "max_memory_gib", value)
2010
2011
 
2011
2012
  @property
2012
2013
  @pulumi.getter(name="maxVcpu")
2013
- def max_vcpu(self) -> Optional[pulumi.Input[int]]:
2014
+ def max_vcpu(self) -> Optional[pulumi.Input[builtins.int]]:
2014
2015
  """
2015
2016
  Maximum number of vcpus available.
2016
2017
  """
2017
2018
  return pulumi.get(self, "max_vcpu")
2018
2019
 
2019
2020
  @max_vcpu.setter
2020
- def max_vcpu(self, value: Optional[pulumi.Input[int]]):
2021
+ def max_vcpu(self, value: Optional[pulumi.Input[builtins.int]]):
2021
2022
  pulumi.set(self, "max_vcpu", value)
2022
2023
 
2023
2024
  @property
2024
2025
  @pulumi.getter(name="minDisk")
2025
- def min_disk(self) -> Optional[pulumi.Input[int]]:
2026
+ def min_disk(self) -> Optional[pulumi.Input[builtins.int]]:
2026
2027
  """
2027
2028
  Minimum number of data disks available.
2028
2029
  """
2029
2030
  return pulumi.get(self, "min_disk")
2030
2031
 
2031
2032
  @min_disk.setter
2032
- def min_disk(self, value: Optional[pulumi.Input[int]]):
2033
+ def min_disk(self, value: Optional[pulumi.Input[builtins.int]]):
2033
2034
  pulumi.set(self, "min_disk", value)
2034
2035
 
2035
2036
  @property
2036
2037
  @pulumi.getter(name="minGpu")
2037
- def min_gpu(self) -> Optional[pulumi.Input[float]]:
2038
+ def min_gpu(self) -> Optional[pulumi.Input[builtins.float]]:
2038
2039
  """
2039
2040
  Minimum number of GPUs available.
2040
2041
  """
2041
2042
  return pulumi.get(self, "min_gpu")
2042
2043
 
2043
2044
  @min_gpu.setter
2044
- def min_gpu(self, value: Optional[pulumi.Input[float]]):
2045
+ def min_gpu(self, value: Optional[pulumi.Input[builtins.float]]):
2045
2046
  pulumi.set(self, "min_gpu", value)
2046
2047
 
2047
2048
  @property
2048
2049
  @pulumi.getter(name="minMemoryGib")
2049
- def min_memory_gib(self) -> Optional[pulumi.Input[float]]:
2050
+ def min_memory_gib(self) -> Optional[pulumi.Input[builtins.float]]:
2050
2051
  """
2051
2052
  Minimum amount of Memory (GiB).
2052
2053
  """
2053
2054
  return pulumi.get(self, "min_memory_gib")
2054
2055
 
2055
2056
  @min_memory_gib.setter
2056
- def min_memory_gib(self, value: Optional[pulumi.Input[float]]):
2057
+ def min_memory_gib(self, value: Optional[pulumi.Input[builtins.float]]):
2057
2058
  pulumi.set(self, "min_memory_gib", value)
2058
2059
 
2059
2060
  @property
2060
2061
  @pulumi.getter(name="minNics")
2061
- def min_nics(self) -> Optional[pulumi.Input[int]]:
2062
+ def min_nics(self) -> Optional[pulumi.Input[builtins.int]]:
2062
2063
  """
2063
2064
  Minimum number of network interfaces.
2064
2065
  """
2065
2066
  return pulumi.get(self, "min_nics")
2066
2067
 
2067
2068
  @min_nics.setter
2068
- def min_nics(self, value: Optional[pulumi.Input[int]]):
2069
+ def min_nics(self, value: Optional[pulumi.Input[builtins.int]]):
2069
2070
  pulumi.set(self, "min_nics", value)
2070
2071
 
2071
2072
  @property
2072
2073
  @pulumi.getter(name="minVcpu")
2073
- def min_vcpu(self) -> Optional[pulumi.Input[int]]:
2074
+ def min_vcpu(self) -> Optional[pulumi.Input[builtins.int]]:
2074
2075
  """
2075
2076
  Minimum number of vcpus available.
2076
2077
  """
2077
2078
  return pulumi.get(self, "min_vcpu")
2078
2079
 
2079
2080
  @min_vcpu.setter
2080
- def min_vcpu(self, value: Optional[pulumi.Input[int]]):
2081
+ def min_vcpu(self, value: Optional[pulumi.Input[builtins.int]]):
2081
2082
  pulumi.set(self, "min_vcpu", value)
2082
2083
 
2083
2084
  @property
2084
2085
  @pulumi.getter
2085
- def series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
2086
+ def series(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
2086
2087
  """
2087
2088
  Vm sizes belonging to a series from the list will be available for scaling.
2088
2089
  """
2089
2090
  return pulumi.get(self, "series")
2090
2091
 
2091
2092
  @series.setter
2092
- def series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
2093
+ def series(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
2093
2094
  pulumi.set(self, "series", value)
2094
2095
 
2095
2096
  @property
2096
2097
  @pulumi.getter(name="vmTypes")
2097
- def vm_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
2098
+ def vm_types(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
2098
2099
  """
2099
2100
  The filtered vm types will belong to one of the vm types from this list.
2100
2101
  """
2101
2102
  return pulumi.get(self, "vm_types")
2102
2103
 
2103
2104
  @vm_types.setter
2104
- def vm_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
2105
+ def vm_types(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
2105
2106
  pulumi.set(self, "vm_types", value)
2106
2107
 
2107
2108
 
2108
2109
  if not MYPY:
2109
2110
  class OceanNpVirtualNodeGroupHeadroomArgsDict(TypedDict):
2110
- cpu_per_unit: NotRequired[pulumi.Input[int]]
2111
+ cpu_per_unit: NotRequired[pulumi.Input[builtins.int]]
2111
2112
  """
2112
2113
  Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
2113
2114
  """
2114
- gpu_per_unit: NotRequired[pulumi.Input[int]]
2115
+ gpu_per_unit: NotRequired[pulumi.Input[builtins.int]]
2115
2116
  """
2116
2117
  Amount of GPU to allocate for headroom unit.
2117
2118
  """
2118
- memory_per_unit: NotRequired[pulumi.Input[int]]
2119
+ memory_per_unit: NotRequired[pulumi.Input[builtins.int]]
2119
2120
  """
2120
2121
  Configure the amount of memory (MiB) to allocate the headroom.
2121
2122
  """
2122
- num_of_units: NotRequired[pulumi.Input[int]]
2123
+ num_of_units: NotRequired[pulumi.Input[builtins.int]]
2123
2124
  """
2124
2125
  The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
2125
2126
  """
@@ -2129,15 +2130,15 @@ elif False:
2129
2130
  @pulumi.input_type
2130
2131
  class OceanNpVirtualNodeGroupHeadroomArgs:
2131
2132
  def __init__(__self__, *,
2132
- cpu_per_unit: Optional[pulumi.Input[int]] = None,
2133
- gpu_per_unit: Optional[pulumi.Input[int]] = None,
2134
- memory_per_unit: Optional[pulumi.Input[int]] = None,
2135
- num_of_units: Optional[pulumi.Input[int]] = None):
2133
+ cpu_per_unit: Optional[pulumi.Input[builtins.int]] = None,
2134
+ gpu_per_unit: Optional[pulumi.Input[builtins.int]] = None,
2135
+ memory_per_unit: Optional[pulumi.Input[builtins.int]] = None,
2136
+ num_of_units: Optional[pulumi.Input[builtins.int]] = None):
2136
2137
  """
2137
- :param pulumi.Input[int] cpu_per_unit: Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
2138
- :param pulumi.Input[int] gpu_per_unit: Amount of GPU to allocate for headroom unit.
2139
- :param pulumi.Input[int] memory_per_unit: Configure the amount of memory (MiB) to allocate the headroom.
2140
- :param pulumi.Input[int] num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
2138
+ :param pulumi.Input[builtins.int] cpu_per_unit: Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
2139
+ :param pulumi.Input[builtins.int] gpu_per_unit: Amount of GPU to allocate for headroom unit.
2140
+ :param pulumi.Input[builtins.int] memory_per_unit: Configure the amount of memory (MiB) to allocate the headroom.
2141
+ :param pulumi.Input[builtins.int] num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
2141
2142
  """
2142
2143
  if cpu_per_unit is not None:
2143
2144
  pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
@@ -2150,50 +2151,50 @@ class OceanNpVirtualNodeGroupHeadroomArgs:
2150
2151
 
2151
2152
  @property
2152
2153
  @pulumi.getter(name="cpuPerUnit")
2153
- def cpu_per_unit(self) -> Optional[pulumi.Input[int]]:
2154
+ def cpu_per_unit(self) -> Optional[pulumi.Input[builtins.int]]:
2154
2155
  """
2155
2156
  Configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
2156
2157
  """
2157
2158
  return pulumi.get(self, "cpu_per_unit")
2158
2159
 
2159
2160
  @cpu_per_unit.setter
2160
- def cpu_per_unit(self, value: Optional[pulumi.Input[int]]):
2161
+ def cpu_per_unit(self, value: Optional[pulumi.Input[builtins.int]]):
2161
2162
  pulumi.set(self, "cpu_per_unit", value)
2162
2163
 
2163
2164
  @property
2164
2165
  @pulumi.getter(name="gpuPerUnit")
2165
- def gpu_per_unit(self) -> Optional[pulumi.Input[int]]:
2166
+ def gpu_per_unit(self) -> Optional[pulumi.Input[builtins.int]]:
2166
2167
  """
2167
2168
  Amount of GPU to allocate for headroom unit.
2168
2169
  """
2169
2170
  return pulumi.get(self, "gpu_per_unit")
2170
2171
 
2171
2172
  @gpu_per_unit.setter
2172
- def gpu_per_unit(self, value: Optional[pulumi.Input[int]]):
2173
+ def gpu_per_unit(self, value: Optional[pulumi.Input[builtins.int]]):
2173
2174
  pulumi.set(self, "gpu_per_unit", value)
2174
2175
 
2175
2176
  @property
2176
2177
  @pulumi.getter(name="memoryPerUnit")
2177
- def memory_per_unit(self) -> Optional[pulumi.Input[int]]:
2178
+ def memory_per_unit(self) -> Optional[pulumi.Input[builtins.int]]:
2178
2179
  """
2179
2180
  Configure the amount of memory (MiB) to allocate the headroom.
2180
2181
  """
2181
2182
  return pulumi.get(self, "memory_per_unit")
2182
2183
 
2183
2184
  @memory_per_unit.setter
2184
- def memory_per_unit(self, value: Optional[pulumi.Input[int]]):
2185
+ def memory_per_unit(self, value: Optional[pulumi.Input[builtins.int]]):
2185
2186
  pulumi.set(self, "memory_per_unit", value)
2186
2187
 
2187
2188
  @property
2188
2189
  @pulumi.getter(name="numOfUnits")
2189
- def num_of_units(self) -> Optional[pulumi.Input[int]]:
2190
+ def num_of_units(self) -> Optional[pulumi.Input[builtins.int]]:
2190
2191
  """
2191
2192
  The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
2192
2193
  """
2193
2194
  return pulumi.get(self, "num_of_units")
2194
2195
 
2195
2196
  @num_of_units.setter
2196
- def num_of_units(self, value: Optional[pulumi.Input[int]]):
2197
+ def num_of_units(self, value: Optional[pulumi.Input[builtins.int]]):
2197
2198
  pulumi.set(self, "num_of_units", value)
2198
2199
 
2199
2200
 
@@ -2231,7 +2232,7 @@ class OceanNpVirtualNodeGroupLinuxOsConfigArgs:
2231
2232
 
2232
2233
  if not MYPY:
2233
2234
  class OceanNpVirtualNodeGroupLinuxOsConfigSysctlArgsDict(TypedDict):
2234
- vm_max_map_count: NotRequired[pulumi.Input[int]]
2235
+ vm_max_map_count: NotRequired[pulumi.Input[builtins.int]]
2235
2236
  """
2236
2237
  Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
2237
2238
  """
@@ -2241,23 +2242,23 @@ elif False:
2241
2242
  @pulumi.input_type
2242
2243
  class OceanNpVirtualNodeGroupLinuxOsConfigSysctlArgs:
2243
2244
  def __init__(__self__, *,
2244
- vm_max_map_count: Optional[pulumi.Input[int]] = None):
2245
+ vm_max_map_count: Optional[pulumi.Input[builtins.int]] = None):
2245
2246
  """
2246
- :param pulumi.Input[int] vm_max_map_count: Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
2247
+ :param pulumi.Input[builtins.int] vm_max_map_count: Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
2247
2248
  """
2248
2249
  if vm_max_map_count is not None:
2249
2250
  pulumi.set(__self__, "vm_max_map_count", vm_max_map_count)
2250
2251
 
2251
2252
  @property
2252
2253
  @pulumi.getter(name="vmMaxMapCount")
2253
- def vm_max_map_count(self) -> Optional[pulumi.Input[int]]:
2254
+ def vm_max_map_count(self) -> Optional[pulumi.Input[builtins.int]]:
2254
2255
  """
2255
2256
  Maximum number of memory map areas a process may have. Can be configured only if OS type is Linux.
2256
2257
  """
2257
2258
  return pulumi.get(self, "vm_max_map_count")
2258
2259
 
2259
2260
  @vm_max_map_count.setter
2260
- def vm_max_map_count(self, value: Optional[pulumi.Input[int]]):
2261
+ def vm_max_map_count(self, value: Optional[pulumi.Input[builtins.int]]):
2261
2262
  pulumi.set(self, "vm_max_map_count", value)
2262
2263
 
2263
2264
 
@@ -2295,11 +2296,11 @@ class OceanNpVirtualNodeGroupSchedulingArgs:
2295
2296
 
2296
2297
  if not MYPY:
2297
2298
  class OceanNpVirtualNodeGroupSchedulingShutdownHoursArgsDict(TypedDict):
2298
- is_enabled: NotRequired[pulumi.Input[bool]]
2299
+ is_enabled: NotRequired[pulumi.Input[builtins.bool]]
2299
2300
  """
2300
2301
  Flag to enable or disable the shutdown hours mechanism. When `false`, the mechanism is deactivated, and the virtual node gorup remains in its current state.
2301
2302
  """
2302
- time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
2303
+ time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
2303
2304
  """
2304
2305
  The times that the shutdown hours will apply. Required if isEnabled is true.
2305
2306
  """
@@ -2309,11 +2310,11 @@ elif False:
2309
2310
  @pulumi.input_type
2310
2311
  class OceanNpVirtualNodeGroupSchedulingShutdownHoursArgs:
2311
2312
  def __init__(__self__, *,
2312
- is_enabled: Optional[pulumi.Input[bool]] = None,
2313
- time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
2313
+ is_enabled: Optional[pulumi.Input[builtins.bool]] = None,
2314
+ time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
2314
2315
  """
2315
- :param pulumi.Input[bool] is_enabled: Flag to enable or disable the shutdown hours mechanism. When `false`, the mechanism is deactivated, and the virtual node gorup remains in its current state.
2316
- :param pulumi.Input[Sequence[pulumi.Input[str]]] time_windows: The times that the shutdown hours will apply. Required if isEnabled is true.
2316
+ :param pulumi.Input[builtins.bool] is_enabled: Flag to enable or disable the shutdown hours mechanism. When `false`, the mechanism is deactivated, and the virtual node gorup remains in its current state.
2317
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] time_windows: The times that the shutdown hours will apply. Required if isEnabled is true.
2317
2318
  """
2318
2319
  if is_enabled is not None:
2319
2320
  pulumi.set(__self__, "is_enabled", is_enabled)
@@ -2322,40 +2323,40 @@ class OceanNpVirtualNodeGroupSchedulingShutdownHoursArgs:
2322
2323
 
2323
2324
  @property
2324
2325
  @pulumi.getter(name="isEnabled")
2325
- def is_enabled(self) -> Optional[pulumi.Input[bool]]:
2326
+ def is_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
2326
2327
  """
2327
2328
  Flag to enable or disable the shutdown hours mechanism. When `false`, the mechanism is deactivated, and the virtual node gorup remains in its current state.
2328
2329
  """
2329
2330
  return pulumi.get(self, "is_enabled")
2330
2331
 
2331
2332
  @is_enabled.setter
2332
- def is_enabled(self, value: Optional[pulumi.Input[bool]]):
2333
+ def is_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
2333
2334
  pulumi.set(self, "is_enabled", value)
2334
2335
 
2335
2336
  @property
2336
2337
  @pulumi.getter(name="timeWindows")
2337
- def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
2338
+ def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
2338
2339
  """
2339
2340
  The times that the shutdown hours will apply. Required if isEnabled is true.
2340
2341
  """
2341
2342
  return pulumi.get(self, "time_windows")
2342
2343
 
2343
2344
  @time_windows.setter
2344
- def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
2345
+ def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
2345
2346
  pulumi.set(self, "time_windows", value)
2346
2347
 
2347
2348
 
2348
2349
  if not MYPY:
2349
2350
  class OceanNpVirtualNodeGroupTaintArgsDict(TypedDict):
2350
- effect: pulumi.Input[str]
2351
+ effect: pulumi.Input[builtins.str]
2351
2352
  """
2352
2353
  Set taint effect.
2353
2354
  """
2354
- key: pulumi.Input[str]
2355
+ key: pulumi.Input[builtins.str]
2355
2356
  """
2356
2357
  Set taint key. The following are not allowed: "kubernetes.azure.com/scalesetpriority".
2357
2358
  """
2358
- value: pulumi.Input[str]
2359
+ value: pulumi.Input[builtins.str]
2359
2360
  """
2360
2361
  Set taint value.
2361
2362
  """
@@ -2365,13 +2366,13 @@ elif False:
2365
2366
  @pulumi.input_type
2366
2367
  class OceanNpVirtualNodeGroupTaintArgs:
2367
2368
  def __init__(__self__, *,
2368
- effect: pulumi.Input[str],
2369
- key: pulumi.Input[str],
2370
- value: pulumi.Input[str]):
2369
+ effect: pulumi.Input[builtins.str],
2370
+ key: pulumi.Input[builtins.str],
2371
+ value: pulumi.Input[builtins.str]):
2371
2372
  """
2372
- :param pulumi.Input[str] effect: Set taint effect.
2373
- :param pulumi.Input[str] key: Set taint key. The following are not allowed: "kubernetes.azure.com/scalesetpriority".
2374
- :param pulumi.Input[str] value: Set taint value.
2373
+ :param pulumi.Input[builtins.str] effect: Set taint effect.
2374
+ :param pulumi.Input[builtins.str] key: Set taint key. The following are not allowed: "kubernetes.azure.com/scalesetpriority".
2375
+ :param pulumi.Input[builtins.str] value: Set taint value.
2375
2376
  """
2376
2377
  pulumi.set(__self__, "effect", effect)
2377
2378
  pulumi.set(__self__, "key", key)
@@ -2379,48 +2380,48 @@ class OceanNpVirtualNodeGroupTaintArgs:
2379
2380
 
2380
2381
  @property
2381
2382
  @pulumi.getter
2382
- def effect(self) -> pulumi.Input[str]:
2383
+ def effect(self) -> pulumi.Input[builtins.str]:
2383
2384
  """
2384
2385
  Set taint effect.
2385
2386
  """
2386
2387
  return pulumi.get(self, "effect")
2387
2388
 
2388
2389
  @effect.setter
2389
- def effect(self, value: pulumi.Input[str]):
2390
+ def effect(self, value: pulumi.Input[builtins.str]):
2390
2391
  pulumi.set(self, "effect", value)
2391
2392
 
2392
2393
  @property
2393
2394
  @pulumi.getter
2394
- def key(self) -> pulumi.Input[str]:
2395
+ def key(self) -> pulumi.Input[builtins.str]:
2395
2396
  """
2396
2397
  Set taint key. The following are not allowed: "kubernetes.azure.com/scalesetpriority".
2397
2398
  """
2398
2399
  return pulumi.get(self, "key")
2399
2400
 
2400
2401
  @key.setter
2401
- def key(self, value: pulumi.Input[str]):
2402
+ def key(self, value: pulumi.Input[builtins.str]):
2402
2403
  pulumi.set(self, "key", value)
2403
2404
 
2404
2405
  @property
2405
2406
  @pulumi.getter
2406
- def value(self) -> pulumi.Input[str]:
2407
+ def value(self) -> pulumi.Input[builtins.str]:
2407
2408
  """
2408
2409
  Set taint value.
2409
2410
  """
2410
2411
  return pulumi.get(self, "value")
2411
2412
 
2412
2413
  @value.setter
2413
- def value(self, value: pulumi.Input[str]):
2414
+ def value(self, value: pulumi.Input[builtins.str]):
2414
2415
  pulumi.set(self, "value", value)
2415
2416
 
2416
2417
 
2417
2418
  if not MYPY:
2418
2419
  class OceanNpVirtualNodeGroupUpdatePolicyArgsDict(TypedDict):
2419
- should_roll: pulumi.Input[bool]
2420
+ should_roll: pulumi.Input[builtins.bool]
2420
2421
  """
2421
2422
  If set to true along with the vng update, roll will be triggered.
2422
2423
  """
2423
- conditioned_roll: NotRequired[pulumi.Input[bool]]
2424
+ conditioned_roll: NotRequired[pulumi.Input[builtins.bool]]
2424
2425
  """
2425
2426
  Spot will perform a cluster Roll in accordance with a relevant modification of the cluster’s settings. When set to true , only specific changes in the cluster’s configuration will trigger a cluster roll (such as availability_zones, max_pods_per_node, enable_node_public_ip, os_disk_size_gb, os_disk_type, os_sku, kubernetes_version, vnet_subnet_ids, pod_subnet_ids, labels, taints and tags).
2426
2427
  """
@@ -2434,12 +2435,12 @@ elif False:
2434
2435
  @pulumi.input_type
2435
2436
  class OceanNpVirtualNodeGroupUpdatePolicyArgs:
2436
2437
  def __init__(__self__, *,
2437
- should_roll: pulumi.Input[bool],
2438
- conditioned_roll: Optional[pulumi.Input[bool]] = None,
2438
+ should_roll: pulumi.Input[builtins.bool],
2439
+ conditioned_roll: Optional[pulumi.Input[builtins.bool]] = None,
2439
2440
  roll_config: Optional[pulumi.Input['OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgs']] = None):
2440
2441
  """
2441
- :param pulumi.Input[bool] should_roll: If set to true along with the vng update, roll will be triggered.
2442
- :param pulumi.Input[bool] conditioned_roll: Spot will perform a cluster Roll in accordance with a relevant modification of the cluster’s settings. When set to true , only specific changes in the cluster’s configuration will trigger a cluster roll (such as availability_zones, max_pods_per_node, enable_node_public_ip, os_disk_size_gb, os_disk_type, os_sku, kubernetes_version, vnet_subnet_ids, pod_subnet_ids, labels, taints and tags).
2442
+ :param pulumi.Input[builtins.bool] should_roll: If set to true along with the vng update, roll will be triggered.
2443
+ :param pulumi.Input[builtins.bool] conditioned_roll: Spot will perform a cluster Roll in accordance with a relevant modification of the cluster’s settings. When set to true , only specific changes in the cluster’s configuration will trigger a cluster roll (such as availability_zones, max_pods_per_node, enable_node_public_ip, os_disk_size_gb, os_disk_type, os_sku, kubernetes_version, vnet_subnet_ids, pod_subnet_ids, labels, taints and tags).
2443
2444
  :param pulumi.Input['OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgs'] roll_config: While used, you can control whether the group should perform a deployment after an update to the configuration.
2444
2445
  """
2445
2446
  pulumi.set(__self__, "should_roll", should_roll)
@@ -2450,26 +2451,26 @@ class OceanNpVirtualNodeGroupUpdatePolicyArgs:
2450
2451
 
2451
2452
  @property
2452
2453
  @pulumi.getter(name="shouldRoll")
2453
- def should_roll(self) -> pulumi.Input[bool]:
2454
+ def should_roll(self) -> pulumi.Input[builtins.bool]:
2454
2455
  """
2455
2456
  If set to true along with the vng update, roll will be triggered.
2456
2457
  """
2457
2458
  return pulumi.get(self, "should_roll")
2458
2459
 
2459
2460
  @should_roll.setter
2460
- def should_roll(self, value: pulumi.Input[bool]):
2461
+ def should_roll(self, value: pulumi.Input[builtins.bool]):
2461
2462
  pulumi.set(self, "should_roll", value)
2462
2463
 
2463
2464
  @property
2464
2465
  @pulumi.getter(name="conditionedRoll")
2465
- def conditioned_roll(self) -> Optional[pulumi.Input[bool]]:
2466
+ def conditioned_roll(self) -> Optional[pulumi.Input[builtins.bool]]:
2466
2467
  """
2467
2468
  Spot will perform a cluster Roll in accordance with a relevant modification of the cluster’s settings. When set to true , only specific changes in the cluster’s configuration will trigger a cluster roll (such as availability_zones, max_pods_per_node, enable_node_public_ip, os_disk_size_gb, os_disk_type, os_sku, kubernetes_version, vnet_subnet_ids, pod_subnet_ids, labels, taints and tags).
2468
2469
  """
2469
2470
  return pulumi.get(self, "conditioned_roll")
2470
2471
 
2471
2472
  @conditioned_roll.setter
2472
- def conditioned_roll(self, value: Optional[pulumi.Input[bool]]):
2473
+ def conditioned_roll(self, value: Optional[pulumi.Input[builtins.bool]]):
2473
2474
  pulumi.set(self, "conditioned_roll", value)
2474
2475
 
2475
2476
  @property
@@ -2487,35 +2488,35 @@ class OceanNpVirtualNodeGroupUpdatePolicyArgs:
2487
2488
 
2488
2489
  if not MYPY:
2489
2490
  class OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgsDict(TypedDict):
2490
- batch_min_healthy_percentage: NotRequired[pulumi.Input[int]]
2491
+ batch_min_healthy_percentage: NotRequired[pulumi.Input[builtins.int]]
2491
2492
  """
2492
2493
  Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
2493
2494
  """
2494
- batch_size_percentage: NotRequired[pulumi.Input[int]]
2495
+ batch_size_percentage: NotRequired[pulumi.Input[builtins.int]]
2495
2496
  """
2496
2497
  Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
2497
2498
  """
2498
- comment: NotRequired[pulumi.Input[str]]
2499
+ comment: NotRequired[pulumi.Input[builtins.str]]
2499
2500
  """
2500
2501
  Add a comment description for the roll. The comment is limited to 256 chars and optional.
2501
2502
  """
2502
- node_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
2503
+ node_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
2503
2504
  """
2504
2505
  List of node names to be rolled. Each identifier is a string. nodeNames can be null, and cannot be used together with nodePoolNames and vngIds.
2505
2506
  """
2506
- node_pool_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
2507
+ node_pool_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
2507
2508
  """
2508
2509
  List of node pools to be rolled. Each node pool name is a string. nodePoolNames can be null, and cannot be used together with nodeNames and vngIds.
2509
2510
  """
2510
- respect_pdb: NotRequired[pulumi.Input[bool]]
2511
+ respect_pdb: NotRequired[pulumi.Input[builtins.bool]]
2511
2512
  """
2512
2513
  During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
2513
2514
  """
2514
- respect_restrict_scale_down: NotRequired[pulumi.Input[bool]]
2515
+ respect_restrict_scale_down: NotRequired[pulumi.Input[builtins.bool]]
2515
2516
  """
2516
2517
  During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
2517
2518
  """
2518
- vng_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
2519
+ vng_ids: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
2519
2520
  """
2520
2521
  List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
2521
2522
  """
@@ -2525,23 +2526,23 @@ elif False:
2525
2526
  @pulumi.input_type
2526
2527
  class OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgs:
2527
2528
  def __init__(__self__, *,
2528
- batch_min_healthy_percentage: Optional[pulumi.Input[int]] = None,
2529
- batch_size_percentage: Optional[pulumi.Input[int]] = None,
2530
- comment: Optional[pulumi.Input[str]] = None,
2531
- node_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
2532
- node_pool_names: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
2533
- respect_pdb: Optional[pulumi.Input[bool]] = None,
2534
- respect_restrict_scale_down: Optional[pulumi.Input[bool]] = None,
2535
- vng_ids: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
2536
- """
2537
- :param pulumi.Input[int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
2538
- :param pulumi.Input[int] batch_size_percentage: Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
2539
- :param pulumi.Input[str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
2540
- :param pulumi.Input[Sequence[pulumi.Input[str]]] node_names: List of node names to be rolled. Each identifier is a string. nodeNames can be null, and cannot be used together with nodePoolNames and vngIds.
2541
- :param pulumi.Input[Sequence[pulumi.Input[str]]] node_pool_names: List of node pools to be rolled. Each node pool name is a string. nodePoolNames can be null, and cannot be used together with nodeNames and vngIds.
2542
- :param pulumi.Input[bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
2543
- :param pulumi.Input[bool] respect_restrict_scale_down: During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
2544
- :param pulumi.Input[Sequence[pulumi.Input[str]]] vng_ids: List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
2529
+ batch_min_healthy_percentage: Optional[pulumi.Input[builtins.int]] = None,
2530
+ batch_size_percentage: Optional[pulumi.Input[builtins.int]] = None,
2531
+ comment: Optional[pulumi.Input[builtins.str]] = None,
2532
+ node_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
2533
+ node_pool_names: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None,
2534
+ respect_pdb: Optional[pulumi.Input[builtins.bool]] = None,
2535
+ respect_restrict_scale_down: Optional[pulumi.Input[builtins.bool]] = None,
2536
+ vng_ids: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
2537
+ """
2538
+ :param pulumi.Input[builtins.int] batch_min_healthy_percentage: Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
2539
+ :param pulumi.Input[builtins.int] batch_size_percentage: Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
2540
+ :param pulumi.Input[builtins.str] comment: Add a comment description for the roll. The comment is limited to 256 chars and optional.
2541
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_names: List of node names to be rolled. Each identifier is a string. nodeNames can be null, and cannot be used together with nodePoolNames and vngIds.
2542
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] node_pool_names: List of node pools to be rolled. Each node pool name is a string. nodePoolNames can be null, and cannot be used together with nodeNames and vngIds.
2543
+ :param pulumi.Input[builtins.bool] respect_pdb: During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
2544
+ :param pulumi.Input[builtins.bool] respect_restrict_scale_down: During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
2545
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] vng_ids: List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
2545
2546
  """
2546
2547
  if batch_min_healthy_percentage is not None:
2547
2548
  pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
@@ -2562,98 +2563,98 @@ class OceanNpVirtualNodeGroupUpdatePolicyRollConfigArgs:
2562
2563
 
2563
2564
  @property
2564
2565
  @pulumi.getter(name="batchMinHealthyPercentage")
2565
- def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[int]]:
2566
+ def batch_min_healthy_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
2566
2567
  """
2567
2568
  Indicates the threshold of minimum healthy nodes in single batch. If the amount of healthy nodes in single batch is under the threshold, the roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
2568
2569
  """
2569
2570
  return pulumi.get(self, "batch_min_healthy_percentage")
2570
2571
 
2571
2572
  @batch_min_healthy_percentage.setter
2572
- def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[int]]):
2573
+ def batch_min_healthy_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
2573
2574
  pulumi.set(self, "batch_min_healthy_percentage", value)
2574
2575
 
2575
2576
  @property
2576
2577
  @pulumi.getter(name="batchSizePercentage")
2577
- def batch_size_percentage(self) -> Optional[pulumi.Input[int]]:
2578
+ def batch_size_percentage(self) -> Optional[pulumi.Input[builtins.int]]:
2578
2579
  """
2579
2580
  Value as a percent to set the size of a batch in a roll. Valid values are 0-100. In case of null as value, the default value in the backend will be 20%.
2580
2581
  """
2581
2582
  return pulumi.get(self, "batch_size_percentage")
2582
2583
 
2583
2584
  @batch_size_percentage.setter
2584
- def batch_size_percentage(self, value: Optional[pulumi.Input[int]]):
2585
+ def batch_size_percentage(self, value: Optional[pulumi.Input[builtins.int]]):
2585
2586
  pulumi.set(self, "batch_size_percentage", value)
2586
2587
 
2587
2588
  @property
2588
2589
  @pulumi.getter
2589
- def comment(self) -> Optional[pulumi.Input[str]]:
2590
+ def comment(self) -> Optional[pulumi.Input[builtins.str]]:
2590
2591
  """
2591
2592
  Add a comment description for the roll. The comment is limited to 256 chars and optional.
2592
2593
  """
2593
2594
  return pulumi.get(self, "comment")
2594
2595
 
2595
2596
  @comment.setter
2596
- def comment(self, value: Optional[pulumi.Input[str]]):
2597
+ def comment(self, value: Optional[pulumi.Input[builtins.str]]):
2597
2598
  pulumi.set(self, "comment", value)
2598
2599
 
2599
2600
  @property
2600
2601
  @pulumi.getter(name="nodeNames")
2601
- def node_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
2602
+ def node_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
2602
2603
  """
2603
2604
  List of node names to be rolled. Each identifier is a string. nodeNames can be null, and cannot be used together with nodePoolNames and vngIds.
2604
2605
  """
2605
2606
  return pulumi.get(self, "node_names")
2606
2607
 
2607
2608
  @node_names.setter
2608
- def node_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
2609
+ def node_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
2609
2610
  pulumi.set(self, "node_names", value)
2610
2611
 
2611
2612
  @property
2612
2613
  @pulumi.getter(name="nodePoolNames")
2613
- def node_pool_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
2614
+ def node_pool_names(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
2614
2615
  """
2615
2616
  List of node pools to be rolled. Each node pool name is a string. nodePoolNames can be null, and cannot be used together with nodeNames and vngIds.
2616
2617
  """
2617
2618
  return pulumi.get(self, "node_pool_names")
2618
2619
 
2619
2620
  @node_pool_names.setter
2620
- def node_pool_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
2621
+ def node_pool_names(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
2621
2622
  pulumi.set(self, "node_pool_names", value)
2622
2623
 
2623
2624
  @property
2624
2625
  @pulumi.getter(name="respectPdb")
2625
- def respect_pdb(self) -> Optional[pulumi.Input[bool]]:
2626
+ def respect_pdb(self) -> Optional[pulumi.Input[builtins.bool]]:
2626
2627
  """
2627
2628
  During the roll, if the parameter is set to true we honor PDB during the nodes replacement.
2628
2629
  """
2629
2630
  return pulumi.get(self, "respect_pdb")
2630
2631
 
2631
2632
  @respect_pdb.setter
2632
- def respect_pdb(self, value: Optional[pulumi.Input[bool]]):
2633
+ def respect_pdb(self, value: Optional[pulumi.Input[builtins.bool]]):
2633
2634
  pulumi.set(self, "respect_pdb", value)
2634
2635
 
2635
2636
  @property
2636
2637
  @pulumi.getter(name="respectRestrictScaleDown")
2637
- def respect_restrict_scale_down(self) -> Optional[pulumi.Input[bool]]:
2638
+ def respect_restrict_scale_down(self) -> Optional[pulumi.Input[builtins.bool]]:
2638
2639
  """
2639
2640
  During the roll, if the parameter is set to true we honor Restrict Scale Down label during the nodes replacement.
2640
2641
  """
2641
2642
  return pulumi.get(self, "respect_restrict_scale_down")
2642
2643
 
2643
2644
  @respect_restrict_scale_down.setter
2644
- def respect_restrict_scale_down(self, value: Optional[pulumi.Input[bool]]):
2645
+ def respect_restrict_scale_down(self, value: Optional[pulumi.Input[builtins.bool]]):
2645
2646
  pulumi.set(self, "respect_restrict_scale_down", value)
2646
2647
 
2647
2648
  @property
2648
2649
  @pulumi.getter(name="vngIds")
2649
- def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
2650
+ def vng_ids(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
2650
2651
  """
2651
2652
  List of virtual node group identifiers to be rolled. Each identifier is a string. vngIds can be null, and cannot be used together with nodeNames and nodePoolNames.
2652
2653
  """
2653
2654
  return pulumi.get(self, "vng_ids")
2654
2655
 
2655
2656
  @vng_ids.setter
2656
- def vng_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
2657
+ def vng_ids(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
2657
2658
  pulumi.set(self, "vng_ids", value)
2658
2659
 
2659
2660
 
@@ -2682,8 +2683,8 @@ class OceanNpVngTemplateSchedulingArgs:
2682
2683
 
2683
2684
  if not MYPY:
2684
2685
  class OceanNpVngTemplateSchedulingVngTemplateShutdownHoursArgsDict(TypedDict):
2685
- is_enabled: NotRequired[pulumi.Input[bool]]
2686
- time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
2686
+ is_enabled: NotRequired[pulumi.Input[builtins.bool]]
2687
+ time_windows: NotRequired[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]
2687
2688
  """
2688
2689
  The times that the shutdown hours will apply. Required if `is_enabled` is true.
2689
2690
  """
@@ -2693,10 +2694,10 @@ elif False:
2693
2694
  @pulumi.input_type
2694
2695
  class OceanNpVngTemplateSchedulingVngTemplateShutdownHoursArgs:
2695
2696
  def __init__(__self__, *,
2696
- is_enabled: Optional[pulumi.Input[bool]] = None,
2697
- time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None):
2697
+ is_enabled: Optional[pulumi.Input[builtins.bool]] = None,
2698
+ time_windows: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
2698
2699
  """
2699
- :param pulumi.Input[Sequence[pulumi.Input[str]]] time_windows: The times that the shutdown hours will apply. Required if `is_enabled` is true.
2700
+ :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] time_windows: The times that the shutdown hours will apply. Required if `is_enabled` is true.
2700
2701
  """
2701
2702
  if is_enabled is not None:
2702
2703
  pulumi.set(__self__, "is_enabled", is_enabled)
@@ -2705,23 +2706,23 @@ class OceanNpVngTemplateSchedulingVngTemplateShutdownHoursArgs:
2705
2706
 
2706
2707
  @property
2707
2708
  @pulumi.getter(name="isEnabled")
2708
- def is_enabled(self) -> Optional[pulumi.Input[bool]]:
2709
+ def is_enabled(self) -> Optional[pulumi.Input[builtins.bool]]:
2709
2710
  return pulumi.get(self, "is_enabled")
2710
2711
 
2711
2712
  @is_enabled.setter
2712
- def is_enabled(self, value: Optional[pulumi.Input[bool]]):
2713
+ def is_enabled(self, value: Optional[pulumi.Input[builtins.bool]]):
2713
2714
  pulumi.set(self, "is_enabled", value)
2714
2715
 
2715
2716
  @property
2716
2717
  @pulumi.getter(name="timeWindows")
2717
- def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
2718
+ def time_windows(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]:
2718
2719
  """
2719
2720
  The times that the shutdown hours will apply. Required if `is_enabled` is true.
2720
2721
  """
2721
2722
  return pulumi.get(self, "time_windows")
2722
2723
 
2723
2724
  @time_windows.setter
2724
- def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
2725
+ def time_windows(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]]):
2725
2726
  pulumi.set(self, "time_windows", value)
2726
2727
 
2727
2728