pulumi-spotinst 3.124.0a1753339288__py3-none-any.whl → 3.124.0a1753398242__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 (76) hide show
  1. pulumi_spotinst/__init__.py +1 -1
  2. pulumi_spotinst/_inputs.py +1616 -1617
  3. pulumi_spotinst/account.py +18 -19
  4. pulumi_spotinst/aws/__init__.py +1 -1
  5. pulumi_spotinst/aws/_inputs.py +3654 -3655
  6. pulumi_spotinst/aws/account.py +18 -19
  7. pulumi_spotinst/aws/beanstalk.py +176 -177
  8. pulumi_spotinst/aws/credentials.py +35 -36
  9. pulumi_spotinst/aws/elastigroup.py +936 -937
  10. pulumi_spotinst/aws/managed_instance.py +505 -506
  11. pulumi_spotinst/aws/mr_scalar.py +652 -653
  12. pulumi_spotinst/aws/ocean.py +531 -532
  13. pulumi_spotinst/aws/ocean_extended_resource_definition.py +35 -36
  14. pulumi_spotinst/aws/ocean_launch_spec.py +302 -303
  15. pulumi_spotinst/aws/outputs.py +2392 -2393
  16. pulumi_spotinst/aws/suspension.py +21 -22
  17. pulumi_spotinst/azure/__init__.py +1 -1
  18. pulumi_spotinst/azure/_inputs.py +606 -607
  19. pulumi_spotinst/azure/ocean_np.py +385 -386
  20. pulumi_spotinst/azure/ocean_np_virtual_node_group.py +321 -322
  21. pulumi_spotinst/azure/outputs.py +410 -411
  22. pulumi_spotinst/config/__init__.py +1 -1
  23. pulumi_spotinst/config/__init__.pyi +1 -2
  24. pulumi_spotinst/config/vars.py +5 -6
  25. pulumi_spotinst/credentials_azure.py +103 -104
  26. pulumi_spotinst/credentials_gcp.py +188 -189
  27. pulumi_spotinst/data_integration.py +38 -39
  28. pulumi_spotinst/ecs/__init__.py +1 -1
  29. pulumi_spotinst/ecs/_inputs.py +583 -584
  30. pulumi_spotinst/ecs/ocean.py +414 -415
  31. pulumi_spotinst/ecs/ocean_launch_spec.py +195 -196
  32. pulumi_spotinst/ecs/outputs.py +393 -394
  33. pulumi_spotinst/elastigroup_azure_v3.py +324 -325
  34. pulumi_spotinst/gcp/__init__.py +1 -1
  35. pulumi_spotinst/gcp/_inputs.py +505 -506
  36. pulumi_spotinst/gcp/elastigroup.py +481 -482
  37. pulumi_spotinst/gcp/outputs.py +335 -336
  38. pulumi_spotinst/gke/__init__.py +1 -1
  39. pulumi_spotinst/gke/_inputs.py +917 -918
  40. pulumi_spotinst/gke/elastigroup.py +339 -340
  41. pulumi_spotinst/gke/ocean_import.py +202 -203
  42. pulumi_spotinst/gke/ocean_launch_spec.py +210 -211
  43. pulumi_spotinst/gke/ocean_launch_spec_import.py +35 -36
  44. pulumi_spotinst/gke/outputs.py +597 -598
  45. pulumi_spotinst/health_check.py +64 -65
  46. pulumi_spotinst/notification_center.py +62 -63
  47. pulumi_spotinst/ocean_right_sizing_rule.py +74 -75
  48. pulumi_spotinst/oceancd/__init__.py +1 -1
  49. pulumi_spotinst/oceancd/_inputs.py +763 -764
  50. pulumi_spotinst/oceancd/outputs.py +525 -526
  51. pulumi_spotinst/oceancd/rollout_spec.py +33 -34
  52. pulumi_spotinst/oceancd/strategy.py +20 -21
  53. pulumi_spotinst/oceancd/verification_provider.py +50 -51
  54. pulumi_spotinst/oceancd/verification_template.py +24 -25
  55. pulumi_spotinst/organization/__init__.py +1 -1
  56. pulumi_spotinst/organization/_inputs.py +67 -68
  57. pulumi_spotinst/organization/outputs.py +45 -46
  58. pulumi_spotinst/organization/policy.py +38 -39
  59. pulumi_spotinst/organization/programmatic_user.py +58 -59
  60. pulumi_spotinst/organization/user.py +106 -107
  61. pulumi_spotinst/organization/user_group.py +55 -56
  62. pulumi_spotinst/outputs.py +990 -991
  63. pulumi_spotinst/provider.py +40 -41
  64. pulumi_spotinst/pulumi-plugin.json +1 -1
  65. pulumi_spotinst/spark/__init__.py +1 -1
  66. pulumi_spotinst/spark/_inputs.py +103 -104
  67. pulumi_spotinst/spark/ocean.py +36 -37
  68. pulumi_spotinst/spark/ocean_virtual_node_group.py +27 -28
  69. pulumi_spotinst/spark/outputs.py +71 -72
  70. pulumi_spotinst/stateful_node_azure.py +304 -305
  71. pulumi_spotinst/subscription.py +86 -87
  72. {pulumi_spotinst-3.124.0a1753339288.dist-info → pulumi_spotinst-3.124.0a1753398242.dist-info}/METADATA +1 -1
  73. pulumi_spotinst-3.124.0a1753398242.dist-info/RECORD +77 -0
  74. pulumi_spotinst-3.124.0a1753339288.dist-info/RECORD +0 -77
  75. {pulumi_spotinst-3.124.0a1753339288.dist-info → pulumi_spotinst-3.124.0a1753398242.dist-info}/WHEEL +0 -0
  76. {pulumi_spotinst-3.124.0a1753339288.dist-info → pulumi_spotinst-3.124.0a1753398242.dist-info}/top_level.txt +0 -0
pulumi_spotinst/outputs.py CHANGED
@@ -2,8 +2,7 @@
2
2
  # *** WARNING: this file was generated by pulumi-language-python. ***
3
3
  # *** Do not edit by hand unless you're certain you know what you are doing! ***
4
4
 
5
- import builtins
6
- import copy
5
+ import builtins as _builtins
7
6
  import warnings
8
7
  import sys
9
8
  import pulumi
@@ -137,23 +136,23 @@ class DataIntegrationS3(dict):
137
136
  return super().get(key, default)
138
137
 
139
138
  def __init__(__self__, *,
140
- bucket_name: builtins.str,
141
- subdir: Optional[builtins.str] = None):
139
+ bucket_name: _builtins.str,
140
+ subdir: Optional[_builtins.str] = None):
142
141
  """
143
- :param builtins.str subdir: The subdirectory in which your files will be stored within the bucket. Adds the prefix subdir/ to new objects' keys. Can't be null or contain '/'.
142
+ :param _builtins.str subdir: The subdirectory in which your files will be stored within the bucket. Adds the prefix subdir/ to new objects' keys. Can't be null or contain '/'.
144
143
  """
145
144
  pulumi.set(__self__, "bucket_name", bucket_name)
146
145
  if subdir is not None:
147
146
  pulumi.set(__self__, "subdir", subdir)
148
147
 
149
- @property
148
+ @_builtins.property
150
149
  @pulumi.getter(name="bucketName")
151
- def bucket_name(self) -> builtins.str:
150
+ def bucket_name(self) -> _builtins.str:
152
151
  return pulumi.get(self, "bucket_name")
153
152
 
154
- @property
153
+ @_builtins.property
155
154
  @pulumi.getter
156
- def subdir(self) -> Optional[builtins.str]:
155
+ def subdir(self) -> Optional[_builtins.str]:
157
156
  """
158
157
  The subdirectory in which your files will be stored within the bucket. Adds the prefix subdir/ to new objects' keys. Can't be null or contain '/'.
159
158
  """
@@ -182,27 +181,27 @@ class ElastigroupAzureV3BootDiagnostic(dict):
182
181
  return super().get(key, default)
183
182
 
184
183
  def __init__(__self__, *,
185
- is_enabled: builtins.bool,
186
- type: builtins.str,
187
- storage_url: Optional[builtins.str] = None):
184
+ is_enabled: _builtins.bool,
185
+ type: _builtins.str,
186
+ storage_url: Optional[_builtins.str] = None):
188
187
  pulumi.set(__self__, "is_enabled", is_enabled)
189
188
  pulumi.set(__self__, "type", type)
190
189
  if storage_url is not None:
191
190
  pulumi.set(__self__, "storage_url", storage_url)
192
191
 
193
- @property
192
+ @_builtins.property
194
193
  @pulumi.getter(name="isEnabled")
195
- def is_enabled(self) -> builtins.bool:
194
+ def is_enabled(self) -> _builtins.bool:
196
195
  return pulumi.get(self, "is_enabled")
197
196
 
198
- @property
197
+ @_builtins.property
199
198
  @pulumi.getter
200
- def type(self) -> builtins.str:
199
+ def type(self) -> _builtins.str:
201
200
  return pulumi.get(self, "type")
202
201
 
203
- @property
202
+ @_builtins.property
204
203
  @pulumi.getter(name="storageUrl")
205
- def storage_url(self) -> Optional[builtins.str]:
204
+ def storage_url(self) -> Optional[_builtins.str]:
206
205
  return pulumi.get(self, "storage_url")
207
206
 
208
207
 
@@ -230,25 +229,25 @@ class ElastigroupAzureV3CapacityReservation(dict):
230
229
  return super().get(key, default)
231
230
 
232
231
  def __init__(__self__, *,
233
- should_utilize: builtins.bool,
234
- utilization_strategy: builtins.str,
232
+ should_utilize: _builtins.bool,
233
+ utilization_strategy: _builtins.str,
235
234
  capacity_reservation_groups: Optional['outputs.ElastigroupAzureV3CapacityReservationCapacityReservationGroups'] = None):
236
235
  pulumi.set(__self__, "should_utilize", should_utilize)
237
236
  pulumi.set(__self__, "utilization_strategy", utilization_strategy)
238
237
  if capacity_reservation_groups is not None:
239
238
  pulumi.set(__self__, "capacity_reservation_groups", capacity_reservation_groups)
240
239
 
241
- @property
240
+ @_builtins.property
242
241
  @pulumi.getter(name="shouldUtilize")
243
- def should_utilize(self) -> builtins.bool:
242
+ def should_utilize(self) -> _builtins.bool:
244
243
  return pulumi.get(self, "should_utilize")
245
244
 
246
- @property
245
+ @_builtins.property
247
246
  @pulumi.getter(name="utilizationStrategy")
248
- def utilization_strategy(self) -> builtins.str:
247
+ def utilization_strategy(self) -> _builtins.str:
249
248
  return pulumi.get(self, "utilization_strategy")
250
249
 
251
- @property
250
+ @_builtins.property
252
251
  @pulumi.getter(name="capacityReservationGroups")
253
252
  def capacity_reservation_groups(self) -> Optional['outputs.ElastigroupAzureV3CapacityReservationCapacityReservationGroups']:
254
253
  return pulumi.get(self, "capacity_reservation_groups")
@@ -278,27 +277,27 @@ class ElastigroupAzureV3CapacityReservationCapacityReservationGroups(dict):
278
277
  return super().get(key, default)
279
278
 
280
279
  def __init__(__self__, *,
281
- crg_name: builtins.str,
282
- crg_resource_group_name: builtins.str,
283
- crg_should_prioritize: Optional[builtins.bool] = None):
280
+ crg_name: _builtins.str,
281
+ crg_resource_group_name: _builtins.str,
282
+ crg_should_prioritize: Optional[_builtins.bool] = None):
284
283
  pulumi.set(__self__, "crg_name", crg_name)
285
284
  pulumi.set(__self__, "crg_resource_group_name", crg_resource_group_name)
286
285
  if crg_should_prioritize is not None:
287
286
  pulumi.set(__self__, "crg_should_prioritize", crg_should_prioritize)
288
287
 
289
- @property
288
+ @_builtins.property
290
289
  @pulumi.getter(name="crgName")
291
- def crg_name(self) -> builtins.str:
290
+ def crg_name(self) -> _builtins.str:
292
291
  return pulumi.get(self, "crg_name")
293
292
 
294
- @property
293
+ @_builtins.property
295
294
  @pulumi.getter(name="crgResourceGroupName")
296
- def crg_resource_group_name(self) -> builtins.str:
295
+ def crg_resource_group_name(self) -> _builtins.str:
297
296
  return pulumi.get(self, "crg_resource_group_name")
298
297
 
299
- @property
298
+ @_builtins.property
300
299
  @pulumi.getter(name="crgShouldPrioritize")
301
- def crg_should_prioritize(self) -> Optional[builtins.bool]:
300
+ def crg_should_prioritize(self) -> Optional[_builtins.bool]:
302
301
  return pulumi.get(self, "crg_should_prioritize")
303
302
 
304
303
 
@@ -322,26 +321,26 @@ class ElastigroupAzureV3DataDisk(dict):
322
321
  return super().get(key, default)
323
322
 
324
323
  def __init__(__self__, *,
325
- lun: builtins.int,
326
- size_gb: builtins.int,
327
- type: builtins.str):
324
+ lun: _builtins.int,
325
+ size_gb: _builtins.int,
326
+ type: _builtins.str):
328
327
  pulumi.set(__self__, "lun", lun)
329
328
  pulumi.set(__self__, "size_gb", size_gb)
330
329
  pulumi.set(__self__, "type", type)
331
330
 
332
- @property
331
+ @_builtins.property
333
332
  @pulumi.getter
334
- def lun(self) -> builtins.int:
333
+ def lun(self) -> _builtins.int:
335
334
  return pulumi.get(self, "lun")
336
335
 
337
- @property
336
+ @_builtins.property
338
337
  @pulumi.getter(name="sizeGb")
339
- def size_gb(self) -> builtins.int:
338
+ def size_gb(self) -> _builtins.int:
340
339
  return pulumi.get(self, "size_gb")
341
340
 
342
- @property
341
+ @_builtins.property
343
342
  @pulumi.getter
344
- def type(self) -> builtins.str:
343
+ def type(self) -> _builtins.str:
345
344
  return pulumi.get(self, "type")
346
345
 
347
346
 
@@ -375,15 +374,15 @@ class ElastigroupAzureV3Extension(dict):
375
374
  return super().get(key, default)
376
375
 
377
376
  def __init__(__self__, *,
378
- api_version: builtins.str,
379
- minor_version_auto_upgrade: builtins.bool,
380
- name: builtins.str,
381
- publisher: builtins.str,
382
- type: builtins.str,
383
- enable_automatic_upgrade: Optional[builtins.bool] = None,
384
- protected_settings: Optional[Mapping[str, builtins.str]] = None,
377
+ api_version: _builtins.str,
378
+ minor_version_auto_upgrade: _builtins.bool,
379
+ name: _builtins.str,
380
+ publisher: _builtins.str,
381
+ type: _builtins.str,
382
+ enable_automatic_upgrade: Optional[_builtins.bool] = None,
383
+ protected_settings: Optional[Mapping[str, _builtins.str]] = None,
385
384
  protected_settings_from_key_vault: Optional['outputs.ElastigroupAzureV3ExtensionProtectedSettingsFromKeyVault'] = None,
386
- public_settings: Optional[Mapping[str, builtins.str]] = None):
385
+ public_settings: Optional[Mapping[str, _builtins.str]] = None):
387
386
  pulumi.set(__self__, "api_version", api_version)
388
387
  pulumi.set(__self__, "minor_version_auto_upgrade", minor_version_auto_upgrade)
389
388
  pulumi.set(__self__, "name", name)
@@ -398,49 +397,49 @@ class ElastigroupAzureV3Extension(dict):
398
397
  if public_settings is not None:
399
398
  pulumi.set(__self__, "public_settings", public_settings)
400
399
 
401
- @property
400
+ @_builtins.property
402
401
  @pulumi.getter(name="apiVersion")
403
- def api_version(self) -> builtins.str:
402
+ def api_version(self) -> _builtins.str:
404
403
  return pulumi.get(self, "api_version")
405
404
 
406
- @property
405
+ @_builtins.property
407
406
  @pulumi.getter(name="minorVersionAutoUpgrade")
408
- def minor_version_auto_upgrade(self) -> builtins.bool:
407
+ def minor_version_auto_upgrade(self) -> _builtins.bool:
409
408
  return pulumi.get(self, "minor_version_auto_upgrade")
410
409
 
411
- @property
410
+ @_builtins.property
412
411
  @pulumi.getter
413
- def name(self) -> builtins.str:
412
+ def name(self) -> _builtins.str:
414
413
  return pulumi.get(self, "name")
415
414
 
416
- @property
415
+ @_builtins.property
417
416
  @pulumi.getter
418
- def publisher(self) -> builtins.str:
417
+ def publisher(self) -> _builtins.str:
419
418
  return pulumi.get(self, "publisher")
420
419
 
421
- @property
420
+ @_builtins.property
422
421
  @pulumi.getter
423
- def type(self) -> builtins.str:
422
+ def type(self) -> _builtins.str:
424
423
  return pulumi.get(self, "type")
425
424
 
426
- @property
425
+ @_builtins.property
427
426
  @pulumi.getter(name="enableAutomaticUpgrade")
428
- def enable_automatic_upgrade(self) -> Optional[builtins.bool]:
427
+ def enable_automatic_upgrade(self) -> Optional[_builtins.bool]:
429
428
  return pulumi.get(self, "enable_automatic_upgrade")
430
429
 
431
- @property
430
+ @_builtins.property
432
431
  @pulumi.getter(name="protectedSettings")
433
- def protected_settings(self) -> Optional[Mapping[str, builtins.str]]:
432
+ def protected_settings(self) -> Optional[Mapping[str, _builtins.str]]:
434
433
  return pulumi.get(self, "protected_settings")
435
434
 
436
- @property
435
+ @_builtins.property
437
436
  @pulumi.getter(name="protectedSettingsFromKeyVault")
438
437
  def protected_settings_from_key_vault(self) -> Optional['outputs.ElastigroupAzureV3ExtensionProtectedSettingsFromKeyVault']:
439
438
  return pulumi.get(self, "protected_settings_from_key_vault")
440
439
 
441
- @property
440
+ @_builtins.property
442
441
  @pulumi.getter(name="publicSettings")
443
- def public_settings(self) -> Optional[Mapping[str, builtins.str]]:
442
+ def public_settings(self) -> Optional[Mapping[str, _builtins.str]]:
444
443
  return pulumi.get(self, "public_settings")
445
444
 
446
445
 
@@ -466,19 +465,19 @@ class ElastigroupAzureV3ExtensionProtectedSettingsFromKeyVault(dict):
466
465
  return super().get(key, default)
467
466
 
468
467
  def __init__(__self__, *,
469
- secret_url: builtins.str,
470
- source_vault: builtins.str):
468
+ secret_url: _builtins.str,
469
+ source_vault: _builtins.str):
471
470
  pulumi.set(__self__, "secret_url", secret_url)
472
471
  pulumi.set(__self__, "source_vault", source_vault)
473
472
 
474
- @property
473
+ @_builtins.property
475
474
  @pulumi.getter(name="secretUrl")
476
- def secret_url(self) -> builtins.str:
475
+ def secret_url(self) -> _builtins.str:
477
476
  return pulumi.get(self, "secret_url")
478
477
 
479
- @property
478
+ @_builtins.property
480
479
  @pulumi.getter(name="sourceVault")
481
- def source_vault(self) -> builtins.str:
480
+ def source_vault(self) -> _builtins.str:
482
481
  return pulumi.get(self, "source_vault")
483
482
 
484
483
 
@@ -508,10 +507,10 @@ class ElastigroupAzureV3Health(dict):
508
507
  return super().get(key, default)
509
508
 
510
509
  def __init__(__self__, *,
511
- auto_healing: Optional[builtins.bool] = None,
512
- grace_period: Optional[builtins.int] = None,
513
- health_check_types: Optional[Sequence[builtins.str]] = None,
514
- unhealthy_duration: Optional[builtins.int] = None):
510
+ auto_healing: Optional[_builtins.bool] = None,
511
+ grace_period: Optional[_builtins.int] = None,
512
+ health_check_types: Optional[Sequence[_builtins.str]] = None,
513
+ unhealthy_duration: Optional[_builtins.int] = None):
515
514
  if auto_healing is not None:
516
515
  pulumi.set(__self__, "auto_healing", auto_healing)
517
516
  if grace_period is not None:
@@ -521,24 +520,24 @@ class ElastigroupAzureV3Health(dict):
521
520
  if unhealthy_duration is not None:
522
521
  pulumi.set(__self__, "unhealthy_duration", unhealthy_duration)
523
522
 
524
- @property
523
+ @_builtins.property
525
524
  @pulumi.getter(name="autoHealing")
526
- def auto_healing(self) -> Optional[builtins.bool]:
525
+ def auto_healing(self) -> Optional[_builtins.bool]:
527
526
  return pulumi.get(self, "auto_healing")
528
527
 
529
- @property
528
+ @_builtins.property
530
529
  @pulumi.getter(name="gracePeriod")
531
- def grace_period(self) -> Optional[builtins.int]:
530
+ def grace_period(self) -> Optional[_builtins.int]:
532
531
  return pulumi.get(self, "grace_period")
533
532
 
534
- @property
533
+ @_builtins.property
535
534
  @pulumi.getter(name="healthCheckTypes")
536
- def health_check_types(self) -> Optional[Sequence[builtins.str]]:
535
+ def health_check_types(self) -> Optional[Sequence[_builtins.str]]:
537
536
  return pulumi.get(self, "health_check_types")
538
537
 
539
- @property
538
+ @_builtins.property
540
539
  @pulumi.getter(name="unhealthyDuration")
541
- def unhealthy_duration(self) -> Optional[builtins.int]:
540
+ def unhealthy_duration(self) -> Optional[_builtins.int]:
542
541
  return pulumi.get(self, "unhealthy_duration")
543
542
 
544
543
 
@@ -572,17 +571,17 @@ class ElastigroupAzureV3Image(dict):
572
571
  if marketplaces is not None:
573
572
  pulumi.set(__self__, "marketplaces", marketplaces)
574
573
 
575
- @property
574
+ @_builtins.property
576
575
  @pulumi.getter
577
576
  def customs(self) -> Optional[Sequence['outputs.ElastigroupAzureV3ImageCustom']]:
578
577
  return pulumi.get(self, "customs")
579
578
 
580
- @property
579
+ @_builtins.property
581
580
  @pulumi.getter(name="galleryImages")
582
581
  def gallery_images(self) -> Optional[Sequence['outputs.ElastigroupAzureV3ImageGalleryImage']]:
583
582
  return pulumi.get(self, "gallery_images")
584
583
 
585
- @property
584
+ @_builtins.property
586
585
  @pulumi.getter
587
586
  def marketplaces(self) -> Optional[Sequence['outputs.ElastigroupAzureV3ImageMarketplace']]:
588
587
  return pulumi.get(self, "marketplaces")
@@ -610,19 +609,19 @@ class ElastigroupAzureV3ImageCustom(dict):
610
609
  return super().get(key, default)
611
610
 
612
611
  def __init__(__self__, *,
613
- image_name: builtins.str,
614
- resource_group_name: builtins.str):
612
+ image_name: _builtins.str,
613
+ resource_group_name: _builtins.str):
615
614
  pulumi.set(__self__, "image_name", image_name)
616
615
  pulumi.set(__self__, "resource_group_name", resource_group_name)
617
616
 
618
- @property
617
+ @_builtins.property
619
618
  @pulumi.getter(name="imageName")
620
- def image_name(self) -> builtins.str:
619
+ def image_name(self) -> _builtins.str:
621
620
  return pulumi.get(self, "image_name")
622
621
 
623
- @property
622
+ @_builtins.property
624
623
  @pulumi.getter(name="resourceGroupName")
625
- def resource_group_name(self) -> builtins.str:
624
+ def resource_group_name(self) -> _builtins.str:
626
625
  return pulumi.get(self, "resource_group_name")
627
626
 
628
627
 
@@ -652,11 +651,11 @@ class ElastigroupAzureV3ImageGalleryImage(dict):
652
651
  return super().get(key, default)
653
652
 
654
653
  def __init__(__self__, *,
655
- gallery_name: builtins.str,
656
- image_name: builtins.str,
657
- resource_group_name: builtins.str,
658
- version: builtins.str,
659
- spot_account_id: Optional[builtins.str] = None):
654
+ gallery_name: _builtins.str,
655
+ image_name: _builtins.str,
656
+ resource_group_name: _builtins.str,
657
+ version: _builtins.str,
658
+ spot_account_id: Optional[_builtins.str] = None):
660
659
  pulumi.set(__self__, "gallery_name", gallery_name)
661
660
  pulumi.set(__self__, "image_name", image_name)
662
661
  pulumi.set(__self__, "resource_group_name", resource_group_name)
@@ -664,62 +663,62 @@ class ElastigroupAzureV3ImageGalleryImage(dict):
664
663
  if spot_account_id is not None:
665
664
  pulumi.set(__self__, "spot_account_id", spot_account_id)
666
665
 
667
- @property
666
+ @_builtins.property
668
667
  @pulumi.getter(name="galleryName")
669
- def gallery_name(self) -> builtins.str:
668
+ def gallery_name(self) -> _builtins.str:
670
669
  return pulumi.get(self, "gallery_name")
671
670
 
672
- @property
671
+ @_builtins.property
673
672
  @pulumi.getter(name="imageName")
674
- def image_name(self) -> builtins.str:
673
+ def image_name(self) -> _builtins.str:
675
674
  return pulumi.get(self, "image_name")
676
675
 
677
- @property
676
+ @_builtins.property
678
677
  @pulumi.getter(name="resourceGroupName")
679
- def resource_group_name(self) -> builtins.str:
678
+ def resource_group_name(self) -> _builtins.str:
680
679
  return pulumi.get(self, "resource_group_name")
681
680
 
682
- @property
681
+ @_builtins.property
683
682
  @pulumi.getter
684
- def version(self) -> builtins.str:
683
+ def version(self) -> _builtins.str:
685
684
  return pulumi.get(self, "version")
686
685
 
687
- @property
686
+ @_builtins.property
688
687
  @pulumi.getter(name="spotAccountId")
689
- def spot_account_id(self) -> Optional[builtins.str]:
688
+ def spot_account_id(self) -> Optional[_builtins.str]:
690
689
  return pulumi.get(self, "spot_account_id")
691
690
 
692
691
 
693
692
  @pulumi.output_type
694
693
  class ElastigroupAzureV3ImageMarketplace(dict):
695
694
  def __init__(__self__, *,
696
- offer: builtins.str,
697
- publisher: builtins.str,
698
- sku: builtins.str,
699
- version: builtins.str):
695
+ offer: _builtins.str,
696
+ publisher: _builtins.str,
697
+ sku: _builtins.str,
698
+ version: _builtins.str):
700
699
  pulumi.set(__self__, "offer", offer)
701
700
  pulumi.set(__self__, "publisher", publisher)
702
701
  pulumi.set(__self__, "sku", sku)
703
702
  pulumi.set(__self__, "version", version)
704
703
 
705
- @property
704
+ @_builtins.property
706
705
  @pulumi.getter
707
- def offer(self) -> builtins.str:
706
+ def offer(self) -> _builtins.str:
708
707
  return pulumi.get(self, "offer")
709
708
 
710
- @property
709
+ @_builtins.property
711
710
  @pulumi.getter
712
- def publisher(self) -> builtins.str:
711
+ def publisher(self) -> _builtins.str:
713
712
  return pulumi.get(self, "publisher")
714
713
 
715
- @property
714
+ @_builtins.property
716
715
  @pulumi.getter
717
- def sku(self) -> builtins.str:
716
+ def sku(self) -> _builtins.str:
718
717
  return pulumi.get(self, "sku")
719
718
 
720
- @property
719
+ @_builtins.property
721
720
  @pulumi.getter
722
- def version(self) -> builtins.str:
721
+ def version(self) -> _builtins.str:
723
722
  return pulumi.get(self, "version")
724
723
 
725
724
 
@@ -745,11 +744,11 @@ class ElastigroupAzureV3LoadBalancer(dict):
745
744
  return super().get(key, default)
746
745
 
747
746
  def __init__(__self__, *,
748
- name: builtins.str,
749
- resource_group_name: builtins.str,
750
- type: builtins.str,
751
- backend_pool_names: Optional[Sequence[builtins.str]] = None,
752
- sku: Optional[builtins.str] = None):
747
+ name: _builtins.str,
748
+ resource_group_name: _builtins.str,
749
+ type: _builtins.str,
750
+ backend_pool_names: Optional[Sequence[_builtins.str]] = None,
751
+ sku: Optional[_builtins.str] = None):
753
752
  pulumi.set(__self__, "name", name)
754
753
  pulumi.set(__self__, "resource_group_name", resource_group_name)
755
754
  pulumi.set(__self__, "type", type)
@@ -758,29 +757,29 @@ class ElastigroupAzureV3LoadBalancer(dict):
758
757
  if sku is not None:
759
758
  pulumi.set(__self__, "sku", sku)
760
759
 
761
- @property
760
+ @_builtins.property
762
761
  @pulumi.getter
763
- def name(self) -> builtins.str:
762
+ def name(self) -> _builtins.str:
764
763
  return pulumi.get(self, "name")
765
764
 
766
- @property
765
+ @_builtins.property
767
766
  @pulumi.getter(name="resourceGroupName")
768
- def resource_group_name(self) -> builtins.str:
767
+ def resource_group_name(self) -> _builtins.str:
769
768
  return pulumi.get(self, "resource_group_name")
770
769
 
771
- @property
770
+ @_builtins.property
772
771
  @pulumi.getter
773
- def type(self) -> builtins.str:
772
+ def type(self) -> _builtins.str:
774
773
  return pulumi.get(self, "type")
775
774
 
776
- @property
775
+ @_builtins.property
777
776
  @pulumi.getter(name="backendPoolNames")
778
- def backend_pool_names(self) -> Optional[Sequence[builtins.str]]:
777
+ def backend_pool_names(self) -> Optional[Sequence[_builtins.str]]:
779
778
  return pulumi.get(self, "backend_pool_names")
780
779
 
781
- @property
780
+ @_builtins.property
782
781
  @pulumi.getter
783
- def sku(self) -> Optional[builtins.str]:
782
+ def sku(self) -> Optional[_builtins.str]:
784
783
  return pulumi.get(self, "sku")
785
784
 
786
785
 
@@ -806,28 +805,28 @@ class ElastigroupAzureV3Login(dict):
806
805
  return super().get(key, default)
807
806
 
808
807
  def __init__(__self__, *,
809
- user_name: builtins.str,
810
- password: Optional[builtins.str] = None,
811
- ssh_public_key: Optional[builtins.str] = None):
808
+ user_name: _builtins.str,
809
+ password: Optional[_builtins.str] = None,
810
+ ssh_public_key: Optional[_builtins.str] = None):
812
811
  pulumi.set(__self__, "user_name", user_name)
813
812
  if password is not None:
814
813
  pulumi.set(__self__, "password", password)
815
814
  if ssh_public_key is not None:
816
815
  pulumi.set(__self__, "ssh_public_key", ssh_public_key)
817
816
 
818
- @property
817
+ @_builtins.property
819
818
  @pulumi.getter(name="userName")
820
- def user_name(self) -> builtins.str:
819
+ def user_name(self) -> _builtins.str:
821
820
  return pulumi.get(self, "user_name")
822
821
 
823
- @property
822
+ @_builtins.property
824
823
  @pulumi.getter
825
- def password(self) -> Optional[builtins.str]:
824
+ def password(self) -> Optional[_builtins.str]:
826
825
  return pulumi.get(self, "password")
827
826
 
828
- @property
827
+ @_builtins.property
829
828
  @pulumi.getter(name="sshPublicKey")
830
- def ssh_public_key(self) -> Optional[builtins.str]:
829
+ def ssh_public_key(self) -> Optional[_builtins.str]:
831
830
  return pulumi.get(self, "ssh_public_key")
832
831
 
833
832
 
@@ -851,19 +850,19 @@ class ElastigroupAzureV3ManagedServiceIdentity(dict):
851
850
  return super().get(key, default)
852
851
 
853
852
  def __init__(__self__, *,
854
- name: builtins.str,
855
- resource_group_name: builtins.str):
853
+ name: _builtins.str,
854
+ resource_group_name: _builtins.str):
856
855
  pulumi.set(__self__, "name", name)
857
856
  pulumi.set(__self__, "resource_group_name", resource_group_name)
858
857
 
859
- @property
858
+ @_builtins.property
860
859
  @pulumi.getter
861
- def name(self) -> builtins.str:
860
+ def name(self) -> _builtins.str:
862
861
  return pulumi.get(self, "name")
863
862
 
864
- @property
863
+ @_builtins.property
865
864
  @pulumi.getter(name="resourceGroupName")
866
- def resource_group_name(self) -> builtins.str:
865
+ def resource_group_name(self) -> _builtins.str:
867
866
  return pulumi.get(self, "resource_group_name")
868
867
 
869
868
 
@@ -892,25 +891,25 @@ class ElastigroupAzureV3Network(dict):
892
891
 
893
892
  def __init__(__self__, *,
894
893
  network_interfaces: Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterface'],
895
- resource_group_name: builtins.str,
896
- virtual_network_name: builtins.str):
894
+ resource_group_name: _builtins.str,
895
+ virtual_network_name: _builtins.str):
897
896
  pulumi.set(__self__, "network_interfaces", network_interfaces)
898
897
  pulumi.set(__self__, "resource_group_name", resource_group_name)
899
898
  pulumi.set(__self__, "virtual_network_name", virtual_network_name)
900
899
 
901
- @property
900
+ @_builtins.property
902
901
  @pulumi.getter(name="networkInterfaces")
903
902
  def network_interfaces(self) -> Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterface']:
904
903
  return pulumi.get(self, "network_interfaces")
905
904
 
906
- @property
905
+ @_builtins.property
907
906
  @pulumi.getter(name="resourceGroupName")
908
- def resource_group_name(self) -> builtins.str:
907
+ def resource_group_name(self) -> _builtins.str:
909
908
  return pulumi.get(self, "resource_group_name")
910
909
 
911
- @property
910
+ @_builtins.property
912
911
  @pulumi.getter(name="virtualNetworkName")
913
- def virtual_network_name(self) -> builtins.str:
912
+ def virtual_network_name(self) -> _builtins.str:
914
913
  return pulumi.get(self, "virtual_network_name")
915
914
 
916
915
 
@@ -950,14 +949,14 @@ class ElastigroupAzureV3NetworkNetworkInterface(dict):
950
949
  return super().get(key, default)
951
950
 
952
951
  def __init__(__self__, *,
953
- assign_public_ip: builtins.bool,
954
- is_primary: builtins.bool,
955
- subnet_name: builtins.str,
952
+ assign_public_ip: _builtins.bool,
953
+ is_primary: _builtins.bool,
954
+ subnet_name: _builtins.str,
956
955
  additional_ip_configs: Optional[Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterfaceAdditionalIpConfig']] = None,
957
956
  application_security_groups: Optional[Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterfaceApplicationSecurityGroup']] = None,
958
- enable_ip_forwarding: Optional[builtins.bool] = None,
959
- private_ip_addresses: Optional[Sequence[builtins.str]] = None,
960
- public_ip_sku: Optional[builtins.str] = None,
957
+ enable_ip_forwarding: Optional[_builtins.bool] = None,
958
+ private_ip_addresses: Optional[Sequence[_builtins.str]] = None,
959
+ public_ip_sku: Optional[_builtins.str] = None,
961
960
  security_groups: Optional[Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterfaceSecurityGroup']] = None):
962
961
  pulumi.set(__self__, "assign_public_ip", assign_public_ip)
963
962
  pulumi.set(__self__, "is_primary", is_primary)
@@ -975,47 +974,47 @@ class ElastigroupAzureV3NetworkNetworkInterface(dict):
975
974
  if security_groups is not None:
976
975
  pulumi.set(__self__, "security_groups", security_groups)
977
976
 
978
- @property
977
+ @_builtins.property
979
978
  @pulumi.getter(name="assignPublicIp")
980
- def assign_public_ip(self) -> builtins.bool:
979
+ def assign_public_ip(self) -> _builtins.bool:
981
980
  return pulumi.get(self, "assign_public_ip")
982
981
 
983
- @property
982
+ @_builtins.property
984
983
  @pulumi.getter(name="isPrimary")
985
- def is_primary(self) -> builtins.bool:
984
+ def is_primary(self) -> _builtins.bool:
986
985
  return pulumi.get(self, "is_primary")
987
986
 
988
- @property
987
+ @_builtins.property
989
988
  @pulumi.getter(name="subnetName")
990
- def subnet_name(self) -> builtins.str:
989
+ def subnet_name(self) -> _builtins.str:
991
990
  return pulumi.get(self, "subnet_name")
992
991
 
993
- @property
992
+ @_builtins.property
994
993
  @pulumi.getter(name="additionalIpConfigs")
995
994
  def additional_ip_configs(self) -> Optional[Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterfaceAdditionalIpConfig']]:
996
995
  return pulumi.get(self, "additional_ip_configs")
997
996
 
998
- @property
997
+ @_builtins.property
999
998
  @pulumi.getter(name="applicationSecurityGroups")
1000
999
  def application_security_groups(self) -> Optional[Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterfaceApplicationSecurityGroup']]:
1001
1000
  return pulumi.get(self, "application_security_groups")
1002
1001
 
1003
- @property
1002
+ @_builtins.property
1004
1003
  @pulumi.getter(name="enableIpForwarding")
1005
- def enable_ip_forwarding(self) -> Optional[builtins.bool]:
1004
+ def enable_ip_forwarding(self) -> Optional[_builtins.bool]:
1006
1005
  return pulumi.get(self, "enable_ip_forwarding")
1007
1006
 
1008
- @property
1007
+ @_builtins.property
1009
1008
  @pulumi.getter(name="privateIpAddresses")
1010
- def private_ip_addresses(self) -> Optional[Sequence[builtins.str]]:
1009
+ def private_ip_addresses(self) -> Optional[Sequence[_builtins.str]]:
1011
1010
  return pulumi.get(self, "private_ip_addresses")
1012
1011
 
1013
- @property
1012
+ @_builtins.property
1014
1013
  @pulumi.getter(name="publicIpSku")
1015
- def public_ip_sku(self) -> Optional[builtins.str]:
1014
+ def public_ip_sku(self) -> Optional[_builtins.str]:
1016
1015
  return pulumi.get(self, "public_ip_sku")
1017
1016
 
1018
- @property
1017
+ @_builtins.property
1019
1018
  @pulumi.getter(name="securityGroups")
1020
1019
  def security_groups(self) -> Optional[Sequence['outputs.ElastigroupAzureV3NetworkNetworkInterfaceSecurityGroup']]:
1021
1020
  return pulumi.get(self, "security_groups")
@@ -1041,20 +1040,20 @@ class ElastigroupAzureV3NetworkNetworkInterfaceAdditionalIpConfig(dict):
1041
1040
  return super().get(key, default)
1042
1041
 
1043
1042
  def __init__(__self__, *,
1044
- name: builtins.str,
1045
- private_ip_version: Optional[builtins.str] = None):
1043
+ name: _builtins.str,
1044
+ private_ip_version: Optional[_builtins.str] = None):
1046
1045
  pulumi.set(__self__, "name", name)
1047
1046
  if private_ip_version is not None:
1048
1047
  pulumi.set(__self__, "private_ip_version", private_ip_version)
1049
1048
 
1050
- @property
1049
+ @_builtins.property
1051
1050
  @pulumi.getter
1052
- def name(self) -> builtins.str:
1051
+ def name(self) -> _builtins.str:
1053
1052
  return pulumi.get(self, "name")
1054
1053
 
1055
- @property
1054
+ @_builtins.property
1056
1055
  @pulumi.getter(name="privateIpVersion")
1057
- def private_ip_version(self) -> Optional[builtins.str]:
1056
+ def private_ip_version(self) -> Optional[_builtins.str]:
1058
1057
  return pulumi.get(self, "private_ip_version")
1059
1058
 
1060
1059
 
@@ -1078,19 +1077,19 @@ class ElastigroupAzureV3NetworkNetworkInterfaceApplicationSecurityGroup(dict):
1078
1077
  return super().get(key, default)
1079
1078
 
1080
1079
  def __init__(__self__, *,
1081
- name: builtins.str,
1082
- resource_group_name: builtins.str):
1080
+ name: _builtins.str,
1081
+ resource_group_name: _builtins.str):
1083
1082
  pulumi.set(__self__, "name", name)
1084
1083
  pulumi.set(__self__, "resource_group_name", resource_group_name)
1085
1084
 
1086
- @property
1085
+ @_builtins.property
1087
1086
  @pulumi.getter
1088
- def name(self) -> builtins.str:
1087
+ def name(self) -> _builtins.str:
1089
1088
  return pulumi.get(self, "name")
1090
1089
 
1091
- @property
1090
+ @_builtins.property
1092
1091
  @pulumi.getter(name="resourceGroupName")
1093
- def resource_group_name(self) -> builtins.str:
1092
+ def resource_group_name(self) -> _builtins.str:
1094
1093
  return pulumi.get(self, "resource_group_name")
1095
1094
 
1096
1095
 
@@ -1114,21 +1113,21 @@ class ElastigroupAzureV3NetworkNetworkInterfaceSecurityGroup(dict):
1114
1113
  return super().get(key, default)
1115
1114
 
1116
1115
  def __init__(__self__, *,
1117
- name: Optional[builtins.str] = None,
1118
- resource_group_name: Optional[builtins.str] = None):
1116
+ name: Optional[_builtins.str] = None,
1117
+ resource_group_name: Optional[_builtins.str] = None):
1119
1118
  if name is not None:
1120
1119
  pulumi.set(__self__, "name", name)
1121
1120
  if resource_group_name is not None:
1122
1121
  pulumi.set(__self__, "resource_group_name", resource_group_name)
1123
1122
 
1124
- @property
1123
+ @_builtins.property
1125
1124
  @pulumi.getter
1126
- def name(self) -> Optional[builtins.str]:
1125
+ def name(self) -> Optional[_builtins.str]:
1127
1126
  return pulumi.get(self, "name")
1128
1127
 
1129
- @property
1128
+ @_builtins.property
1130
1129
  @pulumi.getter(name="resourceGroupName")
1131
- def resource_group_name(self) -> Optional[builtins.str]:
1130
+ def resource_group_name(self) -> Optional[_builtins.str]:
1132
1131
  return pulumi.get(self, "resource_group_name")
1133
1132
 
1134
1133
 
@@ -1152,20 +1151,20 @@ class ElastigroupAzureV3OsDisk(dict):
1152
1151
  return super().get(key, default)
1153
1152
 
1154
1153
  def __init__(__self__, *,
1155
- type: builtins.str,
1156
- size_gb: Optional[builtins.int] = None):
1154
+ type: _builtins.str,
1155
+ size_gb: Optional[_builtins.int] = None):
1157
1156
  pulumi.set(__self__, "type", type)
1158
1157
  if size_gb is not None:
1159
1158
  pulumi.set(__self__, "size_gb", size_gb)
1160
1159
 
1161
- @property
1160
+ @_builtins.property
1162
1161
  @pulumi.getter
1163
- def type(self) -> builtins.str:
1162
+ def type(self) -> _builtins.str:
1164
1163
  return pulumi.get(self, "type")
1165
1164
 
1166
- @property
1165
+ @_builtins.property
1167
1166
  @pulumi.getter(name="sizeGb")
1168
- def size_gb(self) -> Optional[builtins.int]:
1167
+ def size_gb(self) -> Optional[_builtins.int]:
1169
1168
  return pulumi.get(self, "size_gb")
1170
1169
 
1171
1170
 
@@ -1189,19 +1188,19 @@ class ElastigroupAzureV3ProximityPlacementGroup(dict):
1189
1188
  return super().get(key, default)
1190
1189
 
1191
1190
  def __init__(__self__, *,
1192
- name: builtins.str,
1193
- resource_group_name: builtins.str):
1191
+ name: _builtins.str,
1192
+ resource_group_name: _builtins.str):
1194
1193
  pulumi.set(__self__, "name", name)
1195
1194
  pulumi.set(__self__, "resource_group_name", resource_group_name)
1196
1195
 
1197
- @property
1196
+ @_builtins.property
1198
1197
  @pulumi.getter
1199
- def name(self) -> builtins.str:
1198
+ def name(self) -> _builtins.str:
1200
1199
  return pulumi.get(self, "name")
1201
1200
 
1202
- @property
1201
+ @_builtins.property
1203
1202
  @pulumi.getter(name="resourceGroupName")
1204
- def resource_group_name(self) -> builtins.str:
1203
+ def resource_group_name(self) -> _builtins.str:
1205
1204
  return pulumi.get(self, "resource_group_name")
1206
1205
 
1207
1206
 
@@ -1225,12 +1224,12 @@ class ElastigroupAzureV3RevertToSpot(dict):
1225
1224
  return super().get(key, default)
1226
1225
 
1227
1226
  def __init__(__self__, *,
1228
- perform_at: builtins.str):
1227
+ perform_at: _builtins.str):
1229
1228
  pulumi.set(__self__, "perform_at", perform_at)
1230
1229
 
1231
- @property
1230
+ @_builtins.property
1232
1231
  @pulumi.getter(name="performAt")
1233
- def perform_at(self) -> builtins.str:
1232
+ def perform_at(self) -> _builtins.str:
1234
1233
  return pulumi.get(self, "perform_at")
1235
1234
 
1236
1235
 
@@ -1261,19 +1260,19 @@ class ElastigroupAzureV3ScalingDownPolicy(dict):
1261
1260
 
1262
1261
  def __init__(__self__, *,
1263
1262
  action: 'outputs.ElastigroupAzureV3ScalingDownPolicyAction',
1264
- cooldown: builtins.int,
1265
- evaluation_periods: builtins.int,
1266
- metric_name: builtins.str,
1267
- namespace: builtins.str,
1268
- operator: builtins.str,
1269
- period: builtins.int,
1270
- policy_name: builtins.str,
1271
- statistic: builtins.str,
1272
- threshold: builtins.float,
1263
+ cooldown: _builtins.int,
1264
+ evaluation_periods: _builtins.int,
1265
+ metric_name: _builtins.str,
1266
+ namespace: _builtins.str,
1267
+ operator: _builtins.str,
1268
+ period: _builtins.int,
1269
+ policy_name: _builtins.str,
1270
+ statistic: _builtins.str,
1271
+ threshold: _builtins.float,
1273
1272
  dimensions: Optional[Sequence['outputs.ElastigroupAzureV3ScalingDownPolicyDimension']] = None,
1274
- is_enabled: Optional[builtins.bool] = None,
1275
- source: Optional[builtins.str] = None,
1276
- unit: Optional[builtins.str] = None):
1273
+ is_enabled: Optional[_builtins.bool] = None,
1274
+ source: Optional[_builtins.str] = None,
1275
+ unit: Optional[_builtins.str] = None):
1277
1276
  pulumi.set(__self__, "action", action)
1278
1277
  pulumi.set(__self__, "cooldown", cooldown)
1279
1278
  pulumi.set(__self__, "evaluation_periods", evaluation_periods)
@@ -1293,85 +1292,85 @@ class ElastigroupAzureV3ScalingDownPolicy(dict):
1293
1292
  if unit is not None:
1294
1293
  pulumi.set(__self__, "unit", unit)
1295
1294
 
1296
- @property
1295
+ @_builtins.property
1297
1296
  @pulumi.getter
1298
1297
  def action(self) -> 'outputs.ElastigroupAzureV3ScalingDownPolicyAction':
1299
1298
  return pulumi.get(self, "action")
1300
1299
 
1301
- @property
1300
+ @_builtins.property
1302
1301
  @pulumi.getter
1303
- def cooldown(self) -> builtins.int:
1302
+ def cooldown(self) -> _builtins.int:
1304
1303
  return pulumi.get(self, "cooldown")
1305
1304
 
1306
- @property
1305
+ @_builtins.property
1307
1306
  @pulumi.getter(name="evaluationPeriods")
1308
- def evaluation_periods(self) -> builtins.int:
1307
+ def evaluation_periods(self) -> _builtins.int:
1309
1308
  return pulumi.get(self, "evaluation_periods")
1310
1309
 
1311
- @property
1310
+ @_builtins.property
1312
1311
  @pulumi.getter(name="metricName")
1313
- def metric_name(self) -> builtins.str:
1312
+ def metric_name(self) -> _builtins.str:
1314
1313
  return pulumi.get(self, "metric_name")
1315
1314
 
1316
- @property
1315
+ @_builtins.property
1317
1316
  @pulumi.getter
1318
- def namespace(self) -> builtins.str:
1317
+ def namespace(self) -> _builtins.str:
1319
1318
  return pulumi.get(self, "namespace")
1320
1319
 
1321
- @property
1320
+ @_builtins.property
1322
1321
  @pulumi.getter
1323
- def operator(self) -> builtins.str:
1322
+ def operator(self) -> _builtins.str:
1324
1323
  return pulumi.get(self, "operator")
1325
1324
 
1326
- @property
1325
+ @_builtins.property
1327
1326
  @pulumi.getter
1328
- def period(self) -> builtins.int:
1327
+ def period(self) -> _builtins.int:
1329
1328
  return pulumi.get(self, "period")
1330
1329
 
1331
- @property
1330
+ @_builtins.property
1332
1331
  @pulumi.getter(name="policyName")
1333
- def policy_name(self) -> builtins.str:
1332
+ def policy_name(self) -> _builtins.str:
1334
1333
  return pulumi.get(self, "policy_name")
1335
1334
 
1336
- @property
1335
+ @_builtins.property
1337
1336
  @pulumi.getter
1338
- def statistic(self) -> builtins.str:
1337
+ def statistic(self) -> _builtins.str:
1339
1338
  return pulumi.get(self, "statistic")
1340
1339
 
1341
- @property
1340
+ @_builtins.property
1342
1341
  @pulumi.getter
1343
- def threshold(self) -> builtins.float:
1342
+ def threshold(self) -> _builtins.float:
1344
1343
  return pulumi.get(self, "threshold")
1345
1344
 
1346
- @property
1345
+ @_builtins.property
1347
1346
  @pulumi.getter
1348
1347
  def dimensions(self) -> Optional[Sequence['outputs.ElastigroupAzureV3ScalingDownPolicyDimension']]:
1349
1348
  return pulumi.get(self, "dimensions")
1350
1349
 
1351
- @property
1350
+ @_builtins.property
1352
1351
  @pulumi.getter(name="isEnabled")
1353
- def is_enabled(self) -> Optional[builtins.bool]:
1352
+ def is_enabled(self) -> Optional[_builtins.bool]:
1354
1353
  return pulumi.get(self, "is_enabled")
1355
1354
 
1356
- @property
1355
+ @_builtins.property
1357
1356
  @pulumi.getter
1358
- def source(self) -> Optional[builtins.str]:
1357
+ def source(self) -> Optional[_builtins.str]:
1359
1358
  return pulumi.get(self, "source")
1360
1359
 
1361
- @property
1360
+ @_builtins.property
1362
1361
  @pulumi.getter
1363
- def unit(self) -> Optional[builtins.str]:
1362
+ def unit(self) -> Optional[_builtins.str]:
1364
1363
  return pulumi.get(self, "unit")
1365
1364
 
1366
1365
 
1367
1366
  @pulumi.output_type
1368
1367
  class ElastigroupAzureV3ScalingDownPolicyAction(dict):
1369
1368
  def __init__(__self__, *,
1370
- adjustment: Optional[builtins.str] = None,
1371
- maximum: Optional[builtins.str] = None,
1372
- minimum: Optional[builtins.str] = None,
1373
- target: Optional[builtins.str] = None,
1374
- type: Optional[builtins.str] = None):
1369
+ adjustment: Optional[_builtins.str] = None,
1370
+ maximum: Optional[_builtins.str] = None,
1371
+ minimum: Optional[_builtins.str] = None,
1372
+ target: Optional[_builtins.str] = None,
1373
+ type: Optional[_builtins.str] = None):
1375
1374
  if adjustment is not None:
1376
1375
  pulumi.set(__self__, "adjustment", adjustment)
1377
1376
  if maximum is not None:
@@ -1383,50 +1382,50 @@ class ElastigroupAzureV3ScalingDownPolicyAction(dict):
1383
1382
  if type is not None:
1384
1383
  pulumi.set(__self__, "type", type)
1385
1384
 
1386
- @property
1385
+ @_builtins.property
1387
1386
  @pulumi.getter
1388
- def adjustment(self) -> Optional[builtins.str]:
1387
+ def adjustment(self) -> Optional[_builtins.str]:
1389
1388
  return pulumi.get(self, "adjustment")
1390
1389
 
1391
- @property
1390
+ @_builtins.property
1392
1391
  @pulumi.getter
1393
- def maximum(self) -> Optional[builtins.str]:
1392
+ def maximum(self) -> Optional[_builtins.str]:
1394
1393
  return pulumi.get(self, "maximum")
1395
1394
 
1396
- @property
1395
+ @_builtins.property
1397
1396
  @pulumi.getter
1398
- def minimum(self) -> Optional[builtins.str]:
1397
+ def minimum(self) -> Optional[_builtins.str]:
1399
1398
  return pulumi.get(self, "minimum")
1400
1399
 
1401
- @property
1400
+ @_builtins.property
1402
1401
  @pulumi.getter
1403
- def target(self) -> Optional[builtins.str]:
1402
+ def target(self) -> Optional[_builtins.str]:
1404
1403
  return pulumi.get(self, "target")
1405
1404
 
1406
- @property
1405
+ @_builtins.property
1407
1406
  @pulumi.getter
1408
- def type(self) -> Optional[builtins.str]:
1407
+ def type(self) -> Optional[_builtins.str]:
1409
1408
  return pulumi.get(self, "type")
1410
1409
 
1411
1410
 
1412
1411
  @pulumi.output_type
1413
1412
  class ElastigroupAzureV3ScalingDownPolicyDimension(dict):
1414
1413
  def __init__(__self__, *,
1415
- name: Optional[builtins.str] = None,
1416
- value: Optional[builtins.str] = None):
1414
+ name: Optional[_builtins.str] = None,
1415
+ value: Optional[_builtins.str] = None):
1417
1416
  if name is not None:
1418
1417
  pulumi.set(__self__, "name", name)
1419
1418
  if value is not None:
1420
1419
  pulumi.set(__self__, "value", value)
1421
1420
 
1422
- @property
1421
+ @_builtins.property
1423
1422
  @pulumi.getter
1424
- def name(self) -> Optional[builtins.str]:
1423
+ def name(self) -> Optional[_builtins.str]:
1425
1424
  return pulumi.get(self, "name")
1426
1425
 
1427
- @property
1426
+ @_builtins.property
1428
1427
  @pulumi.getter
1429
- def value(self) -> Optional[builtins.str]:
1428
+ def value(self) -> Optional[_builtins.str]:
1430
1429
  return pulumi.get(self, "value")
1431
1430
 
1432
1431
 
@@ -1457,19 +1456,19 @@ class ElastigroupAzureV3ScalingUpPolicy(dict):
1457
1456
 
1458
1457
  def __init__(__self__, *,
1459
1458
  action: 'outputs.ElastigroupAzureV3ScalingUpPolicyAction',
1460
- cooldown: builtins.int,
1461
- evaluation_periods: builtins.int,
1462
- metric_name: builtins.str,
1463
- namespace: builtins.str,
1464
- operator: builtins.str,
1465
- period: builtins.int,
1466
- policy_name: builtins.str,
1467
- statistic: builtins.str,
1468
- threshold: builtins.float,
1459
+ cooldown: _builtins.int,
1460
+ evaluation_periods: _builtins.int,
1461
+ metric_name: _builtins.str,
1462
+ namespace: _builtins.str,
1463
+ operator: _builtins.str,
1464
+ period: _builtins.int,
1465
+ policy_name: _builtins.str,
1466
+ statistic: _builtins.str,
1467
+ threshold: _builtins.float,
1469
1468
  dimensions: Optional[Sequence['outputs.ElastigroupAzureV3ScalingUpPolicyDimension']] = None,
1470
- is_enabled: Optional[builtins.bool] = None,
1471
- source: Optional[builtins.str] = None,
1472
- unit: Optional[builtins.str] = None):
1469
+ is_enabled: Optional[_builtins.bool] = None,
1470
+ source: Optional[_builtins.str] = None,
1471
+ unit: Optional[_builtins.str] = None):
1473
1472
  pulumi.set(__self__, "action", action)
1474
1473
  pulumi.set(__self__, "cooldown", cooldown)
1475
1474
  pulumi.set(__self__, "evaluation_periods", evaluation_periods)
@@ -1489,85 +1488,85 @@ class ElastigroupAzureV3ScalingUpPolicy(dict):
1489
1488
  if unit is not None:
1490
1489
  pulumi.set(__self__, "unit", unit)
1491
1490
 
1492
- @property
1491
+ @_builtins.property
1493
1492
  @pulumi.getter
1494
1493
  def action(self) -> 'outputs.ElastigroupAzureV3ScalingUpPolicyAction':
1495
1494
  return pulumi.get(self, "action")
1496
1495
 
1497
- @property
1496
+ @_builtins.property
1498
1497
  @pulumi.getter
1499
- def cooldown(self) -> builtins.int:
1498
+ def cooldown(self) -> _builtins.int:
1500
1499
  return pulumi.get(self, "cooldown")
1501
1500
 
1502
- @property
1501
+ @_builtins.property
1503
1502
  @pulumi.getter(name="evaluationPeriods")
1504
- def evaluation_periods(self) -> builtins.int:
1503
+ def evaluation_periods(self) -> _builtins.int:
1505
1504
  return pulumi.get(self, "evaluation_periods")
1506
1505
 
1507
- @property
1506
+ @_builtins.property
1508
1507
  @pulumi.getter(name="metricName")
1509
- def metric_name(self) -> builtins.str:
1508
+ def metric_name(self) -> _builtins.str:
1510
1509
  return pulumi.get(self, "metric_name")
1511
1510
 
1512
- @property
1511
+ @_builtins.property
1513
1512
  @pulumi.getter
1514
- def namespace(self) -> builtins.str:
1513
+ def namespace(self) -> _builtins.str:
1515
1514
  return pulumi.get(self, "namespace")
1516
1515
 
1517
- @property
1516
+ @_builtins.property
1518
1517
  @pulumi.getter
1519
- def operator(self) -> builtins.str:
1518
+ def operator(self) -> _builtins.str:
1520
1519
  return pulumi.get(self, "operator")
1521
1520
 
1522
- @property
1521
+ @_builtins.property
1523
1522
  @pulumi.getter
1524
- def period(self) -> builtins.int:
1523
+ def period(self) -> _builtins.int:
1525
1524
  return pulumi.get(self, "period")
1526
1525
 
1527
- @property
1526
+ @_builtins.property
1528
1527
  @pulumi.getter(name="policyName")
1529
- def policy_name(self) -> builtins.str:
1528
+ def policy_name(self) -> _builtins.str:
1530
1529
  return pulumi.get(self, "policy_name")
1531
1530
 
1532
- @property
1531
+ @_builtins.property
1533
1532
  @pulumi.getter
1534
- def statistic(self) -> builtins.str:
1533
+ def statistic(self) -> _builtins.str:
1535
1534
  return pulumi.get(self, "statistic")
1536
1535
 
1537
- @property
1536
+ @_builtins.property
1538
1537
  @pulumi.getter
1539
- def threshold(self) -> builtins.float:
1538
+ def threshold(self) -> _builtins.float:
1540
1539
  return pulumi.get(self, "threshold")
1541
1540
 
1542
- @property
1541
+ @_builtins.property
1543
1542
  @pulumi.getter
1544
1543
  def dimensions(self) -> Optional[Sequence['outputs.ElastigroupAzureV3ScalingUpPolicyDimension']]:
1545
1544
  return pulumi.get(self, "dimensions")
1546
1545
 
1547
- @property
1546
+ @_builtins.property
1548
1547
  @pulumi.getter(name="isEnabled")
1549
- def is_enabled(self) -> Optional[builtins.bool]:
1548
+ def is_enabled(self) -> Optional[_builtins.bool]:
1550
1549
  return pulumi.get(self, "is_enabled")
1551
1550
 
1552
- @property
1551
+ @_builtins.property
1553
1552
  @pulumi.getter
1554
- def source(self) -> Optional[builtins.str]:
1553
+ def source(self) -> Optional[_builtins.str]:
1555
1554
  return pulumi.get(self, "source")
1556
1555
 
1557
- @property
1556
+ @_builtins.property
1558
1557
  @pulumi.getter
1559
- def unit(self) -> Optional[builtins.str]:
1558
+ def unit(self) -> Optional[_builtins.str]:
1560
1559
  return pulumi.get(self, "unit")
1561
1560
 
1562
1561
 
1563
1562
  @pulumi.output_type
1564
1563
  class ElastigroupAzureV3ScalingUpPolicyAction(dict):
1565
1564
  def __init__(__self__, *,
1566
- adjustment: Optional[builtins.str] = None,
1567
- maximum: Optional[builtins.str] = None,
1568
- minimum: Optional[builtins.str] = None,
1569
- target: Optional[builtins.str] = None,
1570
- type: Optional[builtins.str] = None):
1565
+ adjustment: Optional[_builtins.str] = None,
1566
+ maximum: Optional[_builtins.str] = None,
1567
+ minimum: Optional[_builtins.str] = None,
1568
+ target: Optional[_builtins.str] = None,
1569
+ type: Optional[_builtins.str] = None):
1571
1570
  if adjustment is not None:
1572
1571
  pulumi.set(__self__, "adjustment", adjustment)
1573
1572
  if maximum is not None:
@@ -1579,50 +1578,50 @@ class ElastigroupAzureV3ScalingUpPolicyAction(dict):
1579
1578
  if type is not None:
1580
1579
  pulumi.set(__self__, "type", type)
1581
1580
 
1582
- @property
1581
+ @_builtins.property
1583
1582
  @pulumi.getter
1584
- def adjustment(self) -> Optional[builtins.str]:
1583
+ def adjustment(self) -> Optional[_builtins.str]:
1585
1584
  return pulumi.get(self, "adjustment")
1586
1585
 
1587
- @property
1586
+ @_builtins.property
1588
1587
  @pulumi.getter
1589
- def maximum(self) -> Optional[builtins.str]:
1588
+ def maximum(self) -> Optional[_builtins.str]:
1590
1589
  return pulumi.get(self, "maximum")
1591
1590
 
1592
- @property
1591
+ @_builtins.property
1593
1592
  @pulumi.getter
1594
- def minimum(self) -> Optional[builtins.str]:
1593
+ def minimum(self) -> Optional[_builtins.str]:
1595
1594
  return pulumi.get(self, "minimum")
1596
1595
 
1597
- @property
1596
+ @_builtins.property
1598
1597
  @pulumi.getter
1599
- def target(self) -> Optional[builtins.str]:
1598
+ def target(self) -> Optional[_builtins.str]:
1600
1599
  return pulumi.get(self, "target")
1601
1600
 
1602
- @property
1601
+ @_builtins.property
1603
1602
  @pulumi.getter
1604
- def type(self) -> Optional[builtins.str]:
1603
+ def type(self) -> Optional[_builtins.str]:
1605
1604
  return pulumi.get(self, "type")
1606
1605
 
1607
1606
 
1608
1607
  @pulumi.output_type
1609
1608
  class ElastigroupAzureV3ScalingUpPolicyDimension(dict):
1610
1609
  def __init__(__self__, *,
1611
- name: Optional[builtins.str] = None,
1612
- value: Optional[builtins.str] = None):
1610
+ name: Optional[_builtins.str] = None,
1611
+ value: Optional[_builtins.str] = None):
1613
1612
  if name is not None:
1614
1613
  pulumi.set(__self__, "name", name)
1615
1614
  if value is not None:
1616
1615
  pulumi.set(__self__, "value", value)
1617
1616
 
1618
- @property
1617
+ @_builtins.property
1619
1618
  @pulumi.getter
1620
- def name(self) -> Optional[builtins.str]:
1619
+ def name(self) -> Optional[_builtins.str]:
1621
1620
  return pulumi.get(self, "name")
1622
1621
 
1623
- @property
1622
+ @_builtins.property
1624
1623
  @pulumi.getter
1625
- def value(self) -> Optional[builtins.str]:
1624
+ def value(self) -> Optional[_builtins.str]:
1626
1625
  return pulumi.get(self, "value")
1627
1626
 
1628
1627
 
@@ -1660,16 +1659,16 @@ class ElastigroupAzureV3SchedulingTask(dict):
1660
1659
  return super().get(key, default)
1661
1660
 
1662
1661
  def __init__(__self__, *,
1663
- cron_expression: builtins.str,
1664
- is_enabled: builtins.bool,
1665
- type: builtins.str,
1666
- adjustment: Optional[builtins.str] = None,
1667
- adjustment_percentage: Optional[builtins.str] = None,
1668
- batch_size_percentage: Optional[builtins.str] = None,
1669
- grace_period: Optional[builtins.str] = None,
1670
- scale_max_capacity: Optional[builtins.str] = None,
1671
- scale_min_capacity: Optional[builtins.str] = None,
1672
- scale_target_capacity: Optional[builtins.str] = None):
1662
+ cron_expression: _builtins.str,
1663
+ is_enabled: _builtins.bool,
1664
+ type: _builtins.str,
1665
+ adjustment: Optional[_builtins.str] = None,
1666
+ adjustment_percentage: Optional[_builtins.str] = None,
1667
+ batch_size_percentage: Optional[_builtins.str] = None,
1668
+ grace_period: Optional[_builtins.str] = None,
1669
+ scale_max_capacity: Optional[_builtins.str] = None,
1670
+ scale_min_capacity: Optional[_builtins.str] = None,
1671
+ scale_target_capacity: Optional[_builtins.str] = None):
1673
1672
  pulumi.set(__self__, "cron_expression", cron_expression)
1674
1673
  pulumi.set(__self__, "is_enabled", is_enabled)
1675
1674
  pulumi.set(__self__, "type", type)
@@ -1688,54 +1687,54 @@ class ElastigroupAzureV3SchedulingTask(dict):
1688
1687
  if scale_target_capacity is not None:
1689
1688
  pulumi.set(__self__, "scale_target_capacity", scale_target_capacity)
1690
1689
 
1691
- @property
1690
+ @_builtins.property
1692
1691
  @pulumi.getter(name="cronExpression")
1693
- def cron_expression(self) -> builtins.str:
1692
+ def cron_expression(self) -> _builtins.str:
1694
1693
  return pulumi.get(self, "cron_expression")
1695
1694
 
1696
- @property
1695
+ @_builtins.property
1697
1696
  @pulumi.getter(name="isEnabled")
1698
- def is_enabled(self) -> builtins.bool:
1697
+ def is_enabled(self) -> _builtins.bool:
1699
1698
  return pulumi.get(self, "is_enabled")
1700
1699
 
1701
- @property
1700
+ @_builtins.property
1702
1701
  @pulumi.getter
1703
- def type(self) -> builtins.str:
1702
+ def type(self) -> _builtins.str:
1704
1703
  return pulumi.get(self, "type")
1705
1704
 
1706
- @property
1705
+ @_builtins.property
1707
1706
  @pulumi.getter
1708
- def adjustment(self) -> Optional[builtins.str]:
1707
+ def adjustment(self) -> Optional[_builtins.str]:
1709
1708
  return pulumi.get(self, "adjustment")
1710
1709
 
1711
- @property
1710
+ @_builtins.property
1712
1711
  @pulumi.getter(name="adjustmentPercentage")
1713
- def adjustment_percentage(self) -> Optional[builtins.str]:
1712
+ def adjustment_percentage(self) -> Optional[_builtins.str]:
1714
1713
  return pulumi.get(self, "adjustment_percentage")
1715
1714
 
1716
- @property
1715
+ @_builtins.property
1717
1716
  @pulumi.getter(name="batchSizePercentage")
1718
- def batch_size_percentage(self) -> Optional[builtins.str]:
1717
+ def batch_size_percentage(self) -> Optional[_builtins.str]:
1719
1718
  return pulumi.get(self, "batch_size_percentage")
1720
1719
 
1721
- @property
1720
+ @_builtins.property
1722
1721
  @pulumi.getter(name="gracePeriod")
1723
- def grace_period(self) -> Optional[builtins.str]:
1722
+ def grace_period(self) -> Optional[_builtins.str]:
1724
1723
  return pulumi.get(self, "grace_period")
1725
1724
 
1726
- @property
1725
+ @_builtins.property
1727
1726
  @pulumi.getter(name="scaleMaxCapacity")
1728
- def scale_max_capacity(self) -> Optional[builtins.str]:
1727
+ def scale_max_capacity(self) -> Optional[_builtins.str]:
1729
1728
  return pulumi.get(self, "scale_max_capacity")
1730
1729
 
1731
- @property
1730
+ @_builtins.property
1732
1731
  @pulumi.getter(name="scaleMinCapacity")
1733
- def scale_min_capacity(self) -> Optional[builtins.str]:
1732
+ def scale_min_capacity(self) -> Optional[_builtins.str]:
1734
1733
  return pulumi.get(self, "scale_min_capacity")
1735
1734
 
1736
- @property
1735
+ @_builtins.property
1737
1736
  @pulumi.getter(name="scaleTargetCapacity")
1738
- def scale_target_capacity(self) -> Optional[builtins.str]:
1737
+ def scale_target_capacity(self) -> Optional[_builtins.str]:
1739
1738
  return pulumi.get(self, "scale_target_capacity")
1740
1739
 
1741
1740
 
@@ -1766,12 +1765,12 @@ class ElastigroupAzureV3Secret(dict):
1766
1765
  pulumi.set(__self__, "source_vaults", source_vaults)
1767
1766
  pulumi.set(__self__, "vault_certificates", vault_certificates)
1768
1767
 
1769
- @property
1768
+ @_builtins.property
1770
1769
  @pulumi.getter(name="sourceVaults")
1771
1770
  def source_vaults(self) -> Sequence['outputs.ElastigroupAzureV3SecretSourceVault']:
1772
1771
  return pulumi.get(self, "source_vaults")
1773
1772
 
1774
- @property
1773
+ @_builtins.property
1775
1774
  @pulumi.getter(name="vaultCertificates")
1776
1775
  def vault_certificates(self) -> Sequence['outputs.ElastigroupAzureV3SecretVaultCertificate']:
1777
1776
  return pulumi.get(self, "vault_certificates")
@@ -1797,19 +1796,19 @@ class ElastigroupAzureV3SecretSourceVault(dict):
1797
1796
  return super().get(key, default)
1798
1797
 
1799
1798
  def __init__(__self__, *,
1800
- name: builtins.str,
1801
- resource_group_name: builtins.str):
1799
+ name: _builtins.str,
1800
+ resource_group_name: _builtins.str):
1802
1801
  pulumi.set(__self__, "name", name)
1803
1802
  pulumi.set(__self__, "resource_group_name", resource_group_name)
1804
1803
 
1805
- @property
1804
+ @_builtins.property
1806
1805
  @pulumi.getter
1807
- def name(self) -> builtins.str:
1806
+ def name(self) -> _builtins.str:
1808
1807
  return pulumi.get(self, "name")
1809
1808
 
1810
- @property
1809
+ @_builtins.property
1811
1810
  @pulumi.getter(name="resourceGroupName")
1812
- def resource_group_name(self) -> builtins.str:
1811
+ def resource_group_name(self) -> _builtins.str:
1813
1812
  return pulumi.get(self, "resource_group_name")
1814
1813
 
1815
1814
 
@@ -1835,19 +1834,19 @@ class ElastigroupAzureV3SecretVaultCertificate(dict):
1835
1834
  return super().get(key, default)
1836
1835
 
1837
1836
  def __init__(__self__, *,
1838
- certificate_store: builtins.str,
1839
- certificate_url: builtins.str):
1837
+ certificate_store: _builtins.str,
1838
+ certificate_url: _builtins.str):
1840
1839
  pulumi.set(__self__, "certificate_store", certificate_store)
1841
1840
  pulumi.set(__self__, "certificate_url", certificate_url)
1842
1841
 
1843
- @property
1842
+ @_builtins.property
1844
1843
  @pulumi.getter(name="certificateStore")
1845
- def certificate_store(self) -> builtins.str:
1844
+ def certificate_store(self) -> _builtins.str:
1846
1845
  return pulumi.get(self, "certificate_store")
1847
1846
 
1848
- @property
1847
+ @_builtins.property
1849
1848
  @pulumi.getter(name="certificateUrl")
1850
- def certificate_url(self) -> builtins.str:
1849
+ def certificate_url(self) -> _builtins.str:
1851
1850
  return pulumi.get(self, "certificate_url")
1852
1851
 
1853
1852
 
@@ -1879,11 +1878,11 @@ class ElastigroupAzureV3Security(dict):
1879
1878
  return super().get(key, default)
1880
1879
 
1881
1880
  def __init__(__self__, *,
1882
- confidential_os_disk_encryption: Optional[builtins.bool] = None,
1883
- encryption_at_host: Optional[builtins.bool] = None,
1884
- secure_boot_enabled: Optional[builtins.bool] = None,
1885
- security_type: Optional[builtins.str] = None,
1886
- vtpm_enabled: Optional[builtins.bool] = None):
1881
+ confidential_os_disk_encryption: Optional[_builtins.bool] = None,
1882
+ encryption_at_host: Optional[_builtins.bool] = None,
1883
+ secure_boot_enabled: Optional[_builtins.bool] = None,
1884
+ security_type: Optional[_builtins.str] = None,
1885
+ vtpm_enabled: Optional[_builtins.bool] = None):
1887
1886
  if confidential_os_disk_encryption is not None:
1888
1887
  pulumi.set(__self__, "confidential_os_disk_encryption", confidential_os_disk_encryption)
1889
1888
  if encryption_at_host is not None:
@@ -1895,67 +1894,67 @@ class ElastigroupAzureV3Security(dict):
1895
1894
  if vtpm_enabled is not None:
1896
1895
  pulumi.set(__self__, "vtpm_enabled", vtpm_enabled)
1897
1896
 
1898
- @property
1897
+ @_builtins.property
1899
1898
  @pulumi.getter(name="confidentialOsDiskEncryption")
1900
- def confidential_os_disk_encryption(self) -> Optional[builtins.bool]:
1899
+ def confidential_os_disk_encryption(self) -> Optional[_builtins.bool]:
1901
1900
  return pulumi.get(self, "confidential_os_disk_encryption")
1902
1901
 
1903
- @property
1902
+ @_builtins.property
1904
1903
  @pulumi.getter(name="encryptionAtHost")
1905
- def encryption_at_host(self) -> Optional[builtins.bool]:
1904
+ def encryption_at_host(self) -> Optional[_builtins.bool]:
1906
1905
  return pulumi.get(self, "encryption_at_host")
1907
1906
 
1908
- @property
1907
+ @_builtins.property
1909
1908
  @pulumi.getter(name="secureBootEnabled")
1910
- def secure_boot_enabled(self) -> Optional[builtins.bool]:
1909
+ def secure_boot_enabled(self) -> Optional[_builtins.bool]:
1911
1910
  return pulumi.get(self, "secure_boot_enabled")
1912
1911
 
1913
- @property
1912
+ @_builtins.property
1914
1913
  @pulumi.getter(name="securityType")
1915
- def security_type(self) -> Optional[builtins.str]:
1914
+ def security_type(self) -> Optional[_builtins.str]:
1916
1915
  return pulumi.get(self, "security_type")
1917
1916
 
1918
- @property
1917
+ @_builtins.property
1919
1918
  @pulumi.getter(name="vtpmEnabled")
1920
- def vtpm_enabled(self) -> Optional[builtins.bool]:
1919
+ def vtpm_enabled(self) -> Optional[_builtins.bool]:
1921
1920
  return pulumi.get(self, "vtpm_enabled")
1922
1921
 
1923
1922
 
1924
1923
  @pulumi.output_type
1925
1924
  class ElastigroupAzureV3Signal(dict):
1926
1925
  def __init__(__self__, *,
1927
- timeout: builtins.int,
1928
- type: builtins.str):
1926
+ timeout: _builtins.int,
1927
+ type: _builtins.str):
1929
1928
  pulumi.set(__self__, "timeout", timeout)
1930
1929
  pulumi.set(__self__, "type", type)
1931
1930
 
1932
- @property
1931
+ @_builtins.property
1933
1932
  @pulumi.getter
1934
- def timeout(self) -> builtins.int:
1933
+ def timeout(self) -> _builtins.int:
1935
1934
  return pulumi.get(self, "timeout")
1936
1935
 
1937
- @property
1936
+ @_builtins.property
1938
1937
  @pulumi.getter
1939
- def type(self) -> builtins.str:
1938
+ def type(self) -> _builtins.str:
1940
1939
  return pulumi.get(self, "type")
1941
1940
 
1942
1941
 
1943
1942
  @pulumi.output_type
1944
1943
  class ElastigroupAzureV3Tag(dict):
1945
1944
  def __init__(__self__, *,
1946
- key: builtins.str,
1947
- value: builtins.str):
1945
+ key: _builtins.str,
1946
+ value: _builtins.str):
1948
1947
  pulumi.set(__self__, "key", key)
1949
1948
  pulumi.set(__self__, "value", value)
1950
1949
 
1951
- @property
1950
+ @_builtins.property
1952
1951
  @pulumi.getter
1953
- def key(self) -> builtins.str:
1952
+ def key(self) -> _builtins.str:
1954
1953
  return pulumi.get(self, "key")
1955
1954
 
1956
- @property
1955
+ @_builtins.property
1957
1956
  @pulumi.getter
1958
- def value(self) -> builtins.str:
1957
+ def value(self) -> _builtins.str:
1959
1958
  return pulumi.get(self, "value")
1960
1959
 
1961
1960
 
@@ -1987,11 +1986,11 @@ class ElastigroupAzureV3VmSizes(dict):
1987
1986
  return super().get(key, default)
1988
1987
 
1989
1988
  def __init__(__self__, *,
1990
- od_sizes: Sequence[builtins.str],
1991
- excluded_vm_sizes: Optional[Sequence[builtins.str]] = None,
1992
- preferred_spot_sizes: Optional[Sequence[builtins.str]] = None,
1989
+ od_sizes: Sequence[_builtins.str],
1990
+ excluded_vm_sizes: Optional[Sequence[_builtins.str]] = None,
1991
+ preferred_spot_sizes: Optional[Sequence[_builtins.str]] = None,
1993
1992
  spot_size_attributes: Optional['outputs.ElastigroupAzureV3VmSizesSpotSizeAttributes'] = None,
1994
- spot_sizes: Optional[Sequence[builtins.str]] = None):
1993
+ spot_sizes: Optional[Sequence[_builtins.str]] = None):
1995
1994
  pulumi.set(__self__, "od_sizes", od_sizes)
1996
1995
  if excluded_vm_sizes is not None:
1997
1996
  pulumi.set(__self__, "excluded_vm_sizes", excluded_vm_sizes)
@@ -2002,29 +2001,29 @@ class ElastigroupAzureV3VmSizes(dict):
2002
2001
  if spot_sizes is not None:
2003
2002
  pulumi.set(__self__, "spot_sizes", spot_sizes)
2004
2003
 
2005
- @property
2004
+ @_builtins.property
2006
2005
  @pulumi.getter(name="odSizes")
2007
- def od_sizes(self) -> Sequence[builtins.str]:
2006
+ def od_sizes(self) -> Sequence[_builtins.str]:
2008
2007
  return pulumi.get(self, "od_sizes")
2009
2008
 
2010
- @property
2009
+ @_builtins.property
2011
2010
  @pulumi.getter(name="excludedVmSizes")
2012
- def excluded_vm_sizes(self) -> Optional[Sequence[builtins.str]]:
2011
+ def excluded_vm_sizes(self) -> Optional[Sequence[_builtins.str]]:
2013
2012
  return pulumi.get(self, "excluded_vm_sizes")
2014
2013
 
2015
- @property
2014
+ @_builtins.property
2016
2015
  @pulumi.getter(name="preferredSpotSizes")
2017
- def preferred_spot_sizes(self) -> Optional[Sequence[builtins.str]]:
2016
+ def preferred_spot_sizes(self) -> Optional[Sequence[_builtins.str]]:
2018
2017
  return pulumi.get(self, "preferred_spot_sizes")
2019
2018
 
2020
- @property
2019
+ @_builtins.property
2021
2020
  @pulumi.getter(name="spotSizeAttributes")
2022
2021
  def spot_size_attributes(self) -> Optional['outputs.ElastigroupAzureV3VmSizesSpotSizeAttributes']:
2023
2022
  return pulumi.get(self, "spot_size_attributes")
2024
2023
 
2025
- @property
2024
+ @_builtins.property
2026
2025
  @pulumi.getter(name="spotSizes")
2027
- def spot_sizes(self) -> Optional[Sequence[builtins.str]]:
2026
+ def spot_sizes(self) -> Optional[Sequence[_builtins.str]]:
2028
2027
  return pulumi.get(self, "spot_sizes")
2029
2028
 
2030
2029
 
@@ -2058,12 +2057,12 @@ class ElastigroupAzureV3VmSizesSpotSizeAttributes(dict):
2058
2057
  return super().get(key, default)
2059
2058
 
2060
2059
  def __init__(__self__, *,
2061
- max_cpu: Optional[builtins.int] = None,
2062
- max_memory: Optional[builtins.int] = None,
2063
- max_storage: Optional[builtins.int] = None,
2064
- min_cpu: Optional[builtins.int] = None,
2065
- min_memory: Optional[builtins.int] = None,
2066
- min_storage: Optional[builtins.int] = None):
2060
+ max_cpu: Optional[_builtins.int] = None,
2061
+ max_memory: Optional[_builtins.int] = None,
2062
+ max_storage: Optional[_builtins.int] = None,
2063
+ min_cpu: Optional[_builtins.int] = None,
2064
+ min_memory: Optional[_builtins.int] = None,
2065
+ min_storage: Optional[_builtins.int] = None):
2067
2066
  if max_cpu is not None:
2068
2067
  pulumi.set(__self__, "max_cpu", max_cpu)
2069
2068
  if max_memory is not None:
@@ -2077,34 +2076,34 @@ class ElastigroupAzureV3VmSizesSpotSizeAttributes(dict):
2077
2076
  if min_storage is not None:
2078
2077
  pulumi.set(__self__, "min_storage", min_storage)
2079
2078
 
2080
- @property
2079
+ @_builtins.property
2081
2080
  @pulumi.getter(name="maxCpu")
2082
- def max_cpu(self) -> Optional[builtins.int]:
2081
+ def max_cpu(self) -> Optional[_builtins.int]:
2083
2082
  return pulumi.get(self, "max_cpu")
2084
2083
 
2085
- @property
2084
+ @_builtins.property
2086
2085
  @pulumi.getter(name="maxMemory")
2087
- def max_memory(self) -> Optional[builtins.int]:
2086
+ def max_memory(self) -> Optional[_builtins.int]:
2088
2087
  return pulumi.get(self, "max_memory")
2089
2088
 
2090
- @property
2089
+ @_builtins.property
2091
2090
  @pulumi.getter(name="maxStorage")
2092
- def max_storage(self) -> Optional[builtins.int]:
2091
+ def max_storage(self) -> Optional[_builtins.int]:
2093
2092
  return pulumi.get(self, "max_storage")
2094
2093
 
2095
- @property
2094
+ @_builtins.property
2096
2095
  @pulumi.getter(name="minCpu")
2097
- def min_cpu(self) -> Optional[builtins.int]:
2096
+ def min_cpu(self) -> Optional[_builtins.int]:
2098
2097
  return pulumi.get(self, "min_cpu")
2099
2098
 
2100
- @property
2099
+ @_builtins.property
2101
2100
  @pulumi.getter(name="minMemory")
2102
- def min_memory(self) -> Optional[builtins.int]:
2101
+ def min_memory(self) -> Optional[_builtins.int]:
2103
2102
  return pulumi.get(self, "min_memory")
2104
2103
 
2105
- @property
2104
+ @_builtins.property
2106
2105
  @pulumi.getter(name="minStorage")
2107
- def min_storage(self) -> Optional[builtins.int]:
2106
+ def min_storage(self) -> Optional[_builtins.int]:
2108
2107
  return pulumi.get(self, "min_storage")
2109
2108
 
2110
2109
 
@@ -2130,23 +2129,23 @@ class HealthCheckCheck(dict):
2130
2129
  return super().get(key, default)
2131
2130
 
2132
2131
  def __init__(__self__, *,
2133
- healthy: builtins.int,
2134
- interval: builtins.int,
2135
- port: builtins.int,
2136
- protocol: builtins.str,
2137
- unhealthy: builtins.int,
2138
- end_point: Optional[builtins.str] = None,
2139
- endpoint: Optional[builtins.str] = None,
2140
- time_out: Optional[builtins.int] = None,
2141
- timeout: Optional[builtins.int] = None):
2132
+ healthy: _builtins.int,
2133
+ interval: _builtins.int,
2134
+ port: _builtins.int,
2135
+ protocol: _builtins.str,
2136
+ unhealthy: _builtins.int,
2137
+ end_point: Optional[_builtins.str] = None,
2138
+ endpoint: Optional[_builtins.str] = None,
2139
+ time_out: Optional[_builtins.int] = None,
2140
+ timeout: Optional[_builtins.int] = None):
2142
2141
  """
2143
- :param builtins.int healthy: The number of consecutive successful health checks that must occur before declaring an instance healthy.
2144
- :param builtins.int interval: The amount of time (in seconds) between each health check (minimum: 10).
2145
- :param builtins.int port: The port to use to connect with the instance.
2146
- :param builtins.str protocol: The protocol to use to connect with the instance. Valid values: http, https.
2147
- :param builtins.int unhealthy: The number of consecutive failed health checks that must occur before declaring an instance unhealthy.
2148
- :param builtins.str endpoint: The destination for the request.
2149
- :param builtins.int timeout: the amount of time (in seconds) to wait when receiving a response from the health check.
2142
+ :param _builtins.int healthy: The number of consecutive successful health checks that must occur before declaring an instance healthy.
2143
+ :param _builtins.int interval: The amount of time (in seconds) between each health check (minimum: 10).
2144
+ :param _builtins.int port: The port to use to connect with the instance.
2145
+ :param _builtins.str protocol: The protocol to use to connect with the instance. Valid values: http, https.
2146
+ :param _builtins.int unhealthy: The number of consecutive failed health checks that must occur before declaring an instance unhealthy.
2147
+ :param _builtins.str endpoint: The destination for the request.
2148
+ :param _builtins.int timeout: the amount of time (in seconds) to wait when receiving a response from the health check.
2150
2149
  """
2151
2150
  pulumi.set(__self__, "healthy", healthy)
2152
2151
  pulumi.set(__self__, "interval", interval)
@@ -2162,67 +2161,67 @@ class HealthCheckCheck(dict):
2162
2161
  if timeout is not None:
2163
2162
  pulumi.set(__self__, "timeout", timeout)
2164
2163
 
2165
- @property
2164
+ @_builtins.property
2166
2165
  @pulumi.getter
2167
- def healthy(self) -> builtins.int:
2166
+ def healthy(self) -> _builtins.int:
2168
2167
  """
2169
2168
  The number of consecutive successful health checks that must occur before declaring an instance healthy.
2170
2169
  """
2171
2170
  return pulumi.get(self, "healthy")
2172
2171
 
2173
- @property
2172
+ @_builtins.property
2174
2173
  @pulumi.getter
2175
- def interval(self) -> builtins.int:
2174
+ def interval(self) -> _builtins.int:
2176
2175
  """
2177
2176
  The amount of time (in seconds) between each health check (minimum: 10).
2178
2177
  """
2179
2178
  return pulumi.get(self, "interval")
2180
2179
 
2181
- @property
2180
+ @_builtins.property
2182
2181
  @pulumi.getter
2183
- def port(self) -> builtins.int:
2182
+ def port(self) -> _builtins.int:
2184
2183
  """
2185
2184
  The port to use to connect with the instance.
2186
2185
  """
2187
2186
  return pulumi.get(self, "port")
2188
2187
 
2189
- @property
2188
+ @_builtins.property
2190
2189
  @pulumi.getter
2191
- def protocol(self) -> builtins.str:
2190
+ def protocol(self) -> _builtins.str:
2192
2191
  """
2193
2192
  The protocol to use to connect with the instance. Valid values: http, https.
2194
2193
  """
2195
2194
  return pulumi.get(self, "protocol")
2196
2195
 
2197
- @property
2196
+ @_builtins.property
2198
2197
  @pulumi.getter
2199
- def unhealthy(self) -> builtins.int:
2198
+ def unhealthy(self) -> _builtins.int:
2200
2199
  """
2201
2200
  The number of consecutive failed health checks that must occur before declaring an instance unhealthy.
2202
2201
  """
2203
2202
  return pulumi.get(self, "unhealthy")
2204
2203
 
2205
- @property
2204
+ @_builtins.property
2206
2205
  @pulumi.getter(name="endPoint")
2207
- def end_point(self) -> Optional[builtins.str]:
2206
+ def end_point(self) -> Optional[_builtins.str]:
2208
2207
  return pulumi.get(self, "end_point")
2209
2208
 
2210
- @property
2209
+ @_builtins.property
2211
2210
  @pulumi.getter
2212
- def endpoint(self) -> Optional[builtins.str]:
2211
+ def endpoint(self) -> Optional[_builtins.str]:
2213
2212
  """
2214
2213
  The destination for the request.
2215
2214
  """
2216
2215
  return pulumi.get(self, "endpoint")
2217
2216
 
2218
- @property
2217
+ @_builtins.property
2219
2218
  @pulumi.getter(name="timeOut")
2220
- def time_out(self) -> Optional[builtins.int]:
2219
+ def time_out(self) -> Optional[_builtins.int]:
2221
2220
  return pulumi.get(self, "time_out")
2222
2221
 
2223
- @property
2222
+ @_builtins.property
2224
2223
  @pulumi.getter
2225
- def timeout(self) -> Optional[builtins.int]:
2224
+ def timeout(self) -> Optional[_builtins.int]:
2226
2225
  """
2227
2226
  the amount of time (in seconds) to wait when receiving a response from the health check.
2228
2227
  """
@@ -2255,8 +2254,8 @@ class NotificationCenterComputePolicyConfig(dict):
2255
2254
  def __init__(__self__, *,
2256
2255
  events: Sequence['outputs.NotificationCenterComputePolicyConfigEvent'],
2257
2256
  dynamic_rules: Optional[Sequence['outputs.NotificationCenterComputePolicyConfigDynamicRule']] = None,
2258
- resource_ids: Optional[Sequence[builtins.str]] = None,
2259
- should_include_all_resources: Optional[builtins.bool] = None):
2257
+ resource_ids: Optional[Sequence[_builtins.str]] = None,
2258
+ should_include_all_resources: Optional[_builtins.bool] = None):
2260
2259
  pulumi.set(__self__, "events", events)
2261
2260
  if dynamic_rules is not None:
2262
2261
  pulumi.set(__self__, "dynamic_rules", dynamic_rules)
@@ -2265,24 +2264,24 @@ class NotificationCenterComputePolicyConfig(dict):
2265
2264
  if should_include_all_resources is not None:
2266
2265
  pulumi.set(__self__, "should_include_all_resources", should_include_all_resources)
2267
2266
 
2268
- @property
2267
+ @_builtins.property
2269
2268
  @pulumi.getter
2270
2269
  def events(self) -> Sequence['outputs.NotificationCenterComputePolicyConfigEvent']:
2271
2270
  return pulumi.get(self, "events")
2272
2271
 
2273
- @property
2272
+ @_builtins.property
2274
2273
  @pulumi.getter(name="dynamicRules")
2275
2274
  def dynamic_rules(self) -> Optional[Sequence['outputs.NotificationCenterComputePolicyConfigDynamicRule']]:
2276
2275
  return pulumi.get(self, "dynamic_rules")
2277
2276
 
2278
- @property
2277
+ @_builtins.property
2279
2278
  @pulumi.getter(name="resourceIds")
2280
- def resource_ids(self) -> Optional[Sequence[builtins.str]]:
2279
+ def resource_ids(self) -> Optional[Sequence[_builtins.str]]:
2281
2280
  return pulumi.get(self, "resource_ids")
2282
2281
 
2283
- @property
2282
+ @_builtins.property
2284
2283
  @pulumi.getter(name="shouldIncludeAllResources")
2285
- def should_include_all_resources(self) -> Optional[builtins.bool]:
2284
+ def should_include_all_resources(self) -> Optional[_builtins.bool]:
2286
2285
  return pulumi.get(self, "should_include_all_resources")
2287
2286
 
2288
2287
 
@@ -2310,7 +2309,7 @@ class NotificationCenterComputePolicyConfigDynamicRule(dict):
2310
2309
  if filter_conditions is not None:
2311
2310
  pulumi.set(__self__, "filter_conditions", filter_conditions)
2312
2311
 
2313
- @property
2312
+ @_builtins.property
2314
2313
  @pulumi.getter(name="filterConditions")
2315
2314
  def filter_conditions(self) -> Optional[Sequence['outputs.NotificationCenterComputePolicyConfigDynamicRuleFilterCondition']]:
2316
2315
  return pulumi.get(self, "filter_conditions")
@@ -2319,9 +2318,9 @@ class NotificationCenterComputePolicyConfigDynamicRule(dict):
2319
2318
  @pulumi.output_type
2320
2319
  class NotificationCenterComputePolicyConfigDynamicRuleFilterCondition(dict):
2321
2320
  def __init__(__self__, *,
2322
- expression: Optional[builtins.str] = None,
2323
- identifier: Optional[builtins.str] = None,
2324
- operator: Optional[builtins.str] = None):
2321
+ expression: Optional[_builtins.str] = None,
2322
+ identifier: Optional[_builtins.str] = None,
2323
+ operator: Optional[_builtins.str] = None):
2325
2324
  if expression is not None:
2326
2325
  pulumi.set(__self__, "expression", expression)
2327
2326
  if identifier is not None:
@@ -2329,19 +2328,19 @@ class NotificationCenterComputePolicyConfigDynamicRuleFilterCondition(dict):
2329
2328
  if operator is not None:
2330
2329
  pulumi.set(__self__, "operator", operator)
2331
2330
 
2332
- @property
2331
+ @_builtins.property
2333
2332
  @pulumi.getter
2334
- def expression(self) -> Optional[builtins.str]:
2333
+ def expression(self) -> Optional[_builtins.str]:
2335
2334
  return pulumi.get(self, "expression")
2336
2335
 
2337
- @property
2336
+ @_builtins.property
2338
2337
  @pulumi.getter
2339
- def identifier(self) -> Optional[builtins.str]:
2338
+ def identifier(self) -> Optional[_builtins.str]:
2340
2339
  return pulumi.get(self, "identifier")
2341
2340
 
2342
- @property
2341
+ @_builtins.property
2343
2342
  @pulumi.getter
2344
- def operator(self) -> Optional[builtins.str]:
2343
+ def operator(self) -> Optional[_builtins.str]:
2345
2344
  return pulumi.get(self, "operator")
2346
2345
 
2347
2346
 
@@ -2365,21 +2364,21 @@ class NotificationCenterComputePolicyConfigEvent(dict):
2365
2364
  return super().get(key, default)
2366
2365
 
2367
2366
  def __init__(__self__, *,
2368
- event: Optional[builtins.str] = None,
2369
- event_type: Optional[builtins.str] = None):
2367
+ event: Optional[_builtins.str] = None,
2368
+ event_type: Optional[_builtins.str] = None):
2370
2369
  if event is not None:
2371
2370
  pulumi.set(__self__, "event", event)
2372
2371
  if event_type is not None:
2373
2372
  pulumi.set(__self__, "event_type", event_type)
2374
2373
 
2375
- @property
2374
+ @_builtins.property
2376
2375
  @pulumi.getter
2377
- def event(self) -> Optional[builtins.str]:
2376
+ def event(self) -> Optional[_builtins.str]:
2378
2377
  return pulumi.get(self, "event")
2379
2378
 
2380
- @property
2379
+ @_builtins.property
2381
2380
  @pulumi.getter(name="eventType")
2382
- def event_type(self) -> Optional[builtins.str]:
2381
+ def event_type(self) -> Optional[_builtins.str]:
2383
2382
  return pulumi.get(self, "event_type")
2384
2383
 
2385
2384
 
@@ -2405,21 +2404,21 @@ class NotificationCenterRegisteredUser(dict):
2405
2404
  return super().get(key, default)
2406
2405
 
2407
2406
  def __init__(__self__, *,
2408
- subscription_types: Optional[Sequence[builtins.str]] = None,
2409
- user_email: Optional[builtins.str] = None):
2407
+ subscription_types: Optional[Sequence[_builtins.str]] = None,
2408
+ user_email: Optional[_builtins.str] = None):
2410
2409
  if subscription_types is not None:
2411
2410
  pulumi.set(__self__, "subscription_types", subscription_types)
2412
2411
  if user_email is not None:
2413
2412
  pulumi.set(__self__, "user_email", user_email)
2414
2413
 
2415
- @property
2414
+ @_builtins.property
2416
2415
  @pulumi.getter(name="subscriptionTypes")
2417
- def subscription_types(self) -> Optional[Sequence[builtins.str]]:
2416
+ def subscription_types(self) -> Optional[Sequence[_builtins.str]]:
2418
2417
  return pulumi.get(self, "subscription_types")
2419
2418
 
2420
- @property
2419
+ @_builtins.property
2421
2420
  @pulumi.getter(name="userEmail")
2422
- def user_email(self) -> Optional[builtins.str]:
2421
+ def user_email(self) -> Optional[_builtins.str]:
2423
2422
  return pulumi.get(self, "user_email")
2424
2423
 
2425
2424
 
@@ -2443,21 +2442,21 @@ class NotificationCenterSubscription(dict):
2443
2442
  return super().get(key, default)
2444
2443
 
2445
2444
  def __init__(__self__, *,
2446
- endpoint: Optional[builtins.str] = None,
2447
- subscription_type: Optional[builtins.str] = None):
2445
+ endpoint: Optional[_builtins.str] = None,
2446
+ subscription_type: Optional[_builtins.str] = None):
2448
2447
  if endpoint is not None:
2449
2448
  pulumi.set(__self__, "endpoint", endpoint)
2450
2449
  if subscription_type is not None:
2451
2450
  pulumi.set(__self__, "subscription_type", subscription_type)
2452
2451
 
2453
- @property
2452
+ @_builtins.property
2454
2453
  @pulumi.getter
2455
- def endpoint(self) -> Optional[builtins.str]:
2454
+ def endpoint(self) -> Optional[_builtins.str]:
2456
2455
  return pulumi.get(self, "endpoint")
2457
2456
 
2458
- @property
2457
+ @_builtins.property
2459
2458
  @pulumi.getter(name="subscriptionType")
2460
- def subscription_type(self) -> Optional[builtins.str]:
2459
+ def subscription_type(self) -> Optional[_builtins.str]:
2461
2460
  return pulumi.get(self, "subscription_type")
2462
2461
 
2463
2462
 
@@ -2467,7 +2466,7 @@ class OceanRightSizingRuleAttachWorkload(dict):
2467
2466
  namespaces: Sequence['outputs.OceanRightSizingRuleAttachWorkloadNamespace']):
2468
2467
  pulumi.set(__self__, "namespaces", namespaces)
2469
2468
 
2470
- @property
2469
+ @_builtins.property
2471
2470
  @pulumi.getter
2472
2471
  def namespaces(self) -> Sequence['outputs.OceanRightSizingRuleAttachWorkloadNamespace']:
2473
2472
  return pulumi.get(self, "namespaces")
@@ -2493,7 +2492,7 @@ class OceanRightSizingRuleAttachWorkloadNamespace(dict):
2493
2492
  return super().get(key, default)
2494
2493
 
2495
2494
  def __init__(__self__, *,
2496
- namespace_name: builtins.str,
2495
+ namespace_name: _builtins.str,
2497
2496
  labels: Optional[Sequence['outputs.OceanRightSizingRuleAttachWorkloadNamespaceLabel']] = None,
2498
2497
  workloads: Optional[Sequence['outputs.OceanRightSizingRuleAttachWorkloadNamespaceWorkload']] = None):
2499
2498
  pulumi.set(__self__, "namespace_name", namespace_name)
@@ -2502,17 +2501,17 @@ class OceanRightSizingRuleAttachWorkloadNamespace(dict):
2502
2501
  if workloads is not None:
2503
2502
  pulumi.set(__self__, "workloads", workloads)
2504
2503
 
2505
- @property
2504
+ @_builtins.property
2506
2505
  @pulumi.getter(name="namespaceName")
2507
- def namespace_name(self) -> builtins.str:
2506
+ def namespace_name(self) -> _builtins.str:
2508
2507
  return pulumi.get(self, "namespace_name")
2509
2508
 
2510
- @property
2509
+ @_builtins.property
2511
2510
  @pulumi.getter
2512
2511
  def labels(self) -> Optional[Sequence['outputs.OceanRightSizingRuleAttachWorkloadNamespaceLabel']]:
2513
2512
  return pulumi.get(self, "labels")
2514
2513
 
2515
- @property
2514
+ @_builtins.property
2516
2515
  @pulumi.getter
2517
2516
  def workloads(self) -> Optional[Sequence['outputs.OceanRightSizingRuleAttachWorkloadNamespaceWorkload']]:
2518
2517
  return pulumi.get(self, "workloads")
@@ -2521,19 +2520,19 @@ class OceanRightSizingRuleAttachWorkloadNamespace(dict):
2521
2520
  @pulumi.output_type
2522
2521
  class OceanRightSizingRuleAttachWorkloadNamespaceLabel(dict):
2523
2522
  def __init__(__self__, *,
2524
- key: builtins.str,
2525
- value: builtins.str):
2523
+ key: _builtins.str,
2524
+ value: _builtins.str):
2526
2525
  pulumi.set(__self__, "key", key)
2527
2526
  pulumi.set(__self__, "value", value)
2528
2527
 
2529
- @property
2528
+ @_builtins.property
2530
2529
  @pulumi.getter
2531
- def key(self) -> builtins.str:
2530
+ def key(self) -> _builtins.str:
2532
2531
  return pulumi.get(self, "key")
2533
2532
 
2534
- @property
2533
+ @_builtins.property
2535
2534
  @pulumi.getter
2536
- def value(self) -> builtins.str:
2535
+ def value(self) -> _builtins.str:
2537
2536
  return pulumi.get(self, "value")
2538
2537
 
2539
2538
 
@@ -2561,28 +2560,28 @@ class OceanRightSizingRuleAttachWorkloadNamespaceWorkload(dict):
2561
2560
  return super().get(key, default)
2562
2561
 
2563
2562
  def __init__(__self__, *,
2564
- workload_type: builtins.str,
2565
- regex_name: Optional[builtins.str] = None,
2566
- workload_name: Optional[builtins.str] = None):
2563
+ workload_type: _builtins.str,
2564
+ regex_name: Optional[_builtins.str] = None,
2565
+ workload_name: Optional[_builtins.str] = None):
2567
2566
  pulumi.set(__self__, "workload_type", workload_type)
2568
2567
  if regex_name is not None:
2569
2568
  pulumi.set(__self__, "regex_name", regex_name)
2570
2569
  if workload_name is not None:
2571
2570
  pulumi.set(__self__, "workload_name", workload_name)
2572
2571
 
2573
- @property
2572
+ @_builtins.property
2574
2573
  @pulumi.getter(name="workloadType")
2575
- def workload_type(self) -> builtins.str:
2574
+ def workload_type(self) -> _builtins.str:
2576
2575
  return pulumi.get(self, "workload_type")
2577
2576
 
2578
- @property
2577
+ @_builtins.property
2579
2578
  @pulumi.getter(name="regexName")
2580
- def regex_name(self) -> Optional[builtins.str]:
2579
+ def regex_name(self) -> Optional[_builtins.str]:
2581
2580
  return pulumi.get(self, "regex_name")
2582
2581
 
2583
- @property
2582
+ @_builtins.property
2584
2583
  @pulumi.getter(name="workloadName")
2585
- def workload_name(self) -> Optional[builtins.str]:
2584
+ def workload_name(self) -> Optional[_builtins.str]:
2586
2585
  return pulumi.get(self, "workload_name")
2587
2586
 
2588
2587
 
@@ -2592,7 +2591,7 @@ class OceanRightSizingRuleDetachWorkload(dict):
2592
2591
  namespaces: Sequence['outputs.OceanRightSizingRuleDetachWorkloadNamespace']):
2593
2592
  pulumi.set(__self__, "namespaces", namespaces)
2594
2593
 
2595
- @property
2594
+ @_builtins.property
2596
2595
  @pulumi.getter
2597
2596
  def namespaces(self) -> Sequence['outputs.OceanRightSizingRuleDetachWorkloadNamespace']:
2598
2597
  return pulumi.get(self, "namespaces")
@@ -2618,7 +2617,7 @@ class OceanRightSizingRuleDetachWorkloadNamespace(dict):
2618
2617
  return super().get(key, default)
2619
2618
 
2620
2619
  def __init__(__self__, *,
2621
- namespace_name: builtins.str,
2620
+ namespace_name: _builtins.str,
2622
2621
  labels: Optional[Sequence['outputs.OceanRightSizingRuleDetachWorkloadNamespaceLabel']] = None,
2623
2622
  workloads: Optional[Sequence['outputs.OceanRightSizingRuleDetachWorkloadNamespaceWorkload']] = None):
2624
2623
  pulumi.set(__self__, "namespace_name", namespace_name)
@@ -2627,17 +2626,17 @@ class OceanRightSizingRuleDetachWorkloadNamespace(dict):
2627
2626
  if workloads is not None:
2628
2627
  pulumi.set(__self__, "workloads", workloads)
2629
2628
 
2630
- @property
2629
+ @_builtins.property
2631
2630
  @pulumi.getter(name="namespaceName")
2632
- def namespace_name(self) -> builtins.str:
2631
+ def namespace_name(self) -> _builtins.str:
2633
2632
  return pulumi.get(self, "namespace_name")
2634
2633
 
2635
- @property
2634
+ @_builtins.property
2636
2635
  @pulumi.getter
2637
2636
  def labels(self) -> Optional[Sequence['outputs.OceanRightSizingRuleDetachWorkloadNamespaceLabel']]:
2638
2637
  return pulumi.get(self, "labels")
2639
2638
 
2640
- @property
2639
+ @_builtins.property
2641
2640
  @pulumi.getter
2642
2641
  def workloads(self) -> Optional[Sequence['outputs.OceanRightSizingRuleDetachWorkloadNamespaceWorkload']]:
2643
2642
  return pulumi.get(self, "workloads")
@@ -2646,19 +2645,19 @@ class OceanRightSizingRuleDetachWorkloadNamespace(dict):
2646
2645
  @pulumi.output_type
2647
2646
  class OceanRightSizingRuleDetachWorkloadNamespaceLabel(dict):
2648
2647
  def __init__(__self__, *,
2649
- key: builtins.str,
2650
- value: builtins.str):
2648
+ key: _builtins.str,
2649
+ value: _builtins.str):
2651
2650
  pulumi.set(__self__, "key", key)
2652
2651
  pulumi.set(__self__, "value", value)
2653
2652
 
2654
- @property
2653
+ @_builtins.property
2655
2654
  @pulumi.getter
2656
- def key(self) -> builtins.str:
2655
+ def key(self) -> _builtins.str:
2657
2656
  return pulumi.get(self, "key")
2658
2657
 
2659
- @property
2658
+ @_builtins.property
2660
2659
  @pulumi.getter
2661
- def value(self) -> builtins.str:
2660
+ def value(self) -> _builtins.str:
2662
2661
  return pulumi.get(self, "value")
2663
2662
 
2664
2663
 
@@ -2686,28 +2685,28 @@ class OceanRightSizingRuleDetachWorkloadNamespaceWorkload(dict):
2686
2685
  return super().get(key, default)
2687
2686
 
2688
2687
  def __init__(__self__, *,
2689
- workload_type: builtins.str,
2690
- regex_name: Optional[builtins.str] = None,
2691
- workload_name: Optional[builtins.str] = None):
2688
+ workload_type: _builtins.str,
2689
+ regex_name: Optional[_builtins.str] = None,
2690
+ workload_name: Optional[_builtins.str] = None):
2692
2691
  pulumi.set(__self__, "workload_type", workload_type)
2693
2692
  if regex_name is not None:
2694
2693
  pulumi.set(__self__, "regex_name", regex_name)
2695
2694
  if workload_name is not None:
2696
2695
  pulumi.set(__self__, "workload_name", workload_name)
2697
2696
 
2698
- @property
2697
+ @_builtins.property
2699
2698
  @pulumi.getter(name="workloadType")
2700
- def workload_type(self) -> builtins.str:
2699
+ def workload_type(self) -> _builtins.str:
2701
2700
  return pulumi.get(self, "workload_type")
2702
2701
 
2703
- @property
2702
+ @_builtins.property
2704
2703
  @pulumi.getter(name="regexName")
2705
- def regex_name(self) -> Optional[builtins.str]:
2704
+ def regex_name(self) -> Optional[_builtins.str]:
2706
2705
  return pulumi.get(self, "regex_name")
2707
2706
 
2708
- @property
2707
+ @_builtins.property
2709
2708
  @pulumi.getter(name="workloadName")
2710
- def workload_name(self) -> Optional[builtins.str]:
2709
+ def workload_name(self) -> Optional[_builtins.str]:
2711
2710
  return pulumi.get(self, "workload_name")
2712
2711
 
2713
2712
 
@@ -2737,10 +2736,10 @@ class OceanRightSizingRuleRecommendationApplicationBoundary(dict):
2737
2736
  return super().get(key, default)
2738
2737
 
2739
2738
  def __init__(__self__, *,
2740
- cpu_max: Optional[builtins.float] = None,
2741
- cpu_min: Optional[builtins.float] = None,
2742
- memory_max: Optional[builtins.int] = None,
2743
- memory_min: Optional[builtins.int] = None):
2739
+ cpu_max: Optional[_builtins.float] = None,
2740
+ cpu_min: Optional[_builtins.float] = None,
2741
+ memory_max: Optional[_builtins.int] = None,
2742
+ memory_min: Optional[_builtins.int] = None):
2744
2743
  if cpu_max is not None:
2745
2744
  pulumi.set(__self__, "cpu_max", cpu_max)
2746
2745
  if cpu_min is not None:
@@ -2750,24 +2749,24 @@ class OceanRightSizingRuleRecommendationApplicationBoundary(dict):
2750
2749
  if memory_min is not None:
2751
2750
  pulumi.set(__self__, "memory_min", memory_min)
2752
2751
 
2753
- @property
2752
+ @_builtins.property
2754
2753
  @pulumi.getter(name="cpuMax")
2755
- def cpu_max(self) -> Optional[builtins.float]:
2754
+ def cpu_max(self) -> Optional[_builtins.float]:
2756
2755
  return pulumi.get(self, "cpu_max")
2757
2756
 
2758
- @property
2757
+ @_builtins.property
2759
2758
  @pulumi.getter(name="cpuMin")
2760
- def cpu_min(self) -> Optional[builtins.float]:
2759
+ def cpu_min(self) -> Optional[_builtins.float]:
2761
2760
  return pulumi.get(self, "cpu_min")
2762
2761
 
2763
- @property
2762
+ @_builtins.property
2764
2763
  @pulumi.getter(name="memoryMax")
2765
- def memory_max(self) -> Optional[builtins.int]:
2764
+ def memory_max(self) -> Optional[_builtins.int]:
2766
2765
  return pulumi.get(self, "memory_max")
2767
2766
 
2768
- @property
2767
+ @_builtins.property
2769
2768
  @pulumi.getter(name="memoryMin")
2770
- def memory_min(self) -> Optional[builtins.int]:
2769
+ def memory_min(self) -> Optional[_builtins.int]:
2771
2770
  return pulumi.get(self, "memory_min")
2772
2771
 
2773
2772
 
@@ -2791,13 +2790,13 @@ class OceanRightSizingRuleRecommendationApplicationHpa(dict):
2791
2790
  return super().get(key, default)
2792
2791
 
2793
2792
  def __init__(__self__, *,
2794
- allow_hpa_recommendations: Optional[builtins.bool] = None):
2793
+ allow_hpa_recommendations: Optional[_builtins.bool] = None):
2795
2794
  if allow_hpa_recommendations is not None:
2796
2795
  pulumi.set(__self__, "allow_hpa_recommendations", allow_hpa_recommendations)
2797
2796
 
2798
- @property
2797
+ @_builtins.property
2799
2798
  @pulumi.getter(name="allowHpaRecommendations")
2800
- def allow_hpa_recommendations(self) -> Optional[builtins.bool]:
2799
+ def allow_hpa_recommendations(self) -> Optional[_builtins.bool]:
2801
2800
  return pulumi.get(self, "allow_hpa_recommendations")
2802
2801
 
2803
2802
 
@@ -2825,7 +2824,7 @@ class OceanRightSizingRuleRecommendationApplicationInterval(dict):
2825
2824
  return super().get(key, default)
2826
2825
 
2827
2826
  def __init__(__self__, *,
2828
- repetition_basis: builtins.str,
2827
+ repetition_basis: _builtins.str,
2829
2828
  monthly_repetition_bases: Optional[Sequence['outputs.OceanRightSizingRuleRecommendationApplicationIntervalMonthlyRepetitionBase']] = None,
2830
2829
  weekly_repetition_bases: Optional[Sequence['outputs.OceanRightSizingRuleRecommendationApplicationIntervalWeeklyRepetitionBase']] = None):
2831
2830
  pulumi.set(__self__, "repetition_basis", repetition_basis)
@@ -2834,17 +2833,17 @@ class OceanRightSizingRuleRecommendationApplicationInterval(dict):
2834
2833
  if weekly_repetition_bases is not None:
2835
2834
  pulumi.set(__self__, "weekly_repetition_bases", weekly_repetition_bases)
2836
2835
 
2837
- @property
2836
+ @_builtins.property
2838
2837
  @pulumi.getter(name="repetitionBasis")
2839
- def repetition_basis(self) -> builtins.str:
2838
+ def repetition_basis(self) -> _builtins.str:
2840
2839
  return pulumi.get(self, "repetition_basis")
2841
2840
 
2842
- @property
2841
+ @_builtins.property
2843
2842
  @pulumi.getter(name="monthlyRepetitionBases")
2844
2843
  def monthly_repetition_bases(self) -> Optional[Sequence['outputs.OceanRightSizingRuleRecommendationApplicationIntervalMonthlyRepetitionBase']]:
2845
2844
  return pulumi.get(self, "monthly_repetition_bases")
2846
2845
 
2847
- @property
2846
+ @_builtins.property
2848
2847
  @pulumi.getter(name="weeklyRepetitionBases")
2849
2848
  def weekly_repetition_bases(self) -> Optional[Sequence['outputs.OceanRightSizingRuleRecommendationApplicationIntervalWeeklyRepetitionBase']]:
2850
2849
  return pulumi.get(self, "weekly_repetition_bases")
@@ -2874,25 +2873,25 @@ class OceanRightSizingRuleRecommendationApplicationIntervalMonthlyRepetitionBase
2874
2873
  return super().get(key, default)
2875
2874
 
2876
2875
  def __init__(__self__, *,
2877
- interval_months: Sequence[builtins.int],
2878
- week_of_the_months: Sequence[builtins.str],
2876
+ interval_months: Sequence[_builtins.int],
2877
+ week_of_the_months: Sequence[_builtins.str],
2879
2878
  weekly_repetition_bases: Optional[Sequence['outputs.OceanRightSizingRuleRecommendationApplicationIntervalMonthlyRepetitionBaseWeeklyRepetitionBase']] = None):
2880
2879
  pulumi.set(__self__, "interval_months", interval_months)
2881
2880
  pulumi.set(__self__, "week_of_the_months", week_of_the_months)
2882
2881
  if weekly_repetition_bases is not None:
2883
2882
  pulumi.set(__self__, "weekly_repetition_bases", weekly_repetition_bases)
2884
2883
 
2885
- @property
2884
+ @_builtins.property
2886
2885
  @pulumi.getter(name="intervalMonths")
2887
- def interval_months(self) -> Sequence[builtins.int]:
2886
+ def interval_months(self) -> Sequence[_builtins.int]:
2888
2887
  return pulumi.get(self, "interval_months")
2889
2888
 
2890
- @property
2889
+ @_builtins.property
2891
2890
  @pulumi.getter(name="weekOfTheMonths")
2892
- def week_of_the_months(self) -> Sequence[builtins.str]:
2891
+ def week_of_the_months(self) -> Sequence[_builtins.str]:
2893
2892
  return pulumi.get(self, "week_of_the_months")
2894
2893
 
2895
- @property
2894
+ @_builtins.property
2896
2895
  @pulumi.getter(name="weeklyRepetitionBases")
2897
2896
  def weekly_repetition_bases(self) -> Optional[Sequence['outputs.OceanRightSizingRuleRecommendationApplicationIntervalMonthlyRepetitionBaseWeeklyRepetitionBase']]:
2898
2897
  return pulumi.get(self, "weekly_repetition_bases")
@@ -2922,26 +2921,26 @@ class OceanRightSizingRuleRecommendationApplicationIntervalMonthlyRepetitionBase
2922
2921
  return super().get(key, default)
2923
2922
 
2924
2923
  def __init__(__self__, *,
2925
- interval_days: Sequence[builtins.str],
2926
- interval_hours_end_time: builtins.str,
2927
- interval_hours_start_time: builtins.str):
2924
+ interval_days: Sequence[_builtins.str],
2925
+ interval_hours_end_time: _builtins.str,
2926
+ interval_hours_start_time: _builtins.str):
2928
2927
  pulumi.set(__self__, "interval_days", interval_days)
2929
2928
  pulumi.set(__self__, "interval_hours_end_time", interval_hours_end_time)
2930
2929
  pulumi.set(__self__, "interval_hours_start_time", interval_hours_start_time)
2931
2930
 
2932
- @property
2931
+ @_builtins.property
2933
2932
  @pulumi.getter(name="intervalDays")
2934
- def interval_days(self) -> Sequence[builtins.str]:
2933
+ def interval_days(self) -> Sequence[_builtins.str]:
2935
2934
  return pulumi.get(self, "interval_days")
2936
2935
 
2937
- @property
2936
+ @_builtins.property
2938
2937
  @pulumi.getter(name="intervalHoursEndTime")
2939
- def interval_hours_end_time(self) -> builtins.str:
2938
+ def interval_hours_end_time(self) -> _builtins.str:
2940
2939
  return pulumi.get(self, "interval_hours_end_time")
2941
2940
 
2942
- @property
2941
+ @_builtins.property
2943
2942
  @pulumi.getter(name="intervalHoursStartTime")
2944
- def interval_hours_start_time(self) -> builtins.str:
2943
+ def interval_hours_start_time(self) -> _builtins.str:
2945
2944
  return pulumi.get(self, "interval_hours_start_time")
2946
2945
 
2947
2946
 
@@ -2969,26 +2968,26 @@ class OceanRightSizingRuleRecommendationApplicationIntervalWeeklyRepetitionBase(
2969
2968
  return super().get(key, default)
2970
2969
 
2971
2970
  def __init__(__self__, *,
2972
- interval_days: Sequence[builtins.str],
2973
- interval_hours_end_time: builtins.str,
2974
- interval_hours_start_time: builtins.str):
2971
+ interval_days: Sequence[_builtins.str],
2972
+ interval_hours_end_time: _builtins.str,
2973
+ interval_hours_start_time: _builtins.str):
2975
2974
  pulumi.set(__self__, "interval_days", interval_days)
2976
2975
  pulumi.set(__self__, "interval_hours_end_time", interval_hours_end_time)
2977
2976
  pulumi.set(__self__, "interval_hours_start_time", interval_hours_start_time)
2978
2977
 
2979
- @property
2978
+ @_builtins.property
2980
2979
  @pulumi.getter(name="intervalDays")
2981
- def interval_days(self) -> Sequence[builtins.str]:
2980
+ def interval_days(self) -> Sequence[_builtins.str]:
2982
2981
  return pulumi.get(self, "interval_days")
2983
2982
 
2984
- @property
2983
+ @_builtins.property
2985
2984
  @pulumi.getter(name="intervalHoursEndTime")
2986
- def interval_hours_end_time(self) -> builtins.str:
2985
+ def interval_hours_end_time(self) -> _builtins.str:
2987
2986
  return pulumi.get(self, "interval_hours_end_time")
2988
2987
 
2989
- @property
2988
+ @_builtins.property
2990
2989
  @pulumi.getter(name="intervalHoursStartTime")
2991
- def interval_hours_start_time(self) -> builtins.str:
2990
+ def interval_hours_start_time(self) -> _builtins.str:
2992
2991
  return pulumi.get(self, "interval_hours_start_time")
2993
2992
 
2994
2993
 
@@ -3014,21 +3013,21 @@ class OceanRightSizingRuleRecommendationApplicationMinThreshold(dict):
3014
3013
  return super().get(key, default)
3015
3014
 
3016
3015
  def __init__(__self__, *,
3017
- cpu_percentage: Optional[builtins.float] = None,
3018
- memory_percentage: Optional[builtins.float] = None):
3016
+ cpu_percentage: Optional[_builtins.float] = None,
3017
+ memory_percentage: Optional[_builtins.float] = None):
3019
3018
  if cpu_percentage is not None:
3020
3019
  pulumi.set(__self__, "cpu_percentage", cpu_percentage)
3021
3020
  if memory_percentage is not None:
3022
3021
  pulumi.set(__self__, "memory_percentage", memory_percentage)
3023
3022
 
3024
- @property
3023
+ @_builtins.property
3025
3024
  @pulumi.getter(name="cpuPercentage")
3026
- def cpu_percentage(self) -> Optional[builtins.float]:
3025
+ def cpu_percentage(self) -> Optional[_builtins.float]:
3027
3026
  return pulumi.get(self, "cpu_percentage")
3028
3027
 
3029
- @property
3028
+ @_builtins.property
3030
3029
  @pulumi.getter(name="memoryPercentage")
3031
- def memory_percentage(self) -> Optional[builtins.float]:
3030
+ def memory_percentage(self) -> Optional[_builtins.float]:
3032
3031
  return pulumi.get(self, "memory_percentage")
3033
3032
 
3034
3033
 
@@ -3054,21 +3053,21 @@ class OceanRightSizingRuleRecommendationApplicationOverheadValue(dict):
3054
3053
  return super().get(key, default)
3055
3054
 
3056
3055
  def __init__(__self__, *,
3057
- cpu_percentage: Optional[builtins.float] = None,
3058
- memory_percentage: Optional[builtins.float] = None):
3056
+ cpu_percentage: Optional[_builtins.float] = None,
3057
+ memory_percentage: Optional[_builtins.float] = None):
3059
3058
  if cpu_percentage is not None:
3060
3059
  pulumi.set(__self__, "cpu_percentage", cpu_percentage)
3061
3060
  if memory_percentage is not None:
3062
3061
  pulumi.set(__self__, "memory_percentage", memory_percentage)
3063
3062
 
3064
- @property
3063
+ @_builtins.property
3065
3064
  @pulumi.getter(name="cpuPercentage")
3066
- def cpu_percentage(self) -> Optional[builtins.float]:
3065
+ def cpu_percentage(self) -> Optional[_builtins.float]:
3067
3066
  return pulumi.get(self, "cpu_percentage")
3068
3067
 
3069
- @property
3068
+ @_builtins.property
3070
3069
  @pulumi.getter(name="memoryPercentage")
3071
- def memory_percentage(self) -> Optional[builtins.float]:
3070
+ def memory_percentage(self) -> Optional[_builtins.float]:
3072
3071
  return pulumi.get(self, "memory_percentage")
3073
3072
 
3074
3073
 
@@ -3098,12 +3097,12 @@ class StatefulNodeAzureAttachDataDisk(dict):
3098
3097
  return super().get(key, default)
3099
3098
 
3100
3099
  def __init__(__self__, *,
3101
- data_disk_name: builtins.str,
3102
- data_disk_resource_group_name: builtins.str,
3103
- size_gb: builtins.int,
3104
- storage_account_type: builtins.str,
3105
- lun: Optional[builtins.int] = None,
3106
- zone: Optional[builtins.str] = None):
3100
+ data_disk_name: _builtins.str,
3101
+ data_disk_resource_group_name: _builtins.str,
3102
+ size_gb: _builtins.int,
3103
+ storage_account_type: _builtins.str,
3104
+ lun: Optional[_builtins.int] = None,
3105
+ zone: Optional[_builtins.str] = None):
3107
3106
  pulumi.set(__self__, "data_disk_name", data_disk_name)
3108
3107
  pulumi.set(__self__, "data_disk_resource_group_name", data_disk_resource_group_name)
3109
3108
  pulumi.set(__self__, "size_gb", size_gb)
@@ -3113,34 +3112,34 @@ class StatefulNodeAzureAttachDataDisk(dict):
3113
3112
  if zone is not None:
3114
3113
  pulumi.set(__self__, "zone", zone)
3115
3114
 
3116
- @property
3115
+ @_builtins.property
3117
3116
  @pulumi.getter(name="dataDiskName")
3118
- def data_disk_name(self) -> builtins.str:
3117
+ def data_disk_name(self) -> _builtins.str:
3119
3118
  return pulumi.get(self, "data_disk_name")
3120
3119
 
3121
- @property
3120
+ @_builtins.property
3122
3121
  @pulumi.getter(name="dataDiskResourceGroupName")
3123
- def data_disk_resource_group_name(self) -> builtins.str:
3122
+ def data_disk_resource_group_name(self) -> _builtins.str:
3124
3123
  return pulumi.get(self, "data_disk_resource_group_name")
3125
3124
 
3126
- @property
3125
+ @_builtins.property
3127
3126
  @pulumi.getter(name="sizeGb")
3128
- def size_gb(self) -> builtins.int:
3127
+ def size_gb(self) -> _builtins.int:
3129
3128
  return pulumi.get(self, "size_gb")
3130
3129
 
3131
- @property
3130
+ @_builtins.property
3132
3131
  @pulumi.getter(name="storageAccountType")
3133
- def storage_account_type(self) -> builtins.str:
3132
+ def storage_account_type(self) -> _builtins.str:
3134
3133
  return pulumi.get(self, "storage_account_type")
3135
3134
 
3136
- @property
3135
+ @_builtins.property
3137
3136
  @pulumi.getter
3138
- def lun(self) -> Optional[builtins.int]:
3137
+ def lun(self) -> Optional[_builtins.int]:
3139
3138
  return pulumi.get(self, "lun")
3140
3139
 
3141
- @property
3140
+ @_builtins.property
3142
3141
  @pulumi.getter
3143
- def zone(self) -> Optional[builtins.str]:
3142
+ def zone(self) -> Optional[_builtins.str]:
3144
3143
  return pulumi.get(self, "zone")
3145
3144
 
3146
3145
 
@@ -3166,9 +3165,9 @@ class StatefulNodeAzureBootDiagnostic(dict):
3166
3165
  return super().get(key, default)
3167
3166
 
3168
3167
  def __init__(__self__, *,
3169
- is_enabled: Optional[builtins.bool] = None,
3170
- storage_url: Optional[builtins.str] = None,
3171
- type: Optional[builtins.str] = None):
3168
+ is_enabled: Optional[_builtins.bool] = None,
3169
+ storage_url: Optional[_builtins.str] = None,
3170
+ type: Optional[_builtins.str] = None):
3172
3171
  if is_enabled is not None:
3173
3172
  pulumi.set(__self__, "is_enabled", is_enabled)
3174
3173
  if storage_url is not None:
@@ -3176,19 +3175,19 @@ class StatefulNodeAzureBootDiagnostic(dict):
3176
3175
  if type is not None:
3177
3176
  pulumi.set(__self__, "type", type)
3178
3177
 
3179
- @property
3178
+ @_builtins.property
3180
3179
  @pulumi.getter(name="isEnabled")
3181
- def is_enabled(self) -> Optional[builtins.bool]:
3180
+ def is_enabled(self) -> Optional[_builtins.bool]:
3182
3181
  return pulumi.get(self, "is_enabled")
3183
3182
 
3184
- @property
3183
+ @_builtins.property
3185
3184
  @pulumi.getter(name="storageUrl")
3186
- def storage_url(self) -> Optional[builtins.str]:
3185
+ def storage_url(self) -> Optional[_builtins.str]:
3187
3186
  return pulumi.get(self, "storage_url")
3188
3187
 
3189
- @property
3188
+ @_builtins.property
3190
3189
  @pulumi.getter
3191
- def type(self) -> Optional[builtins.str]:
3190
+ def type(self) -> Optional[_builtins.str]:
3192
3191
  return pulumi.get(self, "type")
3193
3192
 
3194
3193
 
@@ -3212,26 +3211,26 @@ class StatefulNodeAzureDataDisk(dict):
3212
3211
  return super().get(key, default)
3213
3212
 
3214
3213
  def __init__(__self__, *,
3215
- lun: builtins.int,
3216
- size_gb: builtins.int,
3217
- type: builtins.str):
3214
+ lun: _builtins.int,
3215
+ size_gb: _builtins.int,
3216
+ type: _builtins.str):
3218
3217
  pulumi.set(__self__, "lun", lun)
3219
3218
  pulumi.set(__self__, "size_gb", size_gb)
3220
3219
  pulumi.set(__self__, "type", type)
3221
3220
 
3222
- @property
3221
+ @_builtins.property
3223
3222
  @pulumi.getter
3224
- def lun(self) -> builtins.int:
3223
+ def lun(self) -> _builtins.int:
3225
3224
  return pulumi.get(self, "lun")
3226
3225
 
3227
- @property
3226
+ @_builtins.property
3228
3227
  @pulumi.getter(name="sizeGb")
3229
- def size_gb(self) -> builtins.int:
3228
+ def size_gb(self) -> _builtins.int:
3230
3229
  return pulumi.get(self, "size_gb")
3231
3230
 
3232
- @property
3231
+ @_builtins.property
3233
3232
  @pulumi.getter
3234
- def type(self) -> builtins.str:
3233
+ def type(self) -> _builtins.str:
3235
3234
  return pulumi.get(self, "type")
3236
3235
 
3237
3236
 
@@ -3275,17 +3274,17 @@ class StatefulNodeAzureDelete(dict):
3275
3274
  return super().get(key, default)
3276
3275
 
3277
3276
  def __init__(__self__, *,
3278
- should_terminate_vm: builtins.bool,
3279
- disk_should_deallocate: Optional[builtins.bool] = None,
3280
- disk_ttl_in_hours: Optional[builtins.int] = None,
3281
- network_should_deallocate: Optional[builtins.bool] = None,
3282
- network_ttl_in_hours: Optional[builtins.int] = None,
3283
- public_ip_should_deallocate: Optional[builtins.bool] = None,
3284
- public_ip_ttl_in_hours: Optional[builtins.int] = None,
3285
- should_deregister_from_lb: Optional[builtins.bool] = None,
3286
- should_revert_to_od: Optional[builtins.bool] = None,
3287
- snapshot_should_deallocate: Optional[builtins.bool] = None,
3288
- snapshot_ttl_in_hours: Optional[builtins.int] = None):
3277
+ should_terminate_vm: _builtins.bool,
3278
+ disk_should_deallocate: Optional[_builtins.bool] = None,
3279
+ disk_ttl_in_hours: Optional[_builtins.int] = None,
3280
+ network_should_deallocate: Optional[_builtins.bool] = None,
3281
+ network_ttl_in_hours: Optional[_builtins.int] = None,
3282
+ public_ip_should_deallocate: Optional[_builtins.bool] = None,
3283
+ public_ip_ttl_in_hours: Optional[_builtins.int] = None,
3284
+ should_deregister_from_lb: Optional[_builtins.bool] = None,
3285
+ should_revert_to_od: Optional[_builtins.bool] = None,
3286
+ snapshot_should_deallocate: Optional[_builtins.bool] = None,
3287
+ snapshot_ttl_in_hours: Optional[_builtins.int] = None):
3289
3288
  pulumi.set(__self__, "should_terminate_vm", should_terminate_vm)
3290
3289
  if disk_should_deallocate is not None:
3291
3290
  pulumi.set(__self__, "disk_should_deallocate", disk_should_deallocate)
@@ -3308,59 +3307,59 @@ class StatefulNodeAzureDelete(dict):
3308
3307
  if snapshot_ttl_in_hours is not None:
3309
3308
  pulumi.set(__self__, "snapshot_ttl_in_hours", snapshot_ttl_in_hours)
3310
3309
 
3311
- @property
3310
+ @_builtins.property
3312
3311
  @pulumi.getter(name="shouldTerminateVm")
3313
- def should_terminate_vm(self) -> builtins.bool:
3312
+ def should_terminate_vm(self) -> _builtins.bool:
3314
3313
  return pulumi.get(self, "should_terminate_vm")
3315
3314
 
3316
- @property
3315
+ @_builtins.property
3317
3316
  @pulumi.getter(name="diskShouldDeallocate")
3318
- def disk_should_deallocate(self) -> Optional[builtins.bool]:
3317
+ def disk_should_deallocate(self) -> Optional[_builtins.bool]:
3319
3318
  return pulumi.get(self, "disk_should_deallocate")
3320
3319
 
3321
- @property
3320
+ @_builtins.property
3322
3321
  @pulumi.getter(name="diskTtlInHours")
3323
- def disk_ttl_in_hours(self) -> Optional[builtins.int]:
3322
+ def disk_ttl_in_hours(self) -> Optional[_builtins.int]:
3324
3323
  return pulumi.get(self, "disk_ttl_in_hours")
3325
3324
 
3326
- @property
3325
+ @_builtins.property
3327
3326
  @pulumi.getter(name="networkShouldDeallocate")
3328
- def network_should_deallocate(self) -> Optional[builtins.bool]:
3327
+ def network_should_deallocate(self) -> Optional[_builtins.bool]:
3329
3328
  return pulumi.get(self, "network_should_deallocate")
3330
3329
 
3331
- @property
3330
+ @_builtins.property
3332
3331
  @pulumi.getter(name="networkTtlInHours")
3333
- def network_ttl_in_hours(self) -> Optional[builtins.int]:
3332
+ def network_ttl_in_hours(self) -> Optional[_builtins.int]:
3334
3333
  return pulumi.get(self, "network_ttl_in_hours")
3335
3334
 
3336
- @property
3335
+ @_builtins.property
3337
3336
  @pulumi.getter(name="publicIpShouldDeallocate")
3338
- def public_ip_should_deallocate(self) -> Optional[builtins.bool]:
3337
+ def public_ip_should_deallocate(self) -> Optional[_builtins.bool]:
3339
3338
  return pulumi.get(self, "public_ip_should_deallocate")
3340
3339
 
3341
- @property
3340
+ @_builtins.property
3342
3341
  @pulumi.getter(name="publicIpTtlInHours")
3343
- def public_ip_ttl_in_hours(self) -> Optional[builtins.int]:
3342
+ def public_ip_ttl_in_hours(self) -> Optional[_builtins.int]:
3344
3343
  return pulumi.get(self, "public_ip_ttl_in_hours")
3345
3344
 
3346
- @property
3345
+ @_builtins.property
3347
3346
  @pulumi.getter(name="shouldDeregisterFromLb")
3348
- def should_deregister_from_lb(self) -> Optional[builtins.bool]:
3347
+ def should_deregister_from_lb(self) -> Optional[_builtins.bool]:
3349
3348
  return pulumi.get(self, "should_deregister_from_lb")
3350
3349
 
3351
- @property
3350
+ @_builtins.property
3352
3351
  @pulumi.getter(name="shouldRevertToOd")
3353
- def should_revert_to_od(self) -> Optional[builtins.bool]:
3352
+ def should_revert_to_od(self) -> Optional[_builtins.bool]:
3354
3353
  return pulumi.get(self, "should_revert_to_od")
3355
3354
 
3356
- @property
3355
+ @_builtins.property
3357
3356
  @pulumi.getter(name="snapshotShouldDeallocate")
3358
- def snapshot_should_deallocate(self) -> Optional[builtins.bool]:
3357
+ def snapshot_should_deallocate(self) -> Optional[_builtins.bool]:
3359
3358
  return pulumi.get(self, "snapshot_should_deallocate")
3360
3359
 
3361
- @property
3360
+ @_builtins.property
3362
3361
  @pulumi.getter(name="snapshotTtlInHours")
3363
- def snapshot_ttl_in_hours(self) -> Optional[builtins.int]:
3362
+ def snapshot_ttl_in_hours(self) -> Optional[_builtins.int]:
3364
3363
  return pulumi.get(self, "snapshot_ttl_in_hours")
3365
3364
 
3366
3365
 
@@ -3390,34 +3389,34 @@ class StatefulNodeAzureDetachDataDisk(dict):
3390
3389
  return super().get(key, default)
3391
3390
 
3392
3391
  def __init__(__self__, *,
3393
- data_disk_name: builtins.str,
3394
- data_disk_resource_group_name: builtins.str,
3395
- should_deallocate: builtins.bool,
3396
- ttl_in_hours: Optional[builtins.int] = None):
3392
+ data_disk_name: _builtins.str,
3393
+ data_disk_resource_group_name: _builtins.str,
3394
+ should_deallocate: _builtins.bool,
3395
+ ttl_in_hours: Optional[_builtins.int] = None):
3397
3396
  pulumi.set(__self__, "data_disk_name", data_disk_name)
3398
3397
  pulumi.set(__self__, "data_disk_resource_group_name", data_disk_resource_group_name)
3399
3398
  pulumi.set(__self__, "should_deallocate", should_deallocate)
3400
3399
  if ttl_in_hours is not None:
3401
3400
  pulumi.set(__self__, "ttl_in_hours", ttl_in_hours)
3402
3401
 
3403
- @property
3402
+ @_builtins.property
3404
3403
  @pulumi.getter(name="dataDiskName")
3405
- def data_disk_name(self) -> builtins.str:
3404
+ def data_disk_name(self) -> _builtins.str:
3406
3405
  return pulumi.get(self, "data_disk_name")
3407
3406
 
3408
- @property
3407
+ @_builtins.property
3409
3408
  @pulumi.getter(name="dataDiskResourceGroupName")
3410
- def data_disk_resource_group_name(self) -> builtins.str:
3409
+ def data_disk_resource_group_name(self) -> _builtins.str:
3411
3410
  return pulumi.get(self, "data_disk_resource_group_name")
3412
3411
 
3413
- @property
3412
+ @_builtins.property
3414
3413
  @pulumi.getter(name="shouldDeallocate")
3415
- def should_deallocate(self) -> builtins.bool:
3414
+ def should_deallocate(self) -> _builtins.bool:
3416
3415
  return pulumi.get(self, "should_deallocate")
3417
3416
 
3418
- @property
3417
+ @_builtins.property
3419
3418
  @pulumi.getter(name="ttlInHours")
3420
- def ttl_in_hours(self) -> Optional[builtins.int]:
3419
+ def ttl_in_hours(self) -> Optional[_builtins.int]:
3421
3420
  return pulumi.get(self, "ttl_in_hours")
3422
3421
 
3423
3422
 
@@ -3447,13 +3446,13 @@ class StatefulNodeAzureExtension(dict):
3447
3446
  return super().get(key, default)
3448
3447
 
3449
3448
  def __init__(__self__, *,
3450
- api_version: builtins.str,
3451
- minor_version_auto_upgrade: builtins.bool,
3452
- name: builtins.str,
3453
- publisher: builtins.str,
3454
- type: builtins.str,
3455
- protected_settings: Optional[Mapping[str, builtins.str]] = None,
3456
- public_settings: Optional[Mapping[str, builtins.str]] = None):
3449
+ api_version: _builtins.str,
3450
+ minor_version_auto_upgrade: _builtins.bool,
3451
+ name: _builtins.str,
3452
+ publisher: _builtins.str,
3453
+ type: _builtins.str,
3454
+ protected_settings: Optional[Mapping[str, _builtins.str]] = None,
3455
+ public_settings: Optional[Mapping[str, _builtins.str]] = None):
3457
3456
  pulumi.set(__self__, "api_version", api_version)
3458
3457
  pulumi.set(__self__, "minor_version_auto_upgrade", minor_version_auto_upgrade)
3459
3458
  pulumi.set(__self__, "name", name)
@@ -3464,39 +3463,39 @@ class StatefulNodeAzureExtension(dict):
3464
3463
  if public_settings is not None:
3465
3464
  pulumi.set(__self__, "public_settings", public_settings)
3466
3465
 
3467
- @property
3466
+ @_builtins.property
3468
3467
  @pulumi.getter(name="apiVersion")
3469
- def api_version(self) -> builtins.str:
3468
+ def api_version(self) -> _builtins.str:
3470
3469
  return pulumi.get(self, "api_version")
3471
3470
 
3472
- @property
3471
+ @_builtins.property
3473
3472
  @pulumi.getter(name="minorVersionAutoUpgrade")
3474
- def minor_version_auto_upgrade(self) -> builtins.bool:
3473
+ def minor_version_auto_upgrade(self) -> _builtins.bool:
3475
3474
  return pulumi.get(self, "minor_version_auto_upgrade")
3476
3475
 
3477
- @property
3476
+ @_builtins.property
3478
3477
  @pulumi.getter
3479
- def name(self) -> builtins.str:
3478
+ def name(self) -> _builtins.str:
3480
3479
  return pulumi.get(self, "name")
3481
3480
 
3482
- @property
3481
+ @_builtins.property
3483
3482
  @pulumi.getter
3484
- def publisher(self) -> builtins.str:
3483
+ def publisher(self) -> _builtins.str:
3485
3484
  return pulumi.get(self, "publisher")
3486
3485
 
3487
- @property
3486
+ @_builtins.property
3488
3487
  @pulumi.getter
3489
- def type(self) -> builtins.str:
3488
+ def type(self) -> _builtins.str:
3490
3489
  return pulumi.get(self, "type")
3491
3490
 
3492
- @property
3491
+ @_builtins.property
3493
3492
  @pulumi.getter(name="protectedSettings")
3494
- def protected_settings(self) -> Optional[Mapping[str, builtins.str]]:
3493
+ def protected_settings(self) -> Optional[Mapping[str, _builtins.str]]:
3495
3494
  return pulumi.get(self, "protected_settings")
3496
3495
 
3497
- @property
3496
+ @_builtins.property
3498
3497
  @pulumi.getter(name="publicSettings")
3499
- def public_settings(self) -> Optional[Mapping[str, builtins.str]]:
3498
+ def public_settings(self) -> Optional[Mapping[str, _builtins.str]]:
3500
3499
  return pulumi.get(self, "public_settings")
3501
3500
 
3502
3501
 
@@ -3526,10 +3525,10 @@ class StatefulNodeAzureHealth(dict):
3526
3525
  return super().get(key, default)
3527
3526
 
3528
3527
  def __init__(__self__, *,
3529
- auto_healing: builtins.bool,
3530
- health_check_types: Sequence[builtins.str],
3531
- grace_period: Optional[builtins.int] = None,
3532
- unhealthy_duration: Optional[builtins.int] = None):
3528
+ auto_healing: _builtins.bool,
3529
+ health_check_types: Sequence[_builtins.str],
3530
+ grace_period: Optional[_builtins.int] = None,
3531
+ unhealthy_duration: Optional[_builtins.int] = None):
3533
3532
  pulumi.set(__self__, "auto_healing", auto_healing)
3534
3533
  pulumi.set(__self__, "health_check_types", health_check_types)
3535
3534
  if grace_period is not None:
@@ -3537,24 +3536,24 @@ class StatefulNodeAzureHealth(dict):
3537
3536
  if unhealthy_duration is not None:
3538
3537
  pulumi.set(__self__, "unhealthy_duration", unhealthy_duration)
3539
3538
 
3540
- @property
3539
+ @_builtins.property
3541
3540
  @pulumi.getter(name="autoHealing")
3542
- def auto_healing(self) -> builtins.bool:
3541
+ def auto_healing(self) -> _builtins.bool:
3543
3542
  return pulumi.get(self, "auto_healing")
3544
3543
 
3545
- @property
3544
+ @_builtins.property
3546
3545
  @pulumi.getter(name="healthCheckTypes")
3547
- def health_check_types(self) -> Sequence[builtins.str]:
3546
+ def health_check_types(self) -> Sequence[_builtins.str]:
3548
3547
  return pulumi.get(self, "health_check_types")
3549
3548
 
3550
- @property
3549
+ @_builtins.property
3551
3550
  @pulumi.getter(name="gracePeriod")
3552
- def grace_period(self) -> Optional[builtins.int]:
3551
+ def grace_period(self) -> Optional[_builtins.int]:
3553
3552
  return pulumi.get(self, "grace_period")
3554
3553
 
3555
- @property
3554
+ @_builtins.property
3556
3555
  @pulumi.getter(name="unhealthyDuration")
3557
- def unhealthy_duration(self) -> Optional[builtins.int]:
3556
+ def unhealthy_duration(self) -> Optional[_builtins.int]:
3558
3557
  return pulumi.get(self, "unhealthy_duration")
3559
3558
 
3560
3559
 
@@ -3590,17 +3589,17 @@ class StatefulNodeAzureImage(dict):
3590
3589
  if marketplace_images is not None:
3591
3590
  pulumi.set(__self__, "marketplace_images", marketplace_images)
3592
3591
 
3593
- @property
3592
+ @_builtins.property
3594
3593
  @pulumi.getter(name="customImages")
3595
3594
  def custom_images(self) -> Optional[Sequence['outputs.StatefulNodeAzureImageCustomImage']]:
3596
3595
  return pulumi.get(self, "custom_images")
3597
3596
 
3598
- @property
3597
+ @_builtins.property
3599
3598
  @pulumi.getter
3600
3599
  def galleries(self) -> Optional[Sequence['outputs.StatefulNodeAzureImageGallery']]:
3601
3600
  return pulumi.get(self, "galleries")
3602
3601
 
3603
- @property
3602
+ @_builtins.property
3604
3603
  @pulumi.getter(name="marketplaceImages")
3605
3604
  def marketplace_images(self) -> Optional[Sequence['outputs.StatefulNodeAzureImageMarketplaceImage']]:
3606
3605
  return pulumi.get(self, "marketplace_images")
@@ -3626,19 +3625,19 @@ class StatefulNodeAzureImageCustomImage(dict):
3626
3625
  return super().get(key, default)
3627
3626
 
3628
3627
  def __init__(__self__, *,
3629
- custom_image_resource_group_name: builtins.str,
3630
- name: builtins.str):
3628
+ custom_image_resource_group_name: _builtins.str,
3629
+ name: _builtins.str):
3631
3630
  pulumi.set(__self__, "custom_image_resource_group_name", custom_image_resource_group_name)
3632
3631
  pulumi.set(__self__, "name", name)
3633
3632
 
3634
- @property
3633
+ @_builtins.property
3635
3634
  @pulumi.getter(name="customImageResourceGroupName")
3636
- def custom_image_resource_group_name(self) -> builtins.str:
3635
+ def custom_image_resource_group_name(self) -> _builtins.str:
3637
3636
  return pulumi.get(self, "custom_image_resource_group_name")
3638
3637
 
3639
- @property
3638
+ @_builtins.property
3640
3639
  @pulumi.getter
3641
- def name(self) -> builtins.str:
3640
+ def name(self) -> _builtins.str:
3642
3641
  return pulumi.get(self, "name")
3643
3642
 
3644
3643
 
@@ -3670,11 +3669,11 @@ class StatefulNodeAzureImageGallery(dict):
3670
3669
  return super().get(key, default)
3671
3670
 
3672
3671
  def __init__(__self__, *,
3673
- gallery_name: builtins.str,
3674
- gallery_resource_group_name: builtins.str,
3675
- image_name: builtins.str,
3676
- version_name: builtins.str,
3677
- spot_account_id: Optional[builtins.str] = None):
3672
+ gallery_name: _builtins.str,
3673
+ gallery_resource_group_name: _builtins.str,
3674
+ image_name: _builtins.str,
3675
+ version_name: _builtins.str,
3676
+ spot_account_id: Optional[_builtins.str] = None):
3678
3677
  pulumi.set(__self__, "gallery_name", gallery_name)
3679
3678
  pulumi.set(__self__, "gallery_resource_group_name", gallery_resource_group_name)
3680
3679
  pulumi.set(__self__, "image_name", image_name)
@@ -3682,62 +3681,62 @@ class StatefulNodeAzureImageGallery(dict):
3682
3681
  if spot_account_id is not None:
3683
3682
  pulumi.set(__self__, "spot_account_id", spot_account_id)
3684
3683
 
3685
- @property
3684
+ @_builtins.property
3686
3685
  @pulumi.getter(name="galleryName")
3687
- def gallery_name(self) -> builtins.str:
3686
+ def gallery_name(self) -> _builtins.str:
3688
3687
  return pulumi.get(self, "gallery_name")
3689
3688
 
3690
- @property
3689
+ @_builtins.property
3691
3690
  @pulumi.getter(name="galleryResourceGroupName")
3692
- def gallery_resource_group_name(self) -> builtins.str:
3691
+ def gallery_resource_group_name(self) -> _builtins.str:
3693
3692
  return pulumi.get(self, "gallery_resource_group_name")
3694
3693
 
3695
- @property
3694
+ @_builtins.property
3696
3695
  @pulumi.getter(name="imageName")
3697
- def image_name(self) -> builtins.str:
3696
+ def image_name(self) -> _builtins.str:
3698
3697
  return pulumi.get(self, "image_name")
3699
3698
 
3700
- @property
3699
+ @_builtins.property
3701
3700
  @pulumi.getter(name="versionName")
3702
- def version_name(self) -> builtins.str:
3701
+ def version_name(self) -> _builtins.str:
3703
3702
  return pulumi.get(self, "version_name")
3704
3703
 
3705
- @property
3704
+ @_builtins.property
3706
3705
  @pulumi.getter(name="spotAccountId")
3707
- def spot_account_id(self) -> Optional[builtins.str]:
3706
+ def spot_account_id(self) -> Optional[_builtins.str]:
3708
3707
  return pulumi.get(self, "spot_account_id")
3709
3708
 
3710
3709
 
3711
3710
  @pulumi.output_type
3712
3711
  class StatefulNodeAzureImageMarketplaceImage(dict):
3713
3712
  def __init__(__self__, *,
3714
- offer: builtins.str,
3715
- publisher: builtins.str,
3716
- sku: builtins.str,
3717
- version: builtins.str):
3713
+ offer: _builtins.str,
3714
+ publisher: _builtins.str,
3715
+ sku: _builtins.str,
3716
+ version: _builtins.str):
3718
3717
  pulumi.set(__self__, "offer", offer)
3719
3718
  pulumi.set(__self__, "publisher", publisher)
3720
3719
  pulumi.set(__self__, "sku", sku)
3721
3720
  pulumi.set(__self__, "version", version)
3722
3721
 
3723
- @property
3722
+ @_builtins.property
3724
3723
  @pulumi.getter
3725
- def offer(self) -> builtins.str:
3724
+ def offer(self) -> _builtins.str:
3726
3725
  return pulumi.get(self, "offer")
3727
3726
 
3728
- @property
3727
+ @_builtins.property
3729
3728
  @pulumi.getter
3730
- def publisher(self) -> builtins.str:
3729
+ def publisher(self) -> _builtins.str:
3731
3730
  return pulumi.get(self, "publisher")
3732
3731
 
3733
- @property
3732
+ @_builtins.property
3734
3733
  @pulumi.getter
3735
- def sku(self) -> builtins.str:
3734
+ def sku(self) -> _builtins.str:
3736
3735
  return pulumi.get(self, "sku")
3737
3736
 
3738
- @property
3737
+ @_builtins.property
3739
3738
  @pulumi.getter
3740
- def version(self) -> builtins.str:
3739
+ def version(self) -> _builtins.str:
3741
3740
  return pulumi.get(self, "version")
3742
3741
 
3743
3742
 
@@ -3767,10 +3766,10 @@ class StatefulNodeAzureImportVm(dict):
3767
3766
  return super().get(key, default)
3768
3767
 
3769
3768
  def __init__(__self__, *,
3770
- original_vm_name: builtins.str,
3771
- resource_group_name: builtins.str,
3772
- draining_timeout: Optional[builtins.int] = None,
3773
- resources_retention_time: Optional[builtins.int] = None):
3769
+ original_vm_name: _builtins.str,
3770
+ resource_group_name: _builtins.str,
3771
+ draining_timeout: Optional[_builtins.int] = None,
3772
+ resources_retention_time: Optional[_builtins.int] = None):
3774
3773
  pulumi.set(__self__, "original_vm_name", original_vm_name)
3775
3774
  pulumi.set(__self__, "resource_group_name", resource_group_name)
3776
3775
  if draining_timeout is not None:
@@ -3778,24 +3777,24 @@ class StatefulNodeAzureImportVm(dict):
3778
3777
  if resources_retention_time is not None:
3779
3778
  pulumi.set(__self__, "resources_retention_time", resources_retention_time)
3780
3779
 
3781
- @property
3780
+ @_builtins.property
3782
3781
  @pulumi.getter(name="originalVmName")
3783
- def original_vm_name(self) -> builtins.str:
3782
+ def original_vm_name(self) -> _builtins.str:
3784
3783
  return pulumi.get(self, "original_vm_name")
3785
3784
 
3786
- @property
3785
+ @_builtins.property
3787
3786
  @pulumi.getter(name="resourceGroupName")
3788
- def resource_group_name(self) -> builtins.str:
3787
+ def resource_group_name(self) -> _builtins.str:
3789
3788
  return pulumi.get(self, "resource_group_name")
3790
3789
 
3791
- @property
3790
+ @_builtins.property
3792
3791
  @pulumi.getter(name="drainingTimeout")
3793
- def draining_timeout(self) -> Optional[builtins.int]:
3792
+ def draining_timeout(self) -> Optional[_builtins.int]:
3794
3793
  return pulumi.get(self, "draining_timeout")
3795
3794
 
3796
- @property
3795
+ @_builtins.property
3797
3796
  @pulumi.getter(name="resourcesRetentionTime")
3798
- def resources_retention_time(self) -> Optional[builtins.int]:
3797
+ def resources_retention_time(self) -> Optional[_builtins.int]:
3799
3798
  return pulumi.get(self, "resources_retention_time")
3800
3799
 
3801
3800
 
@@ -3821,11 +3820,11 @@ class StatefulNodeAzureLoadBalancer(dict):
3821
3820
  return super().get(key, default)
3822
3821
 
3823
3822
  def __init__(__self__, *,
3824
- backend_pool_names: Sequence[builtins.str],
3825
- name: builtins.str,
3826
- resource_group_name: builtins.str,
3827
- type: builtins.str,
3828
- sku: Optional[builtins.str] = None):
3823
+ backend_pool_names: Sequence[_builtins.str],
3824
+ name: _builtins.str,
3825
+ resource_group_name: _builtins.str,
3826
+ type: _builtins.str,
3827
+ sku: Optional[_builtins.str] = None):
3829
3828
  pulumi.set(__self__, "backend_pool_names", backend_pool_names)
3830
3829
  pulumi.set(__self__, "name", name)
3831
3830
  pulumi.set(__self__, "resource_group_name", resource_group_name)
@@ -3833,29 +3832,29 @@ class StatefulNodeAzureLoadBalancer(dict):
3833
3832
  if sku is not None:
3834
3833
  pulumi.set(__self__, "sku", sku)
3835
3834
 
3836
- @property
3835
+ @_builtins.property
3837
3836
  @pulumi.getter(name="backendPoolNames")
3838
- def backend_pool_names(self) -> Sequence[builtins.str]:
3837
+ def backend_pool_names(self) -> Sequence[_builtins.str]:
3839
3838
  return pulumi.get(self, "backend_pool_names")
3840
3839
 
3841
- @property
3840
+ @_builtins.property
3842
3841
  @pulumi.getter
3843
- def name(self) -> builtins.str:
3842
+ def name(self) -> _builtins.str:
3844
3843
  return pulumi.get(self, "name")
3845
3844
 
3846
- @property
3845
+ @_builtins.property
3847
3846
  @pulumi.getter(name="resourceGroupName")
3848
- def resource_group_name(self) -> builtins.str:
3847
+ def resource_group_name(self) -> _builtins.str:
3849
3848
  return pulumi.get(self, "resource_group_name")
3850
3849
 
3851
- @property
3850
+ @_builtins.property
3852
3851
  @pulumi.getter
3853
- def type(self) -> builtins.str:
3852
+ def type(self) -> _builtins.str:
3854
3853
  return pulumi.get(self, "type")
3855
3854
 
3856
- @property
3855
+ @_builtins.property
3857
3856
  @pulumi.getter
3858
- def sku(self) -> Optional[builtins.str]:
3857
+ def sku(self) -> Optional[_builtins.str]:
3859
3858
  return pulumi.get(self, "sku")
3860
3859
 
3861
3860
 
@@ -3881,28 +3880,28 @@ class StatefulNodeAzureLogin(dict):
3881
3880
  return super().get(key, default)
3882
3881
 
3883
3882
  def __init__(__self__, *,
3884
- user_name: builtins.str,
3885
- password: Optional[builtins.str] = None,
3886
- ssh_public_key: Optional[builtins.str] = None):
3883
+ user_name: _builtins.str,
3884
+ password: Optional[_builtins.str] = None,
3885
+ ssh_public_key: Optional[_builtins.str] = None):
3887
3886
  pulumi.set(__self__, "user_name", user_name)
3888
3887
  if password is not None:
3889
3888
  pulumi.set(__self__, "password", password)
3890
3889
  if ssh_public_key is not None:
3891
3890
  pulumi.set(__self__, "ssh_public_key", ssh_public_key)
3892
3891
 
3893
- @property
3892
+ @_builtins.property
3894
3893
  @pulumi.getter(name="userName")
3895
- def user_name(self) -> builtins.str:
3894
+ def user_name(self) -> _builtins.str:
3896
3895
  return pulumi.get(self, "user_name")
3897
3896
 
3898
- @property
3897
+ @_builtins.property
3899
3898
  @pulumi.getter
3900
- def password(self) -> Optional[builtins.str]:
3899
+ def password(self) -> Optional[_builtins.str]:
3901
3900
  return pulumi.get(self, "password")
3902
3901
 
3903
- @property
3902
+ @_builtins.property
3904
3903
  @pulumi.getter(name="sshPublicKey")
3905
- def ssh_public_key(self) -> Optional[builtins.str]:
3904
+ def ssh_public_key(self) -> Optional[_builtins.str]:
3906
3905
  return pulumi.get(self, "ssh_public_key")
3907
3906
 
3908
3907
 
@@ -3928,27 +3927,27 @@ class StatefulNodeAzureManagedServiceIdentity(dict):
3928
3927
  return super().get(key, default)
3929
3928
 
3930
3929
  def __init__(__self__, *,
3931
- name: builtins.str,
3932
- resource_group_name: builtins.str,
3933
- subscription_id: Optional[builtins.str] = None):
3930
+ name: _builtins.str,
3931
+ resource_group_name: _builtins.str,
3932
+ subscription_id: Optional[_builtins.str] = None):
3934
3933
  pulumi.set(__self__, "name", name)
3935
3934
  pulumi.set(__self__, "resource_group_name", resource_group_name)
3936
3935
  if subscription_id is not None:
3937
3936
  pulumi.set(__self__, "subscription_id", subscription_id)
3938
3937
 
3939
- @property
3938
+ @_builtins.property
3940
3939
  @pulumi.getter
3941
- def name(self) -> builtins.str:
3940
+ def name(self) -> _builtins.str:
3942
3941
  return pulumi.get(self, "name")
3943
3942
 
3944
- @property
3943
+ @_builtins.property
3945
3944
  @pulumi.getter(name="resourceGroupName")
3946
- def resource_group_name(self) -> builtins.str:
3945
+ def resource_group_name(self) -> _builtins.str:
3947
3946
  return pulumi.get(self, "resource_group_name")
3948
3947
 
3949
- @property
3948
+ @_builtins.property
3950
3949
  @pulumi.getter(name="subscriptionId")
3951
- def subscription_id(self) -> Optional[builtins.str]:
3950
+ def subscription_id(self) -> Optional[_builtins.str]:
3952
3951
  return pulumi.get(self, "subscription_id")
3953
3952
 
3954
3953
 
@@ -3977,25 +3976,25 @@ class StatefulNodeAzureNetwork(dict):
3977
3976
 
3978
3977
  def __init__(__self__, *,
3979
3978
  network_interfaces: Sequence['outputs.StatefulNodeAzureNetworkNetworkInterface'],
3980
- network_resource_group_name: builtins.str,
3981
- virtual_network_name: builtins.str):
3979
+ network_resource_group_name: _builtins.str,
3980
+ virtual_network_name: _builtins.str):
3982
3981
  pulumi.set(__self__, "network_interfaces", network_interfaces)
3983
3982
  pulumi.set(__self__, "network_resource_group_name", network_resource_group_name)
3984
3983
  pulumi.set(__self__, "virtual_network_name", virtual_network_name)
3985
3984
 
3986
- @property
3985
+ @_builtins.property
3987
3986
  @pulumi.getter(name="networkInterfaces")
3988
3987
  def network_interfaces(self) -> Sequence['outputs.StatefulNodeAzureNetworkNetworkInterface']:
3989
3988
  return pulumi.get(self, "network_interfaces")
3990
3989
 
3991
- @property
3990
+ @_builtins.property
3992
3991
  @pulumi.getter(name="networkResourceGroupName")
3993
- def network_resource_group_name(self) -> builtins.str:
3992
+ def network_resource_group_name(self) -> _builtins.str:
3994
3993
  return pulumi.get(self, "network_resource_group_name")
3995
3994
 
3996
- @property
3995
+ @_builtins.property
3997
3996
  @pulumi.getter(name="virtualNetworkName")
3998
- def virtual_network_name(self) -> builtins.str:
3997
+ def virtual_network_name(self) -> _builtins.str:
3999
3998
  return pulumi.get(self, "virtual_network_name")
4000
3999
 
4001
4000
 
@@ -4037,15 +4036,15 @@ class StatefulNodeAzureNetworkNetworkInterface(dict):
4037
4036
  return super().get(key, default)
4038
4037
 
4039
4038
  def __init__(__self__, *,
4040
- is_primary: builtins.bool,
4041
- subnet_name: builtins.str,
4039
+ is_primary: _builtins.bool,
4040
+ subnet_name: _builtins.str,
4042
4041
  additional_ip_configurations: Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfiguration']] = None,
4043
4042
  application_security_groups: Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroup']] = None,
4044
- assign_public_ip: Optional[builtins.bool] = None,
4045
- enable_ip_forwarding: Optional[builtins.bool] = None,
4043
+ assign_public_ip: Optional[_builtins.bool] = None,
4044
+ enable_ip_forwarding: Optional[_builtins.bool] = None,
4046
4045
  network_security_groups: Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroup']] = None,
4047
- private_ip_addresses: Optional[Sequence[builtins.str]] = None,
4048
- public_ip_sku: Optional[builtins.str] = None,
4046
+ private_ip_addresses: Optional[Sequence[_builtins.str]] = None,
4047
+ public_ip_sku: Optional[_builtins.str] = None,
4049
4048
  public_ips: Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterfacePublicIp']] = None):
4050
4049
  pulumi.set(__self__, "is_primary", is_primary)
4051
4050
  pulumi.set(__self__, "subnet_name", subnet_name)
@@ -4066,52 +4065,52 @@ class StatefulNodeAzureNetworkNetworkInterface(dict):
4066
4065
  if public_ips is not None:
4067
4066
  pulumi.set(__self__, "public_ips", public_ips)
4068
4067
 
4069
- @property
4068
+ @_builtins.property
4070
4069
  @pulumi.getter(name="isPrimary")
4071
- def is_primary(self) -> builtins.bool:
4070
+ def is_primary(self) -> _builtins.bool:
4072
4071
  return pulumi.get(self, "is_primary")
4073
4072
 
4074
- @property
4073
+ @_builtins.property
4075
4074
  @pulumi.getter(name="subnetName")
4076
- def subnet_name(self) -> builtins.str:
4075
+ def subnet_name(self) -> _builtins.str:
4077
4076
  return pulumi.get(self, "subnet_name")
4078
4077
 
4079
- @property
4078
+ @_builtins.property
4080
4079
  @pulumi.getter(name="additionalIpConfigurations")
4081
4080
  def additional_ip_configurations(self) -> Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfiguration']]:
4082
4081
  return pulumi.get(self, "additional_ip_configurations")
4083
4082
 
4084
- @property
4083
+ @_builtins.property
4085
4084
  @pulumi.getter(name="applicationSecurityGroups")
4086
4085
  def application_security_groups(self) -> Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroup']]:
4087
4086
  return pulumi.get(self, "application_security_groups")
4088
4087
 
4089
- @property
4088
+ @_builtins.property
4090
4089
  @pulumi.getter(name="assignPublicIp")
4091
- def assign_public_ip(self) -> Optional[builtins.bool]:
4090
+ def assign_public_ip(self) -> Optional[_builtins.bool]:
4092
4091
  return pulumi.get(self, "assign_public_ip")
4093
4092
 
4094
- @property
4093
+ @_builtins.property
4095
4094
  @pulumi.getter(name="enableIpForwarding")
4096
- def enable_ip_forwarding(self) -> Optional[builtins.bool]:
4095
+ def enable_ip_forwarding(self) -> Optional[_builtins.bool]:
4097
4096
  return pulumi.get(self, "enable_ip_forwarding")
4098
4097
 
4099
- @property
4098
+ @_builtins.property
4100
4099
  @pulumi.getter(name="networkSecurityGroups")
4101
4100
  def network_security_groups(self) -> Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroup']]:
4102
4101
  return pulumi.get(self, "network_security_groups")
4103
4102
 
4104
- @property
4103
+ @_builtins.property
4105
4104
  @pulumi.getter(name="privateIpAddresses")
4106
- def private_ip_addresses(self) -> Optional[Sequence[builtins.str]]:
4105
+ def private_ip_addresses(self) -> Optional[Sequence[_builtins.str]]:
4107
4106
  return pulumi.get(self, "private_ip_addresses")
4108
4107
 
4109
- @property
4108
+ @_builtins.property
4110
4109
  @pulumi.getter(name="publicIpSku")
4111
- def public_ip_sku(self) -> Optional[builtins.str]:
4110
+ def public_ip_sku(self) -> Optional[_builtins.str]:
4112
4111
  return pulumi.get(self, "public_ip_sku")
4113
4112
 
4114
- @property
4113
+ @_builtins.property
4115
4114
  @pulumi.getter(name="publicIps")
4116
4115
  def public_ips(self) -> Optional[Sequence['outputs.StatefulNodeAzureNetworkNetworkInterfacePublicIp']]:
4117
4116
  return pulumi.get(self, "public_ips")
@@ -4137,19 +4136,19 @@ class StatefulNodeAzureNetworkNetworkInterfaceAdditionalIpConfiguration(dict):
4137
4136
  return super().get(key, default)
4138
4137
 
4139
4138
  def __init__(__self__, *,
4140
- name: builtins.str,
4141
- private_ip_address_version: builtins.str):
4139
+ name: _builtins.str,
4140
+ private_ip_address_version: _builtins.str):
4142
4141
  pulumi.set(__self__, "name", name)
4143
4142
  pulumi.set(__self__, "private_ip_address_version", private_ip_address_version)
4144
4143
 
4145
- @property
4144
+ @_builtins.property
4146
4145
  @pulumi.getter
4147
- def name(self) -> builtins.str:
4146
+ def name(self) -> _builtins.str:
4148
4147
  return pulumi.get(self, "name")
4149
4148
 
4150
- @property
4149
+ @_builtins.property
4151
4150
  @pulumi.getter(name="privateIpAddressVersion")
4152
- def private_ip_address_version(self) -> builtins.str:
4151
+ def private_ip_address_version(self) -> _builtins.str:
4153
4152
  return pulumi.get(self, "private_ip_address_version")
4154
4153
 
4155
4154
 
@@ -4173,19 +4172,19 @@ class StatefulNodeAzureNetworkNetworkInterfaceApplicationSecurityGroup(dict):
4173
4172
  return super().get(key, default)
4174
4173
 
4175
4174
  def __init__(__self__, *,
4176
- name: builtins.str,
4177
- network_resource_group_name: builtins.str):
4175
+ name: _builtins.str,
4176
+ network_resource_group_name: _builtins.str):
4178
4177
  pulumi.set(__self__, "name", name)
4179
4178
  pulumi.set(__self__, "network_resource_group_name", network_resource_group_name)
4180
4179
 
4181
- @property
4180
+ @_builtins.property
4182
4181
  @pulumi.getter
4183
- def name(self) -> builtins.str:
4182
+ def name(self) -> _builtins.str:
4184
4183
  return pulumi.get(self, "name")
4185
4184
 
4186
- @property
4185
+ @_builtins.property
4187
4186
  @pulumi.getter(name="networkResourceGroupName")
4188
- def network_resource_group_name(self) -> builtins.str:
4187
+ def network_resource_group_name(self) -> _builtins.str:
4189
4188
  return pulumi.get(self, "network_resource_group_name")
4190
4189
 
4191
4190
 
@@ -4209,21 +4208,21 @@ class StatefulNodeAzureNetworkNetworkInterfaceNetworkSecurityGroup(dict):
4209
4208
  return super().get(key, default)
4210
4209
 
4211
4210
  def __init__(__self__, *,
4212
- name: Optional[builtins.str] = None,
4213
- network_resource_group_name: Optional[builtins.str] = None):
4211
+ name: Optional[_builtins.str] = None,
4212
+ network_resource_group_name: Optional[_builtins.str] = None):
4214
4213
  if name is not None:
4215
4214
  pulumi.set(__self__, "name", name)
4216
4215
  if network_resource_group_name is not None:
4217
4216
  pulumi.set(__self__, "network_resource_group_name", network_resource_group_name)
4218
4217
 
4219
- @property
4218
+ @_builtins.property
4220
4219
  @pulumi.getter
4221
- def name(self) -> Optional[builtins.str]:
4220
+ def name(self) -> Optional[_builtins.str]:
4222
4221
  return pulumi.get(self, "name")
4223
4222
 
4224
- @property
4223
+ @_builtins.property
4225
4224
  @pulumi.getter(name="networkResourceGroupName")
4226
- def network_resource_group_name(self) -> Optional[builtins.str]:
4225
+ def network_resource_group_name(self) -> Optional[_builtins.str]:
4227
4226
  return pulumi.get(self, "network_resource_group_name")
4228
4227
 
4229
4228
 
@@ -4247,19 +4246,19 @@ class StatefulNodeAzureNetworkNetworkInterfacePublicIp(dict):
4247
4246
  return super().get(key, default)
4248
4247
 
4249
4248
  def __init__(__self__, *,
4250
- name: builtins.str,
4251
- network_resource_group_name: builtins.str):
4249
+ name: _builtins.str,
4250
+ network_resource_group_name: _builtins.str):
4252
4251
  pulumi.set(__self__, "name", name)
4253
4252
  pulumi.set(__self__, "network_resource_group_name", network_resource_group_name)
4254
4253
 
4255
- @property
4254
+ @_builtins.property
4256
4255
  @pulumi.getter
4257
- def name(self) -> builtins.str:
4256
+ def name(self) -> _builtins.str:
4258
4257
  return pulumi.get(self, "name")
4259
4258
 
4260
- @property
4259
+ @_builtins.property
4261
4260
  @pulumi.getter(name="networkResourceGroupName")
4262
- def network_resource_group_name(self) -> builtins.str:
4261
+ def network_resource_group_name(self) -> _builtins.str:
4263
4262
  return pulumi.get(self, "network_resource_group_name")
4264
4263
 
4265
4264
 
@@ -4283,28 +4282,28 @@ class StatefulNodeAzureOsDisk(dict):
4283
4282
  return super().get(key, default)
4284
4283
 
4285
4284
  def __init__(__self__, *,
4286
- type: builtins.str,
4287
- caching: Optional[builtins.str] = None,
4288
- size_gb: Optional[builtins.int] = None):
4285
+ type: _builtins.str,
4286
+ caching: Optional[_builtins.str] = None,
4287
+ size_gb: Optional[_builtins.int] = None):
4289
4288
  pulumi.set(__self__, "type", type)
4290
4289
  if caching is not None:
4291
4290
  pulumi.set(__self__, "caching", caching)
4292
4291
  if size_gb is not None:
4293
4292
  pulumi.set(__self__, "size_gb", size_gb)
4294
4293
 
4295
- @property
4294
+ @_builtins.property
4296
4295
  @pulumi.getter
4297
- def type(self) -> builtins.str:
4296
+ def type(self) -> _builtins.str:
4298
4297
  return pulumi.get(self, "type")
4299
4298
 
4300
- @property
4299
+ @_builtins.property
4301
4300
  @pulumi.getter
4302
- def caching(self) -> Optional[builtins.str]:
4301
+ def caching(self) -> Optional[_builtins.str]:
4303
4302
  return pulumi.get(self, "caching")
4304
4303
 
4305
- @property
4304
+ @_builtins.property
4306
4305
  @pulumi.getter(name="sizeGb")
4307
- def size_gb(self) -> Optional[builtins.int]:
4306
+ def size_gb(self) -> Optional[_builtins.int]:
4308
4307
  return pulumi.get(self, "size_gb")
4309
4308
 
4310
4309
 
@@ -4328,19 +4327,19 @@ class StatefulNodeAzureProximityPlacementGroup(dict):
4328
4327
  return super().get(key, default)
4329
4328
 
4330
4329
  def __init__(__self__, *,
4331
- name: builtins.str,
4332
- resource_group_name: builtins.str):
4330
+ name: _builtins.str,
4331
+ resource_group_name: _builtins.str):
4333
4332
  pulumi.set(__self__, "name", name)
4334
4333
  pulumi.set(__self__, "resource_group_name", resource_group_name)
4335
4334
 
4336
- @property
4335
+ @_builtins.property
4337
4336
  @pulumi.getter
4338
- def name(self) -> builtins.str:
4337
+ def name(self) -> _builtins.str:
4339
4338
  return pulumi.get(self, "name")
4340
4339
 
4341
- @property
4340
+ @_builtins.property
4342
4341
  @pulumi.getter(name="resourceGroupName")
4343
- def resource_group_name(self) -> builtins.str:
4342
+ def resource_group_name(self) -> _builtins.str:
4344
4343
  return pulumi.get(self, "resource_group_name")
4345
4344
 
4346
4345
 
@@ -4366,26 +4365,26 @@ class StatefulNodeAzureSchedulingTask(dict):
4366
4365
  return super().get(key, default)
4367
4366
 
4368
4367
  def __init__(__self__, *,
4369
- cron_expression: builtins.str,
4370
- is_enabled: builtins.bool,
4371
- type: builtins.str):
4368
+ cron_expression: _builtins.str,
4369
+ is_enabled: _builtins.bool,
4370
+ type: _builtins.str):
4372
4371
  pulumi.set(__self__, "cron_expression", cron_expression)
4373
4372
  pulumi.set(__self__, "is_enabled", is_enabled)
4374
4373
  pulumi.set(__self__, "type", type)
4375
4374
 
4376
- @property
4375
+ @_builtins.property
4377
4376
  @pulumi.getter(name="cronExpression")
4378
- def cron_expression(self) -> builtins.str:
4377
+ def cron_expression(self) -> _builtins.str:
4379
4378
  return pulumi.get(self, "cron_expression")
4380
4379
 
4381
- @property
4380
+ @_builtins.property
4382
4381
  @pulumi.getter(name="isEnabled")
4383
- def is_enabled(self) -> builtins.bool:
4382
+ def is_enabled(self) -> _builtins.bool:
4384
4383
  return pulumi.get(self, "is_enabled")
4385
4384
 
4386
- @property
4385
+ @_builtins.property
4387
4386
  @pulumi.getter
4388
- def type(self) -> builtins.str:
4387
+ def type(self) -> _builtins.str:
4389
4388
  return pulumi.get(self, "type")
4390
4389
 
4391
4390
 
@@ -4416,12 +4415,12 @@ class StatefulNodeAzureSecret(dict):
4416
4415
  pulumi.set(__self__, "source_vaults", source_vaults)
4417
4416
  pulumi.set(__self__, "vault_certificates", vault_certificates)
4418
4417
 
4419
- @property
4418
+ @_builtins.property
4420
4419
  @pulumi.getter(name="sourceVaults")
4421
4420
  def source_vaults(self) -> Sequence['outputs.StatefulNodeAzureSecretSourceVault']:
4422
4421
  return pulumi.get(self, "source_vaults")
4423
4422
 
4424
- @property
4423
+ @_builtins.property
4425
4424
  @pulumi.getter(name="vaultCertificates")
4426
4425
  def vault_certificates(self) -> Sequence['outputs.StatefulNodeAzureSecretVaultCertificate']:
4427
4426
  return pulumi.get(self, "vault_certificates")
@@ -4447,19 +4446,19 @@ class StatefulNodeAzureSecretSourceVault(dict):
4447
4446
  return super().get(key, default)
4448
4447
 
4449
4448
  def __init__(__self__, *,
4450
- name: builtins.str,
4451
- resource_group_name: builtins.str):
4449
+ name: _builtins.str,
4450
+ resource_group_name: _builtins.str):
4452
4451
  pulumi.set(__self__, "name", name)
4453
4452
  pulumi.set(__self__, "resource_group_name", resource_group_name)
4454
4453
 
4455
- @property
4454
+ @_builtins.property
4456
4455
  @pulumi.getter
4457
- def name(self) -> builtins.str:
4456
+ def name(self) -> _builtins.str:
4458
4457
  return pulumi.get(self, "name")
4459
4458
 
4460
- @property
4459
+ @_builtins.property
4461
4460
  @pulumi.getter(name="resourceGroupName")
4462
- def resource_group_name(self) -> builtins.str:
4461
+ def resource_group_name(self) -> _builtins.str:
4463
4462
  return pulumi.get(self, "resource_group_name")
4464
4463
 
4465
4464
 
@@ -4485,21 +4484,21 @@ class StatefulNodeAzureSecretVaultCertificate(dict):
4485
4484
  return super().get(key, default)
4486
4485
 
4487
4486
  def __init__(__self__, *,
4488
- certificate_store: Optional[builtins.str] = None,
4489
- certificate_url: Optional[builtins.str] = None):
4487
+ certificate_store: Optional[_builtins.str] = None,
4488
+ certificate_url: Optional[_builtins.str] = None):
4490
4489
  if certificate_store is not None:
4491
4490
  pulumi.set(__self__, "certificate_store", certificate_store)
4492
4491
  if certificate_url is not None:
4493
4492
  pulumi.set(__self__, "certificate_url", certificate_url)
4494
4493
 
4495
- @property
4494
+ @_builtins.property
4496
4495
  @pulumi.getter(name="certificateStore")
4497
- def certificate_store(self) -> Optional[builtins.str]:
4496
+ def certificate_store(self) -> Optional[_builtins.str]:
4498
4497
  return pulumi.get(self, "certificate_store")
4499
4498
 
4500
- @property
4499
+ @_builtins.property
4501
4500
  @pulumi.getter(name="certificateUrl")
4502
- def certificate_url(self) -> Optional[builtins.str]:
4501
+ def certificate_url(self) -> Optional[_builtins.str]:
4503
4502
  return pulumi.get(self, "certificate_url")
4504
4503
 
4505
4504
 
@@ -4531,11 +4530,11 @@ class StatefulNodeAzureSecurity(dict):
4531
4530
  return super().get(key, default)
4532
4531
 
4533
4532
  def __init__(__self__, *,
4534
- confidential_os_disk_encryption: Optional[builtins.str] = None,
4535
- encryption_at_host: Optional[builtins.bool] = None,
4536
- secure_boot_enabled: Optional[builtins.bool] = None,
4537
- security_type: Optional[builtins.str] = None,
4538
- vtpm_enabled: Optional[builtins.bool] = None):
4533
+ confidential_os_disk_encryption: Optional[_builtins.str] = None,
4534
+ encryption_at_host: Optional[_builtins.bool] = None,
4535
+ secure_boot_enabled: Optional[_builtins.bool] = None,
4536
+ security_type: Optional[_builtins.str] = None,
4537
+ vtpm_enabled: Optional[_builtins.bool] = None):
4539
4538
  if confidential_os_disk_encryption is not None:
4540
4539
  pulumi.set(__self__, "confidential_os_disk_encryption", confidential_os_disk_encryption)
4541
4540
  if encryption_at_host is not None:
@@ -4547,48 +4546,48 @@ class StatefulNodeAzureSecurity(dict):
4547
4546
  if vtpm_enabled is not None:
4548
4547
  pulumi.set(__self__, "vtpm_enabled", vtpm_enabled)
4549
4548
 
4550
- @property
4549
+ @_builtins.property
4551
4550
  @pulumi.getter(name="confidentialOsDiskEncryption")
4552
- def confidential_os_disk_encryption(self) -> Optional[builtins.str]:
4551
+ def confidential_os_disk_encryption(self) -> Optional[_builtins.str]:
4553
4552
  return pulumi.get(self, "confidential_os_disk_encryption")
4554
4553
 
4555
- @property
4554
+ @_builtins.property
4556
4555
  @pulumi.getter(name="encryptionAtHost")
4557
- def encryption_at_host(self) -> Optional[builtins.bool]:
4556
+ def encryption_at_host(self) -> Optional[_builtins.bool]:
4558
4557
  return pulumi.get(self, "encryption_at_host")
4559
4558
 
4560
- @property
4559
+ @_builtins.property
4561
4560
  @pulumi.getter(name="secureBootEnabled")
4562
- def secure_boot_enabled(self) -> Optional[builtins.bool]:
4561
+ def secure_boot_enabled(self) -> Optional[_builtins.bool]:
4563
4562
  return pulumi.get(self, "secure_boot_enabled")
4564
4563
 
4565
- @property
4564
+ @_builtins.property
4566
4565
  @pulumi.getter(name="securityType")
4567
- def security_type(self) -> Optional[builtins.str]:
4566
+ def security_type(self) -> Optional[_builtins.str]:
4568
4567
  return pulumi.get(self, "security_type")
4569
4568
 
4570
- @property
4569
+ @_builtins.property
4571
4570
  @pulumi.getter(name="vtpmEnabled")
4572
- def vtpm_enabled(self) -> Optional[builtins.bool]:
4571
+ def vtpm_enabled(self) -> Optional[_builtins.bool]:
4573
4572
  return pulumi.get(self, "vtpm_enabled")
4574
4573
 
4575
4574
 
4576
4575
  @pulumi.output_type
4577
4576
  class StatefulNodeAzureSignal(dict):
4578
4577
  def __init__(__self__, *,
4579
- timeout: builtins.int,
4580
- type: builtins.str):
4578
+ timeout: _builtins.int,
4579
+ type: _builtins.str):
4581
4580
  pulumi.set(__self__, "timeout", timeout)
4582
4581
  pulumi.set(__self__, "type", type)
4583
4582
 
4584
- @property
4583
+ @_builtins.property
4585
4584
  @pulumi.getter
4586
- def timeout(self) -> builtins.int:
4585
+ def timeout(self) -> _builtins.int:
4587
4586
  return pulumi.get(self, "timeout")
4588
4587
 
4589
- @property
4588
+ @_builtins.property
4590
4589
  @pulumi.getter
4591
- def type(self) -> builtins.str:
4590
+ def type(self) -> _builtins.str:
4592
4591
  return pulumi.get(self, "type")
4593
4592
 
4594
4593
 
@@ -4628,15 +4627,15 @@ class StatefulNodeAzureStrategy(dict):
4628
4627
  return super().get(key, default)
4629
4628
 
4630
4629
  def __init__(__self__, *,
4631
- fallback_to_on_demand: builtins.bool,
4632
- availability_vs_cost: Optional[builtins.int] = None,
4630
+ fallback_to_on_demand: _builtins.bool,
4631
+ availability_vs_cost: Optional[_builtins.int] = None,
4633
4632
  capacity_reservations: Optional[Sequence['outputs.StatefulNodeAzureStrategyCapacityReservation']] = None,
4634
- draining_timeout: Optional[builtins.int] = None,
4635
- od_windows: Optional[Sequence[builtins.str]] = None,
4636
- optimization_windows: Optional[Sequence[builtins.str]] = None,
4637
- preferred_life_cycle: Optional[builtins.str] = None,
4633
+ draining_timeout: Optional[_builtins.int] = None,
4634
+ od_windows: Optional[Sequence[_builtins.str]] = None,
4635
+ optimization_windows: Optional[Sequence[_builtins.str]] = None,
4636
+ preferred_life_cycle: Optional[_builtins.str] = None,
4638
4637
  revert_to_spot: Optional['outputs.StatefulNodeAzureStrategyRevertToSpot'] = None,
4639
- vm_admins: Optional[Sequence[builtins.str]] = None):
4638
+ vm_admins: Optional[Sequence[_builtins.str]] = None):
4640
4639
  pulumi.set(__self__, "fallback_to_on_demand", fallback_to_on_demand)
4641
4640
  if availability_vs_cost is not None:
4642
4641
  pulumi.set(__self__, "availability_vs_cost", availability_vs_cost)
@@ -4655,49 +4654,49 @@ class StatefulNodeAzureStrategy(dict):
4655
4654
  if vm_admins is not None:
4656
4655
  pulumi.set(__self__, "vm_admins", vm_admins)
4657
4656
 
4658
- @property
4657
+ @_builtins.property
4659
4658
  @pulumi.getter(name="fallbackToOnDemand")
4660
- def fallback_to_on_demand(self) -> builtins.bool:
4659
+ def fallback_to_on_demand(self) -> _builtins.bool:
4661
4660
  return pulumi.get(self, "fallback_to_on_demand")
4662
4661
 
4663
- @property
4662
+ @_builtins.property
4664
4663
  @pulumi.getter(name="availabilityVsCost")
4665
- def availability_vs_cost(self) -> Optional[builtins.int]:
4664
+ def availability_vs_cost(self) -> Optional[_builtins.int]:
4666
4665
  return pulumi.get(self, "availability_vs_cost")
4667
4666
 
4668
- @property
4667
+ @_builtins.property
4669
4668
  @pulumi.getter(name="capacityReservations")
4670
4669
  def capacity_reservations(self) -> Optional[Sequence['outputs.StatefulNodeAzureStrategyCapacityReservation']]:
4671
4670
  return pulumi.get(self, "capacity_reservations")
4672
4671
 
4673
- @property
4672
+ @_builtins.property
4674
4673
  @pulumi.getter(name="drainingTimeout")
4675
- def draining_timeout(self) -> Optional[builtins.int]:
4674
+ def draining_timeout(self) -> Optional[_builtins.int]:
4676
4675
  return pulumi.get(self, "draining_timeout")
4677
4676
 
4678
- @property
4677
+ @_builtins.property
4679
4678
  @pulumi.getter(name="odWindows")
4680
- def od_windows(self) -> Optional[Sequence[builtins.str]]:
4679
+ def od_windows(self) -> Optional[Sequence[_builtins.str]]:
4681
4680
  return pulumi.get(self, "od_windows")
4682
4681
 
4683
- @property
4682
+ @_builtins.property
4684
4683
  @pulumi.getter(name="optimizationWindows")
4685
- def optimization_windows(self) -> Optional[Sequence[builtins.str]]:
4684
+ def optimization_windows(self) -> Optional[Sequence[_builtins.str]]:
4686
4685
  return pulumi.get(self, "optimization_windows")
4687
4686
 
4688
- @property
4687
+ @_builtins.property
4689
4688
  @pulumi.getter(name="preferredLifeCycle")
4690
- def preferred_life_cycle(self) -> Optional[builtins.str]:
4689
+ def preferred_life_cycle(self) -> Optional[_builtins.str]:
4691
4690
  return pulumi.get(self, "preferred_life_cycle")
4692
4691
 
4693
- @property
4692
+ @_builtins.property
4694
4693
  @pulumi.getter(name="revertToSpot")
4695
4694
  def revert_to_spot(self) -> Optional['outputs.StatefulNodeAzureStrategyRevertToSpot']:
4696
4695
  return pulumi.get(self, "revert_to_spot")
4697
4696
 
4698
- @property
4697
+ @_builtins.property
4699
4698
  @pulumi.getter(name="vmAdmins")
4700
- def vm_admins(self) -> Optional[Sequence[builtins.str]]:
4699
+ def vm_admins(self) -> Optional[Sequence[_builtins.str]]:
4701
4700
  return pulumi.get(self, "vm_admins")
4702
4701
 
4703
4702
 
@@ -4725,25 +4724,25 @@ class StatefulNodeAzureStrategyCapacityReservation(dict):
4725
4724
  return super().get(key, default)
4726
4725
 
4727
4726
  def __init__(__self__, *,
4728
- should_utilize: builtins.bool,
4729
- utilization_strategy: builtins.str,
4727
+ should_utilize: _builtins.bool,
4728
+ utilization_strategy: _builtins.str,
4730
4729
  capacity_reservation_groups: Optional[Sequence['outputs.StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroup']] = None):
4731
4730
  pulumi.set(__self__, "should_utilize", should_utilize)
4732
4731
  pulumi.set(__self__, "utilization_strategy", utilization_strategy)
4733
4732
  if capacity_reservation_groups is not None:
4734
4733
  pulumi.set(__self__, "capacity_reservation_groups", capacity_reservation_groups)
4735
4734
 
4736
- @property
4735
+ @_builtins.property
4737
4736
  @pulumi.getter(name="shouldUtilize")
4738
- def should_utilize(self) -> builtins.bool:
4737
+ def should_utilize(self) -> _builtins.bool:
4739
4738
  return pulumi.get(self, "should_utilize")
4740
4739
 
4741
- @property
4740
+ @_builtins.property
4742
4741
  @pulumi.getter(name="utilizationStrategy")
4743
- def utilization_strategy(self) -> builtins.str:
4742
+ def utilization_strategy(self) -> _builtins.str:
4744
4743
  return pulumi.get(self, "utilization_strategy")
4745
4744
 
4746
- @property
4745
+ @_builtins.property
4747
4746
  @pulumi.getter(name="capacityReservationGroups")
4748
4747
  def capacity_reservation_groups(self) -> Optional[Sequence['outputs.StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroup']]:
4749
4748
  return pulumi.get(self, "capacity_reservation_groups")
@@ -4773,27 +4772,27 @@ class StatefulNodeAzureStrategyCapacityReservationCapacityReservationGroup(dict)
4773
4772
  return super().get(key, default)
4774
4773
 
4775
4774
  def __init__(__self__, *,
4776
- crg_name: builtins.str,
4777
- crg_resource_group_name: builtins.str,
4778
- crg_should_prioritize: Optional[builtins.bool] = None):
4775
+ crg_name: _builtins.str,
4776
+ crg_resource_group_name: _builtins.str,
4777
+ crg_should_prioritize: Optional[_builtins.bool] = None):
4779
4778
  pulumi.set(__self__, "crg_name", crg_name)
4780
4779
  pulumi.set(__self__, "crg_resource_group_name", crg_resource_group_name)
4781
4780
  if crg_should_prioritize is not None:
4782
4781
  pulumi.set(__self__, "crg_should_prioritize", crg_should_prioritize)
4783
4782
 
4784
- @property
4783
+ @_builtins.property
4785
4784
  @pulumi.getter(name="crgName")
4786
- def crg_name(self) -> builtins.str:
4785
+ def crg_name(self) -> _builtins.str:
4787
4786
  return pulumi.get(self, "crg_name")
4788
4787
 
4789
- @property
4788
+ @_builtins.property
4790
4789
  @pulumi.getter(name="crgResourceGroupName")
4791
- def crg_resource_group_name(self) -> builtins.str:
4790
+ def crg_resource_group_name(self) -> _builtins.str:
4792
4791
  return pulumi.get(self, "crg_resource_group_name")
4793
4792
 
4794
- @property
4793
+ @_builtins.property
4795
4794
  @pulumi.getter(name="crgShouldPrioritize")
4796
- def crg_should_prioritize(self) -> Optional[builtins.bool]:
4795
+ def crg_should_prioritize(self) -> Optional[_builtins.bool]:
4797
4796
  return pulumi.get(self, "crg_should_prioritize")
4798
4797
 
4799
4798
 
@@ -4817,12 +4816,12 @@ class StatefulNodeAzureStrategyRevertToSpot(dict):
4817
4816
  return super().get(key, default)
4818
4817
 
4819
4818
  def __init__(__self__, *,
4820
- perform_at: builtins.str):
4819
+ perform_at: _builtins.str):
4821
4820
  pulumi.set(__self__, "perform_at", perform_at)
4822
4821
 
4823
- @property
4822
+ @_builtins.property
4824
4823
  @pulumi.getter(name="performAt")
4825
- def perform_at(self) -> builtins.str:
4824
+ def perform_at(self) -> _builtins.str:
4826
4825
  return pulumi.get(self, "perform_at")
4827
4826
 
4828
4827
 
@@ -4848,32 +4847,32 @@ class StatefulNodeAzureTag(dict):
4848
4847
  return super().get(key, default)
4849
4848
 
4850
4849
  def __init__(__self__, *,
4851
- tag_key: builtins.str,
4852
- tag_value: Optional[builtins.str] = None):
4850
+ tag_key: _builtins.str,
4851
+ tag_value: Optional[_builtins.str] = None):
4853
4852
  pulumi.set(__self__, "tag_key", tag_key)
4854
4853
  if tag_value is not None:
4855
4854
  pulumi.set(__self__, "tag_value", tag_value)
4856
4855
 
4857
- @property
4856
+ @_builtins.property
4858
4857
  @pulumi.getter(name="tagKey")
4859
- def tag_key(self) -> builtins.str:
4858
+ def tag_key(self) -> _builtins.str:
4860
4859
  return pulumi.get(self, "tag_key")
4861
4860
 
4862
- @property
4861
+ @_builtins.property
4863
4862
  @pulumi.getter(name="tagValue")
4864
- def tag_value(self) -> Optional[builtins.str]:
4863
+ def tag_value(self) -> Optional[_builtins.str]:
4865
4864
  return pulumi.get(self, "tag_value")
4866
4865
 
4867
4866
 
4868
4867
  @pulumi.output_type
4869
4868
  class StatefulNodeAzureUpdateState(dict):
4870
4869
  def __init__(__self__, *,
4871
- state: builtins.str):
4870
+ state: _builtins.str):
4872
4871
  pulumi.set(__self__, "state", state)
4873
4872
 
4874
- @property
4873
+ @_builtins.property
4875
4874
  @pulumi.getter
4876
- def state(self) -> builtins.str:
4875
+ def state(self) -> _builtins.str:
4877
4876
  return pulumi.get(self, "state")
4878
4877
 
4879
4878
 
@@ -4905,11 +4904,11 @@ class StatefulNodeAzureVmSizes(dict):
4905
4904
  return super().get(key, default)
4906
4905
 
4907
4906
  def __init__(__self__, *,
4908
- od_sizes: Sequence[builtins.str],
4909
- excluded_vm_sizes: Optional[Sequence[builtins.str]] = None,
4910
- preferred_spot_sizes: Optional[Sequence[builtins.str]] = None,
4907
+ od_sizes: Sequence[_builtins.str],
4908
+ excluded_vm_sizes: Optional[Sequence[_builtins.str]] = None,
4909
+ preferred_spot_sizes: Optional[Sequence[_builtins.str]] = None,
4911
4910
  spot_size_attributes: Optional['outputs.StatefulNodeAzureVmSizesSpotSizeAttributes'] = None,
4912
- spot_sizes: Optional[Sequence[builtins.str]] = None):
4911
+ spot_sizes: Optional[Sequence[_builtins.str]] = None):
4913
4912
  pulumi.set(__self__, "od_sizes", od_sizes)
4914
4913
  if excluded_vm_sizes is not None:
4915
4914
  pulumi.set(__self__, "excluded_vm_sizes", excluded_vm_sizes)
@@ -4920,29 +4919,29 @@ class StatefulNodeAzureVmSizes(dict):
4920
4919
  if spot_sizes is not None:
4921
4920
  pulumi.set(__self__, "spot_sizes", spot_sizes)
4922
4921
 
4923
- @property
4922
+ @_builtins.property
4924
4923
  @pulumi.getter(name="odSizes")
4925
- def od_sizes(self) -> Sequence[builtins.str]:
4924
+ def od_sizes(self) -> Sequence[_builtins.str]:
4926
4925
  return pulumi.get(self, "od_sizes")
4927
4926
 
4928
- @property
4927
+ @_builtins.property
4929
4928
  @pulumi.getter(name="excludedVmSizes")
4930
- def excluded_vm_sizes(self) -> Optional[Sequence[builtins.str]]:
4929
+ def excluded_vm_sizes(self) -> Optional[Sequence[_builtins.str]]:
4931
4930
  return pulumi.get(self, "excluded_vm_sizes")
4932
4931
 
4933
- @property
4932
+ @_builtins.property
4934
4933
  @pulumi.getter(name="preferredSpotSizes")
4935
- def preferred_spot_sizes(self) -> Optional[Sequence[builtins.str]]:
4934
+ def preferred_spot_sizes(self) -> Optional[Sequence[_builtins.str]]:
4936
4935
  return pulumi.get(self, "preferred_spot_sizes")
4937
4936
 
4938
- @property
4937
+ @_builtins.property
4939
4938
  @pulumi.getter(name="spotSizeAttributes")
4940
4939
  def spot_size_attributes(self) -> Optional['outputs.StatefulNodeAzureVmSizesSpotSizeAttributes']:
4941
4940
  return pulumi.get(self, "spot_size_attributes")
4942
4941
 
4943
- @property
4942
+ @_builtins.property
4944
4943
  @pulumi.getter(name="spotSizes")
4945
- def spot_sizes(self) -> Optional[Sequence[builtins.str]]:
4944
+ def spot_sizes(self) -> Optional[Sequence[_builtins.str]]:
4946
4945
  return pulumi.get(self, "spot_sizes")
4947
4946
 
4948
4947
 
@@ -4976,12 +4975,12 @@ class StatefulNodeAzureVmSizesSpotSizeAttributes(dict):
4976
4975
  return super().get(key, default)
4977
4976
 
4978
4977
  def __init__(__self__, *,
4979
- max_cpu: Optional[builtins.int] = None,
4980
- max_memory: Optional[builtins.int] = None,
4981
- max_storage: Optional[builtins.int] = None,
4982
- min_cpu: Optional[builtins.int] = None,
4983
- min_memory: Optional[builtins.int] = None,
4984
- min_storage: Optional[builtins.int] = None):
4978
+ max_cpu: Optional[_builtins.int] = None,
4979
+ max_memory: Optional[_builtins.int] = None,
4980
+ max_storage: Optional[_builtins.int] = None,
4981
+ min_cpu: Optional[_builtins.int] = None,
4982
+ min_memory: Optional[_builtins.int] = None,
4983
+ min_storage: Optional[_builtins.int] = None):
4985
4984
  if max_cpu is not None:
4986
4985
  pulumi.set(__self__, "max_cpu", max_cpu)
4987
4986
  if max_memory is not None:
@@ -4995,34 +4994,34 @@ class StatefulNodeAzureVmSizesSpotSizeAttributes(dict):
4995
4994
  if min_storage is not None:
4996
4995
  pulumi.set(__self__, "min_storage", min_storage)
4997
4996
 
4998
- @property
4997
+ @_builtins.property
4999
4998
  @pulumi.getter(name="maxCpu")
5000
- def max_cpu(self) -> Optional[builtins.int]:
4999
+ def max_cpu(self) -> Optional[_builtins.int]:
5001
5000
  return pulumi.get(self, "max_cpu")
5002
5001
 
5003
- @property
5002
+ @_builtins.property
5004
5003
  @pulumi.getter(name="maxMemory")
5005
- def max_memory(self) -> Optional[builtins.int]:
5004
+ def max_memory(self) -> Optional[_builtins.int]:
5006
5005
  return pulumi.get(self, "max_memory")
5007
5006
 
5008
- @property
5007
+ @_builtins.property
5009
5008
  @pulumi.getter(name="maxStorage")
5010
- def max_storage(self) -> Optional[builtins.int]:
5009
+ def max_storage(self) -> Optional[_builtins.int]:
5011
5010
  return pulumi.get(self, "max_storage")
5012
5011
 
5013
- @property
5012
+ @_builtins.property
5014
5013
  @pulumi.getter(name="minCpu")
5015
- def min_cpu(self) -> Optional[builtins.int]:
5014
+ def min_cpu(self) -> Optional[_builtins.int]:
5016
5015
  return pulumi.get(self, "min_cpu")
5017
5016
 
5018
- @property
5017
+ @_builtins.property
5019
5018
  @pulumi.getter(name="minMemory")
5020
- def min_memory(self) -> Optional[builtins.int]:
5019
+ def min_memory(self) -> Optional[_builtins.int]:
5021
5020
  return pulumi.get(self, "min_memory")
5022
5021
 
5023
- @property
5022
+ @_builtins.property
5024
5023
  @pulumi.getter(name="minStorage")
5025
- def min_storage(self) -> Optional[builtins.int]:
5024
+ def min_storage(self) -> Optional[_builtins.int]:
5026
5025
  return pulumi.get(self, "min_storage")
5027
5026
 
5028
5027