pulumi-spotinst 3.83.0a1720524486__py3-none-any.whl → 3.128.0a1767140134__py3-none-any.whl

pulumi_spotinst/gcp/outputs.py

@@ -1,17 +1,23 @@
 # coding=utf-8
-# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** WARNING: this file was generated by pulumi-language-python. ***
 # *** Do not edit by hand unless you're certain you know what you are doing! ***
 
-import copy
+import builtins as _builtins
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 from . import outputs
 
 __all__ = [
     'ElastigroupBackendService',
+    'ElastigroupBackendServiceBackendBalancing',
     'ElastigroupBackendServiceNamedPort',
     'ElastigroupDisk',
     'ElastigroupDiskInitializeParam',
@@ -27,11 +33,13 @@ __all__ = [
     'ElastigroupNetworkInterface',
     'ElastigroupNetworkInterfaceAccessConfig',
     'ElastigroupNetworkInterfaceAliasIpRange',
+    'ElastigroupRevertToPreemptible',
     'ElastigroupScalingDownPolicy',
     'ElastigroupScalingDownPolicyDimension',
     'ElastigroupScalingUpPolicy',
     'ElastigroupScalingUpPolicyDimension',
     'ElastigroupScheduledTask',
+    'ElastigroupShieldedInstanceConfig',
     'ElastigroupSubnet',
 ]
 
@@ -42,6 +50,8 @@ class ElastigroupBackendService(dict):
         suggest = None
         if key == "serviceName":
             suggest = "service_name"
+        elif key == "backendBalancing":
+            suggest = "backend_balancing"
         elif key == "locationType":
             suggest = "location_type"
         elif key == "namedPorts":
@@ -59,17 +69,21 @@ class ElastigroupBackendService(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 service_name: str,
-                 location_type: Optional[str] = None,
+                 service_name: _builtins.str,
+                 backend_balancing: Optional['outputs.ElastigroupBackendServiceBackendBalancing'] = None,
+                 location_type: Optional[_builtins.str] = None,
                  named_ports: Optional[Sequence['outputs.ElastigroupBackendServiceNamedPort']] = None,
-                 scheme: Optional[str] = None):
+                 scheme: Optional[_builtins.str] = None):
         """
-        :param str service_name: The name of the backend service.
-        :param str location_type: Sets which location the backend services will be active. Valid values: `regional`, `global`.
+        :param _builtins.str service_name: The name of the backend service.
+        :param 'ElastigroupBackendServiceBackendBalancingArgs' backend_balancing: Configure how traffic is distributed across instance groups.
+        :param _builtins.str location_type: Sets which location the backend services will be active. Valid values: `regional`, `global`.
         :param Sequence['ElastigroupBackendServiceNamedPortArgs'] named_ports: Describes a named port and a list of ports.
-        :param str scheme: Use when `location_type` is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
+        :param _builtins.str scheme: Use when `location_type` is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
         """
         pulumi.set(__self__, "service_name", service_name)
+        if backend_balancing is not None:
+            pulumi.set(__self__, "backend_balancing", backend_balancing)
         if location_type is not None:
             pulumi.set(__self__, "location_type", location_type)
         if named_ports is not None:
@@ -77,23 +91,31 @@ class ElastigroupBackendService(dict):
         if scheme is not None:
             pulumi.set(__self__, "scheme", scheme)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="serviceName")
-    def service_name(self) -> str:
+    def service_name(self) -> _builtins.str:
         """
         The name of the backend service.
         """
         return pulumi.get(self, "service_name")
 
-    @property
+    @_builtins.property
+    @pulumi.getter(name="backendBalancing")
+    def backend_balancing(self) -> Optional['outputs.ElastigroupBackendServiceBackendBalancing']:
+        """
+        Configure how traffic is distributed across instance groups.
+        """
+        return pulumi.get(self, "backend_balancing")
+
+    @_builtins.property
     @pulumi.getter(name="locationType")
-    def location_type(self) -> Optional[str]:
+    def location_type(self) -> Optional[_builtins.str]:
         """
         Sets which location the backend services will be active. Valid values: `regional`, `global`.
         """
         return pulumi.get(self, "location_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="namedPorts")
     def named_ports(self) -> Optional[Sequence['outputs.ElastigroupBackendServiceNamedPort']]:
         """
@@ -101,9 +123,9 @@ class ElastigroupBackendService(dict):
         """
         return pulumi.get(self, "named_ports")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def scheme(self) -> Optional[str]:
+    def scheme(self) -> Optional[_builtins.str]:
         """
         Use when `location_type` is "regional". Set the traffic for the backend service to either between the instances in the vpc or to traffic from the internet. Valid values: `INTERNAL`, `EXTERNAL`.
         """
@@ -111,34 +133,84 @@ class ElastigroupBackendService(dict):
 
 
 @pulumi.output_type
-class ElastigroupBackendServiceNamedPort(dict):
+class ElastigroupBackendServiceBackendBalancing(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "backendBalancingMode":
+            suggest = "backend_balancing_mode"
+        elif key == "maxRatePerInstance":
+            suggest = "max_rate_per_instance"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ElastigroupBackendServiceBackendBalancing. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ElastigroupBackendServiceBackendBalancing.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ElastigroupBackendServiceBackendBalancing.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 name: str,
-                 ports: Sequence[str]):
+                 backend_balancing_mode: Optional[_builtins.str] = None,
+                 max_rate_per_instance: Optional[_builtins.int] = None):
         """
-        :param str name: The name of the port.
-        :param Sequence[str] ports: A list of ports.
+        :param _builtins.str backend_balancing_mode: The backend balancing mode. Valid values: `RATE`, `UTILIZATION`.
+        :param _builtins.int max_rate_per_instance: If the backendBalancingMode is set to RATE, this field is required.
                
                Usage:
         """
+        if backend_balancing_mode is not None:
+            pulumi.set(__self__, "backend_balancing_mode", backend_balancing_mode)
+        if max_rate_per_instance is not None:
+            pulumi.set(__self__, "max_rate_per_instance", max_rate_per_instance)
+
+    @_builtins.property
+    @pulumi.getter(name="backendBalancingMode")
+    def backend_balancing_mode(self) -> Optional[_builtins.str]:
+        """
+        The backend balancing mode. Valid values: `RATE`, `UTILIZATION`.
+        """
+        return pulumi.get(self, "backend_balancing_mode")
+
+    @_builtins.property
+    @pulumi.getter(name="maxRatePerInstance")
+    def max_rate_per_instance(self) -> Optional[_builtins.int]:
+        """
+        If the backendBalancingMode is set to RATE, this field is required.
+
+        Usage:
+        """
+        return pulumi.get(self, "max_rate_per_instance")
+
+
+@pulumi.output_type
+class ElastigroupBackendServiceNamedPort(dict):
+    def __init__(__self__, *,
+                 name: _builtins.str,
+                 ports: Sequence[_builtins.str]):
+        """
+        :param _builtins.str name: The name of the port.
+        :param Sequence[_builtins.str] ports: A list of ports.
+        """
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "ports", ports)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> str:
+    def name(self) -> _builtins.str:
         """
         The name of the port.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def ports(self) -> Sequence[str]:
+    def ports(self) -> Sequence[_builtins.str]:
         """
         A list of ports.
-
-        Usage:
         """
         return pulumi.get(self, "ports")
 
@@ -167,23 +239,23 @@ class ElastigroupDisk(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 auto_delete: Optional[bool] = None,
-                 boot: Optional[bool] = None,
-                 device_name: Optional[str] = None,
+                 auto_delete: Optional[_builtins.bool] = None,
+                 boot: Optional[_builtins.bool] = None,
+                 device_name: Optional[_builtins.str] = None,
                  initialize_params: Optional[Sequence['outputs.ElastigroupDiskInitializeParam']] = None,
-                 interface: Optional[str] = None,
-                 mode: Optional[str] = None,
-                 source: Optional[str] = None,
-                 type: Optional[str] = None):
-        """
-        :param bool auto_delete: Specifies whether the disk will be auto-deleted when the instance is deleted.
-        :param bool boot: Indicates that this is a boot disk. The virtual machine will use the first partition of the disk for its root filesystem.
-        :param str device_name: Specifies a unique device name of your choice.
+                 interface: Optional[_builtins.str] = None,
+                 mode: Optional[_builtins.str] = None,
+                 source: Optional[_builtins.str] = None,
+                 type: Optional[_builtins.str] = None):
+        """
+        :param _builtins.bool auto_delete: Specifies whether the disk will be auto-deleted when the instance is deleted.
+        :param _builtins.bool boot: Indicates that this is a boot disk. The virtual machine will use the first partition of the disk for its root filesystem.
+        :param _builtins.str device_name: Specifies a unique device name of your choice.
         :param Sequence['ElastigroupDiskInitializeParamArgs'] initialize_params: Specifies the parameters for a new disk that will be created alongside the new instance. Use initialization parameters to create boot disks or local SSDs attached to the new instance.
-        :param str interface: Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME.
-        :param str mode: The mode in which to attach this disk, either READ_WRITE or READ_ONLY.
-        :param str source: Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
-        :param str type: Specifies the type of disk, either SCRATCH or PERSISTENT.
+        :param _builtins.str interface: Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME.
+        :param _builtins.str mode: The mode in which to attach this disk, either READ_WRITE or READ_ONLY.
+        :param _builtins.str source: Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
+        :param _builtins.str type: Specifies the type of disk, either SCRATCH or PERSISTENT.
         """
         if auto_delete is not None:
             pulumi.set(__self__, "auto_delete", auto_delete)
@@ -202,31 +274,31 @@ class ElastigroupDisk(dict):
         if type is not None:
             pulumi.set(__self__, "type", type)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="autoDelete")
-    def auto_delete(self) -> Optional[bool]:
+    def auto_delete(self) -> Optional[_builtins.bool]:
         """
         Specifies whether the disk will be auto-deleted when the instance is deleted.
         """
         return pulumi.get(self, "auto_delete")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def boot(self) -> Optional[bool]:
+    def boot(self) -> Optional[_builtins.bool]:
         """
         Indicates that this is a boot disk. The virtual machine will use the first partition of the disk for its root filesystem.
         """
         return pulumi.get(self, "boot")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="deviceName")
-    def device_name(self) -> Optional[str]:
+    def device_name(self) -> Optional[_builtins.str]:
         """
         Specifies a unique device name of your choice.
         """
         return pulumi.get(self, "device_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="initializeParams")
     def initialize_params(self) -> Optional[Sequence['outputs.ElastigroupDiskInitializeParam']]:
         """
@@ -234,33 +306,33 @@ class ElastigroupDisk(dict):
         """
         return pulumi.get(self, "initialize_params")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def interface(self) -> Optional[str]:
+    def interface(self) -> Optional[_builtins.str]:
         """
         Specifies the disk interface to use for attaching this disk, which is either SCSI or NVME.
         """
         return pulumi.get(self, "interface")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def mode(self) -> Optional[str]:
+    def mode(self) -> Optional[_builtins.str]:
         """
         The mode in which to attach this disk, either READ_WRITE or READ_ONLY.
         """
         return pulumi.get(self, "mode")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def source(self) -> Optional[str]:
+    def source(self) -> Optional[_builtins.str]:
         """
         Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
         """
         return pulumi.get(self, "source")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> Optional[str]:
+    def type(self) -> Optional[_builtins.str]:
         """
         Specifies the type of disk, either SCRATCH or PERSISTENT.
         """
@@ -291,15 +363,15 @@ class ElastigroupDiskInitializeParam(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 source_image: str,
-                 disk_size_gb: Optional[str] = None,
-                 disk_type: Optional[str] = None):
+                 source_image: _builtins.str,
+                 disk_size_gb: Optional[_builtins.str] = None,
+                 disk_type: Optional[_builtins.str] = None):
         """
-        :param str source_image: A source image used to create the disk. You can provide a private (custom) image, and Compute Engine will use the corresponding image from your project.
+        :param _builtins.str source_image: A source image used to create the disk. You can provide a private (custom) image, and Compute Engine will use the corresponding image from your project.
                
                Usage:
-        :param str disk_size_gb: Specifies disk size in gigabytes. Must be in increments of 2.
-        :param str disk_type: Specifies the disk type to use to create the instance. Valid values: pd-ssd, local-ssd.
+        :param _builtins.str disk_size_gb: Specifies disk size in gigabytes. Must be in increments of 2.
+        :param _builtins.str disk_type: Specifies the disk type to use to create the instance. Valid values: pd-ssd, local-ssd.
         """
         pulumi.set(__self__, "source_image", source_image)
         if disk_size_gb is not None:
@@ -307,9 +379,9 @@ class ElastigroupDiskInitializeParam(dict):
         if disk_type is not None:
             pulumi.set(__self__, "disk_type", disk_type)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="sourceImage")
-    def source_image(self) -> str:
+    def source_image(self) -> _builtins.str:
         """
         A source image used to create the disk. You can provide a private (custom) image, and Compute Engine will use the corresponding image from your project.
 
@@ -317,17 +389,17 @@ class ElastigroupDiskInitializeParam(dict):
         """
         return pulumi.get(self, "source_image")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="diskSizeGb")
-    def disk_size_gb(self) -> Optional[str]:
+    def disk_size_gb(self) -> Optional[_builtins.str]:
         """
         Specifies disk size in gigabytes. Must be in increments of 2.
         """
         return pulumi.get(self, "disk_size_gb")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="diskType")
-    def disk_type(self) -> Optional[str]:
+    def disk_type(self) -> Optional[_builtins.str]:
         """
         Specifies the disk type to use to create the instance. Valid values: pd-ssd, local-ssd.
         """
@@ -337,20 +409,20 @@ class ElastigroupDiskInitializeParam(dict):
 @pulumi.output_type
 class ElastigroupGpu(dict):
     def __init__(__self__, *,
-                 count: int,
-                 type: str):
+                 count: _builtins.int,
+                 type: _builtins.str):
         """
-        :param int count: The number of GPUs. Must be 0, 2, 4, 6, 8.
+        :param _builtins.int count: The number of GPUs. Must be 0, 2, 4, 6, 8.
                
                Usage:
-        :param str type: The type of GPU instance. Valid values: `nvidia-tesla-v100`, `nvidia-tesla-p100`, `nvidia-tesla-k80`.
+        :param _builtins.str type: The type of GPU instance. Valid values: `nvidia-tesla-v100`, `nvidia-tesla-p100`, `nvidia-tesla-k80`.
         """
         pulumi.set(__self__, "count", count)
         pulumi.set(__self__, "type", type)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def count(self) -> int:
+    def count(self) -> _builtins.int:
         """
         The number of GPUs. Must be 0, 2, 4, 6, 8.
 
@@ -358,9 +430,9 @@ class ElastigroupGpu(dict):
         """
         return pulumi.get(self, "count")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> str:
+    def type(self) -> _builtins.str:
         """
         The type of GPU instance. Valid values: `nvidia-tesla-v100`, `nvidia-tesla-p100`, `nvidia-tesla-k80`.
         """
@@ -387,25 +459,25 @@ class ElastigroupInstanceTypesCustom(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 memory_gib: int,
-                 vcpu: int):
+                 memory_gib: _builtins.int,
+                 vcpu: _builtins.int):
         """
-        :param int memory_gib: The memory (in GiB) in the custom instance types. GCP has a number of limitations on accepted memory values.For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]
+        :param _builtins.int memory_gib: The memory (in GiB) in the custom instance types. GCP has a number of limitations on accepted memory values.For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]
         """
         pulumi.set(__self__, "memory_gib", memory_gib)
         pulumi.set(__self__, "vcpu", vcpu)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="memoryGib")
-    def memory_gib(self) -> int:
+    def memory_gib(self) -> _builtins.int:
         """
         The memory (in GiB) in the custom instance types. GCP has a number of limitations on accepted memory values.For more information, see the GCP documentation (here.)[https://cloud.google.com/compute/docs/instances/creating-instance-with-custom-machine-type#specifications]
         """
         return pulumi.get(self, "memory_gib")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def vcpu(self) -> int:
+    def vcpu(self) -> _builtins.int:
         return pulumi.get(self, "vcpu")
 
 
@@ -431,19 +503,33 @@ class ElastigroupIntegrationDockerSwarm(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 master_host: str,
-                 master_port: int):
+                 master_host: _builtins.str,
+                 master_port: _builtins.int):
+        """
+        :param _builtins.str master_host: IP or FQDN of one of your swarm managers.
+        :param _builtins.int master_port: Network port used by your swarm.
+               
+               Usage:
+        """
         pulumi.set(__self__, "master_host", master_host)
         pulumi.set(__self__, "master_port", master_port)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="masterHost")
-    def master_host(self) -> str:
+    def master_host(self) -> _builtins.str:
+        """
+        IP or FQDN of one of your swarm managers.
+        """
         return pulumi.get(self, "master_host")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="masterPort")
-    def master_port(self) -> int:
+    def master_port(self) -> _builtins.int:
+        """
+        Network port used by your swarm.
+
+        Usage:
+        """
         return pulumi.get(self, "master_port")
 
 
@@ -481,15 +567,15 @@ class ElastigroupIntegrationGke(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 auto_update: Optional[bool] = None,
-                 autoscale_cooldown: Optional[int] = None,
+                 auto_update: Optional[_builtins.bool] = None,
+                 autoscale_cooldown: Optional[_builtins.int] = None,
                  autoscale_down: Optional['outputs.ElastigroupIntegrationGkeAutoscaleDown'] = None,
                  autoscale_headroom: Optional['outputs.ElastigroupIntegrationGkeAutoscaleHeadroom'] = None,
-                 autoscale_is_auto_config: Optional[bool] = None,
-                 autoscale_is_enabled: Optional[bool] = None,
+                 autoscale_is_auto_config: Optional[_builtins.bool] = None,
+                 autoscale_is_enabled: Optional[_builtins.bool] = None,
                  autoscale_labels: Optional[Sequence['outputs.ElastigroupIntegrationGkeAutoscaleLabel']] = None,
-                 cluster_id: Optional[str] = None,
-                 location: Optional[str] = None):
+                 cluster_id: Optional[_builtins.str] = None,
+                 location: Optional[_builtins.str] = None):
         if auto_update is not None:
             pulumi.set(__self__, "auto_update", auto_update)
         if autoscale_cooldown is not None:
@@ -509,49 +595,49 @@ class ElastigroupIntegrationGke(dict):
         if location is not None:
             pulumi.set(__self__, "location", location)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="autoUpdate")
-    def auto_update(self) -> Optional[bool]:
+    def auto_update(self) -> Optional[_builtins.bool]:
         return pulumi.get(self, "auto_update")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="autoscaleCooldown")
-    def autoscale_cooldown(self) -> Optional[int]:
+    def autoscale_cooldown(self) -> Optional[_builtins.int]:
         return pulumi.get(self, "autoscale_cooldown")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="autoscaleDown")
     def autoscale_down(self) -> Optional['outputs.ElastigroupIntegrationGkeAutoscaleDown']:
         return pulumi.get(self, "autoscale_down")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="autoscaleHeadroom")
     def autoscale_headroom(self) -> Optional['outputs.ElastigroupIntegrationGkeAutoscaleHeadroom']:
         return pulumi.get(self, "autoscale_headroom")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="autoscaleIsAutoConfig")
-    def autoscale_is_auto_config(self) -> Optional[bool]:
+    def autoscale_is_auto_config(self) -> Optional[_builtins.bool]:
         return pulumi.get(self, "autoscale_is_auto_config")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="autoscaleIsEnabled")
-    def autoscale_is_enabled(self) -> Optional[bool]:
+    def autoscale_is_enabled(self) -> Optional[_builtins.bool]:
         return pulumi.get(self, "autoscale_is_enabled")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="autoscaleLabels")
     def autoscale_labels(self) -> Optional[Sequence['outputs.ElastigroupIntegrationGkeAutoscaleLabel']]:
         return pulumi.get(self, "autoscale_labels")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="clusterId")
-    def cluster_id(self) -> Optional[str]:
+    def cluster_id(self) -> Optional[_builtins.str]:
         return pulumi.get(self, "cluster_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def location(self) -> Optional[str]:
+    def location(self) -> Optional[_builtins.str]:
         return pulumi.get(self, "location")
 
 
@@ -575,13 +661,19 @@ class ElastigroupIntegrationGkeAutoscaleDown(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 evaluation_periods: Optional[int] = None):
+                 evaluation_periods: Optional[_builtins.int] = None):
+        """
+        :param _builtins.int evaluation_periods: Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
+        """
         if evaluation_periods is not None:
             pulumi.set(__self__, "evaluation_periods", evaluation_periods)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="evaluationPeriods")
-    def evaluation_periods(self) -> Optional[int]:
+    def evaluation_periods(self) -> Optional[_builtins.int]:
+        """
+        Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
+        """
         return pulumi.get(self, "evaluation_periods")
 
 
@@ -609,9 +701,9 @@ class ElastigroupIntegrationGkeAutoscaleHeadroom(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 cpu_per_unit: Optional[int] = None,
-                 memory_per_unit: Optional[int] = None,
-                 num_of_units: Optional[int] = None):
+                 cpu_per_unit: Optional[_builtins.int] = None,
+                 memory_per_unit: Optional[_builtins.int] = None,
+                 num_of_units: Optional[_builtins.int] = None):
         if cpu_per_unit is not None:
             pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
         if memory_per_unit is not None:
@@ -619,64 +711,64 @@ class ElastigroupIntegrationGkeAutoscaleHeadroom(dict):
         if num_of_units is not None:
             pulumi.set(__self__, "num_of_units", num_of_units)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="cpuPerUnit")
-    def cpu_per_unit(self) -> Optional[int]:
+    def cpu_per_unit(self) -> Optional[_builtins.int]:
         return pulumi.get(self, "cpu_per_unit")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="memoryPerUnit")
-    def memory_per_unit(self) -> Optional[int]:
+    def memory_per_unit(self) -> Optional[_builtins.int]:
         return pulumi.get(self, "memory_per_unit")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="numOfUnits")
-    def num_of_units(self) -> Optional[int]:
+    def num_of_units(self) -> Optional[_builtins.int]:
         return pulumi.get(self, "num_of_units")
 
 
 @pulumi.output_type
 class ElastigroupIntegrationGkeAutoscaleLabel(dict):
     def __init__(__self__, *,
-                 key: str,
-                 value: str):
+                 key: _builtins.str,
+                 value: _builtins.str):
         pulumi.set(__self__, "key", key)
         pulumi.set(__self__, "value", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def key(self) -> str:
+    def key(self) -> _builtins.str:
         return pulumi.get(self, "key")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> str:
+    def value(self) -> _builtins.str:
         return pulumi.get(self, "value")
 
 
 @pulumi.output_type
 class ElastigroupLabel(dict):
     def __init__(__self__, *,
-                 key: str,
-                 value: str):
+                 key: _builtins.str,
+                 value: _builtins.str):
         """
-        :param str key: Labels key.
-        :param str value: Labels value.
+        :param _builtins.str key: Labels key.
+        :param _builtins.str value: Labels value.
         """
         pulumi.set(__self__, "key", key)
         pulumi.set(__self__, "value", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def key(self) -> str:
+    def key(self) -> _builtins.str:
         """
         Labels key.
         """
         return pulumi.get(self, "key")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> str:
+    def value(self) -> _builtins.str:
         """
         Labels value.
         """
@@ -686,26 +778,26 @@ class ElastigroupLabel(dict):
 @pulumi.output_type
 class ElastigroupMetadata(dict):
     def __init__(__self__, *,
-                 key: str,
-                 value: str):
+                 key: _builtins.str,
+                 value: _builtins.str):
         """
-        :param str key: Metadata key.
-        :param str value: Metadata value.
+        :param _builtins.str key: Metadata key.
+        :param _builtins.str value: Metadata value.
         """
         pulumi.set(__self__, "key", key)
         pulumi.set(__self__, "value", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def key(self) -> str:
+    def key(self) -> _builtins.str:
         """
         Metadata key.
         """
         return pulumi.get(self, "key")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> str:
+    def value(self) -> _builtins.str:
         """
         Metadata value.
         """
@@ -734,26 +826,36 @@ class ElastigroupNetworkInterface(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 network: str,
+                 network: _builtins.str,
                  access_configs: Optional[Sequence['outputs.ElastigroupNetworkInterfaceAccessConfig']] = None,
                  alias_ip_ranges: Optional[Sequence['outputs.ElastigroupNetworkInterfaceAliasIpRange']] = None):
+        """
+        :param _builtins.str network: Network resource for this group.
+        :param Sequence['ElastigroupNetworkInterfaceAccessConfigArgs'] access_configs: Array of configurations.
+        """
         pulumi.set(__self__, "network", network)
         if access_configs is not None:
             pulumi.set(__self__, "access_configs", access_configs)
         if alias_ip_ranges is not None:
             pulumi.set(__self__, "alias_ip_ranges", alias_ip_ranges)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def network(self) -> str:
+    def network(self) -> _builtins.str:
+        """
+        Network resource for this group.
+        """
         return pulumi.get(self, "network")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="accessConfigs")
     def access_configs(self) -> Optional[Sequence['outputs.ElastigroupNetworkInterfaceAccessConfig']]:
+        """
+        Array of configurations.
+        """
         return pulumi.get(self, "access_configs")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="aliasIpRanges")
     def alias_ip_ranges(self) -> Optional[Sequence['outputs.ElastigroupNetworkInterfaceAliasIpRange']]:
         return pulumi.get(self, "alias_ip_ranges")
@@ -762,27 +864,27 @@ class ElastigroupNetworkInterface(dict):
 @pulumi.output_type
 class ElastigroupNetworkInterfaceAccessConfig(dict):
     def __init__(__self__, *,
-                 name: Optional[str] = None,
-                 type: Optional[str] = None):
+                 name: Optional[_builtins.str] = None,
+                 type: Optional[_builtins.str] = None):
         """
-        :param str name: The group name.
+        :param _builtins.str name: The group name.
         """
         if name is not None:
             pulumi.set(__self__, "name", name)
         if type is not None:
             pulumi.set(__self__, "type", type)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> Optional[str]:
+    def name(self) -> Optional[_builtins.str]:
         """
         The group name.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def type(self) -> Optional[str]:
+    def type(self) -> Optional[_builtins.str]:
         return pulumi.get(self, "type")
 
 
@@ -808,22 +910,57 @@ class ElastigroupNetworkInterfaceAliasIpRange(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 ip_cidr_range: str,
-                 subnetwork_range_name: str):
+                 ip_cidr_range: _builtins.str,
+                 subnetwork_range_name: _builtins.str):
         pulumi.set(__self__, "ip_cidr_range", ip_cidr_range)
         pulumi.set(__self__, "subnetwork_range_name", subnetwork_range_name)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="ipCidrRange")
-    def ip_cidr_range(self) -> str:
+    def ip_cidr_range(self) -> _builtins.str:
         return pulumi.get(self, "ip_cidr_range")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="subnetworkRangeName")
-    def subnetwork_range_name(self) -> str:
+    def subnetwork_range_name(self) -> _builtins.str:
         return pulumi.get(self, "subnetwork_range_name")
 
 
+@pulumi.output_type
+class ElastigroupRevertToPreemptible(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "performAt":
+            suggest = "perform_at"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ElastigroupRevertToPreemptible. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ElastigroupRevertToPreemptible.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ElastigroupRevertToPreemptible.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 perform_at: _builtins.str):
+        """
+        :param _builtins.str perform_at: Valid values: "always", "never", "timeWindow". Required on strategy.revertToPreemptible object.
+        """
+        pulumi.set(__self__, "perform_at", perform_at)
+
+    @_builtins.property
+    @pulumi.getter(name="performAt")
+    def perform_at(self) -> _builtins.str:
+        """
+        Valid values: "always", "never", "timeWindow". Required on strategy.revertToPreemptible object.
+        """
+        return pulumi.get(self, "perform_at")
+
+
 @pulumi.output_type
 class ElastigroupScalingDownPolicy(dict):
     @staticmethod
@@ -850,20 +987,34 @@ class ElastigroupScalingDownPolicy(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 metric_name: str,
-                 namespace: str,
-                 policy_name: str,
-                 threshold: float,
-                 unit: str,
-                 action_type: Optional[str] = None,
-                 adjustment: Optional[int] = None,
-                 cooldown: Optional[int] = None,
+                 metric_name: _builtins.str,
+                 namespace: _builtins.str,
+                 policy_name: _builtins.str,
+                 threshold: _builtins.float,
+                 unit: _builtins.str,
+                 action_type: Optional[_builtins.str] = None,
+                 adjustment: Optional[_builtins.int] = None,
+                 cooldown: Optional[_builtins.int] = None,
                  dimensions: Optional[Sequence['outputs.ElastigroupScalingDownPolicyDimension']] = None,
-                 evaluation_periods: Optional[int] = None,
-                 operator: Optional[str] = None,
-                 period: Optional[int] = None,
-                 source: Optional[str] = None,
-                 statistic: Optional[str] = None):
+                 evaluation_periods: Optional[_builtins.int] = None,
+                 operator: Optional[_builtins.str] = None,
+                 period: Optional[_builtins.int] = None,
+                 source: Optional[_builtins.str] = None,
+                 statistic: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str metric_name: Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".
+        :param _builtins.str policy_name: Name of scaling policy.
+        :param _builtins.float threshold: The value at which the scaling action is triggered.
+        :param _builtins.str action_type: Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"
+        :param _builtins.int adjustment: Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.
+        :param _builtins.int cooldown: Time (seconds) to wait after a scaling action before resuming monitoring.
+        :param Sequence['ElastigroupScalingDownPolicyDimensionArgs'] dimensions: A list of dimensions describing qualities of the metric.
+        :param _builtins.int evaluation_periods: Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
+        :param _builtins.str operator: The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).
+        :param _builtins.int period: Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.
+        :param _builtins.str source: Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
+        :param _builtins.str statistic: Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".
+        """
         pulumi.set(__self__, "metric_name", metric_name)
         pulumi.set(__self__, "namespace", namespace)
         pulumi.set(__self__, "policy_name", policy_name)
@@ -888,100 +1039,136 @@ class ElastigroupScalingDownPolicy(dict):
         if statistic is not None:
             pulumi.set(__self__, "statistic", statistic)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="metricName")
-    def metric_name(self) -> str:
+    def metric_name(self) -> _builtins.str:
+        """
+        Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".
+        """
         return pulumi.get(self, "metric_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def namespace(self) -> str:
+    def namespace(self) -> _builtins.str:
         return pulumi.get(self, "namespace")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="policyName")
-    def policy_name(self) -> str:
+    def policy_name(self) -> _builtins.str:
+        """
+        Name of scaling policy.
+        """
         return pulumi.get(self, "policy_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def threshold(self) -> float:
+    def threshold(self) -> _builtins.float:
+        """
+        The value at which the scaling action is triggered.
+        """
         return pulumi.get(self, "threshold")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def unit(self) -> str:
+    def unit(self) -> _builtins.str:
         return pulumi.get(self, "unit")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="actionType")
-    def action_type(self) -> Optional[str]:
+    def action_type(self) -> Optional[_builtins.str]:
+        """
+        Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"
+        """
         return pulumi.get(self, "action_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def adjustment(self) -> Optional[int]:
+    def adjustment(self) -> Optional[_builtins.int]:
+        """
+        Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.
+        """
         return pulumi.get(self, "adjustment")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def cooldown(self) -> Optional[int]:
+    def cooldown(self) -> Optional[_builtins.int]:
+        """
+        Time (seconds) to wait after a scaling action before resuming monitoring.
+        """
         return pulumi.get(self, "cooldown")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def dimensions(self) -> Optional[Sequence['outputs.ElastigroupScalingDownPolicyDimension']]:
+        """
+        A list of dimensions describing qualities of the metric.
+        """
         return pulumi.get(self, "dimensions")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="evaluationPeriods")
-    def evaluation_periods(self) -> Optional[int]:
+    def evaluation_periods(self) -> Optional[_builtins.int]:
+        """
+        Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
+        """
         return pulumi.get(self, "evaluation_periods")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def operator(self) -> Optional[str]:
+    def operator(self) -> Optional[_builtins.str]:
+        """
+        The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).
+        """
         return pulumi.get(self, "operator")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def period(self) -> Optional[int]:
+    def period(self) -> Optional[_builtins.int]:
+        """
+        Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.
+        """
         return pulumi.get(self, "period")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def source(self) -> Optional[str]:
+    def source(self) -> Optional[_builtins.str]:
+        """
+        Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
+        """
         return pulumi.get(self, "source")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def statistic(self) -> Optional[str]:
+    def statistic(self) -> Optional[_builtins.str]:
+        """
+        Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".
+        """
         return pulumi.get(self, "statistic")
 
 
 @pulumi.output_type
 class ElastigroupScalingDownPolicyDimension(dict):
     def __init__(__self__, *,
-                 name: str,
-                 value: Optional[str] = None):
+                 name: _builtins.str,
+                 value: Optional[_builtins.str] = None):
         """
-        :param str name: The group name.
+        :param _builtins.str name: The group name.
         """
         pulumi.set(__self__, "name", name)
         if value is not None:
             pulumi.set(__self__, "value", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> str:
+    def name(self) -> _builtins.str:
         """
         The group name.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> Optional[str]:
+    def value(self) -> Optional[_builtins.str]:
         return pulumi.get(self, "value")
 
 
@@ -1011,32 +1198,33 @@ class ElastigroupScalingUpPolicy(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 metric_name: str,
-                 namespace: str,
-                 policy_name: str,
-                 threshold: float,
-                 unit: str,
-                 action_type: Optional[str] = None,
-                 adjustment: Optional[int] = None,
-                 cooldown: Optional[int] = None,
+                 metric_name: _builtins.str,
+                 namespace: _builtins.str,
+                 policy_name: _builtins.str,
+                 threshold: _builtins.float,
+                 unit: _builtins.str,
+                 action_type: Optional[_builtins.str] = None,
+                 adjustment: Optional[_builtins.int] = None,
+                 cooldown: Optional[_builtins.int] = None,
                  dimensions: Optional[Sequence['outputs.ElastigroupScalingUpPolicyDimension']] = None,
-                 evaluation_periods: Optional[int] = None,
-                 operator: Optional[str] = None,
-                 period: Optional[int] = None,
-                 source: Optional[str] = None,
-                 statistic: Optional[str] = None):
-        """
-        :param str metric_name: Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".
-        :param str policy_name: Name of scaling policy.
-        :param float threshold: The value at which the scaling action is triggered.
-        :param str action_type: Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"
-        :param int adjustment: Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.
-        :param int cooldown: Time (seconds) to wait after a scaling action before resuming monitoring.
+                 evaluation_periods: Optional[_builtins.int] = None,
+                 operator: Optional[_builtins.str] = None,
+                 period: Optional[_builtins.int] = None,
+                 source: Optional[_builtins.str] = None,
+                 statistic: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str metric_name: Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".
+        :param _builtins.str policy_name: Name of scaling policy.
+        :param _builtins.float threshold: The value at which the scaling action is triggered.
+        :param _builtins.str action_type: Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"
+        :param _builtins.int adjustment: Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.
+        :param _builtins.int cooldown: Time (seconds) to wait after a scaling action before resuming monitoring.
         :param Sequence['ElastigroupScalingUpPolicyDimensionArgs'] dimensions: A list of dimensions describing qualities of the metric.
-        :param int evaluation_periods: Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
-        :param str operator: The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).
-        :param int period: Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.
-        :param str statistic: Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".
+        :param _builtins.int evaluation_periods: Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
+        :param _builtins.str operator: The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).
+        :param _builtins.int period: Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.
+        :param _builtins.str source: Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
+        :param _builtins.str statistic: Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".
         """
         pulumi.set(__self__, "metric_name", metric_name)
         pulumi.set(__self__, "namespace", namespace)
@@ -1062,65 +1250,65 @@ class ElastigroupScalingUpPolicy(dict):
         if statistic is not None:
             pulumi.set(__self__, "statistic", statistic)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="metricName")
-    def metric_name(self) -> str:
+    def metric_name(self) -> _builtins.str:
         """
         Metric to monitor. Valid values: "Percentage CPU", "Network In", "Network Out", "Disk Read Bytes", "Disk Write Bytes", "Disk Write Operations/Sec", "Disk Read Operations/Sec".
         """
         return pulumi.get(self, "metric_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def namespace(self) -> str:
+    def namespace(self) -> _builtins.str:
         return pulumi.get(self, "namespace")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="policyName")
-    def policy_name(self) -> str:
+    def policy_name(self) -> _builtins.str:
         """
         Name of scaling policy.
         """
         return pulumi.get(self, "policy_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def threshold(self) -> float:
+    def threshold(self) -> _builtins.float:
         """
         The value at which the scaling action is triggered.
         """
         return pulumi.get(self, "threshold")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def unit(self) -> str:
+    def unit(self) -> _builtins.str:
         return pulumi.get(self, "unit")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="actionType")
-    def action_type(self) -> Optional[str]:
+    def action_type(self) -> Optional[_builtins.str]:
         """
         Type of scaling action to take when the scaling policy is triggered. Valid values: "adjustment", "setMinTarget", "updateCapacity", "percentageAdjustment"
         """
         return pulumi.get(self, "action_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def adjustment(self) -> Optional[int]:
+    def adjustment(self) -> Optional[_builtins.int]:
         """
         Value to which the action type will be adjusted. Required if using "numeric" or "percentageAdjustment" action types.
         """
         return pulumi.get(self, "adjustment")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def cooldown(self) -> Optional[int]:
+    def cooldown(self) -> Optional[_builtins.int]:
         """
         Time (seconds) to wait after a scaling action before resuming monitoring.
         """
         return pulumi.get(self, "cooldown")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def dimensions(self) -> Optional[Sequence['outputs.ElastigroupScalingUpPolicyDimension']]:
         """
@@ -1128,38 +1316,41 @@ class ElastigroupScalingUpPolicy(dict):
         """
         return pulumi.get(self, "dimensions")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="evaluationPeriods")
-    def evaluation_periods(self) -> Optional[int]:
+    def evaluation_periods(self) -> Optional[_builtins.int]:
         """
         Number of consecutive periods in which the threshold must be met in order to trigger a scaling action.
         """
         return pulumi.get(self, "evaluation_periods")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def operator(self) -> Optional[str]:
+    def operator(self) -> Optional[_builtins.str]:
         """
         The operator used to evaluate the threshold against the current metric value. Valid values: "gt" (greater than), "get" (greater-than or equal), "lt" (less than), "lte" (less than or equal).
         """
         return pulumi.get(self, "operator")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def period(self) -> Optional[int]:
+    def period(self) -> Optional[_builtins.int]:
         """
         Amount of time (seconds) for which the threshold must be met in order to trigger the scaling action.
         """
         return pulumi.get(self, "period")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def source(self) -> Optional[str]:
+    def source(self) -> Optional[_builtins.str]:
+        """
+        Specifies a valid partial or full URL to an existing Persistent Disk resource. This field is only applicable for persistent disks.
+        """
         return pulumi.get(self, "source")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def statistic(self) -> Optional[str]:
+    def statistic(self) -> Optional[_builtins.str]:
         """
         Statistic by which to evaluate the selected metric. Valid values: "AVERAGE", "SAMPLE_COUNT", "SUM", "MINIMUM", "MAXIMUM", "PERCENTILE", "COUNT".
         """
@@ -1169,11 +1360,11 @@ class ElastigroupScalingUpPolicy(dict):
 @pulumi.output_type
 class ElastigroupScalingUpPolicyDimension(dict):
     def __init__(__self__, *,
-                 name: str,
-                 value: Optional[str] = None):
+                 name: _builtins.str,
+                 value: Optional[_builtins.str] = None):
         """
-        :param str name: The dimension name.
-        :param str value: The dimension value.
+        :param _builtins.str name: The dimension name.
+        :param _builtins.str value: The dimension value.
                
                Usage:
         """
@@ -1181,17 +1372,17 @@ class ElastigroupScalingUpPolicyDimension(dict):
         if value is not None:
             pulumi.set(__self__, "value", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> str:
+    def name(self) -> _builtins.str:
         """
         The dimension name.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> Optional[str]:
+    def value(self) -> Optional[_builtins.str]:
         """
         The dimension value.
 
@@ -1230,21 +1421,21 @@ class ElastigroupScheduledTask(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 task_type: str,
-                 cron_expression: Optional[str] = None,
-                 is_enabled: Optional[bool] = None,
-                 max_capacity: Optional[str] = None,
-                 min_capacity: Optional[str] = None,
-                 target_capacity: Optional[str] = None):
-        """
-        :param str task_type: The task type to run. Valid values: `"setCapacity"`.
-        :param str cron_expression: A valid cron expression. The cron is running in UTC time zone and is in [Unix cron format](https://en.wikipedia.org/wiki/Cron).
-        :param bool is_enabled: Setting the task to being enabled or disabled.
-        :param str max_capacity: The maximum number of instances the group should have.
+                 task_type: _builtins.str,
+                 cron_expression: Optional[_builtins.str] = None,
+                 is_enabled: Optional[_builtins.bool] = None,
+                 max_capacity: Optional[_builtins.str] = None,
+                 min_capacity: Optional[_builtins.str] = None,
+                 target_capacity: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str task_type: The task type to run. Valid values: `"setCapacity"`.
+        :param _builtins.str cron_expression: A valid cron expression. The cron is running in UTC time zone and is in [Unix cron format](https://en.wikipedia.org/wiki/Cron).
+        :param _builtins.bool is_enabled: Setting the task to being enabled or disabled.
+        :param _builtins.str max_capacity: The maximum number of instances the group should have.
                
                Usage:
-        :param str min_capacity: The minimum number of instances the group should have.
-        :param str target_capacity: The desired number of instances the group should have.
+        :param _builtins.str min_capacity: The minimum number of instances the group should have.
+        :param _builtins.str target_capacity: The desired number of instances the group should have.
         """
         pulumi.set(__self__, "task_type", task_type)
         if cron_expression is not None:
@@ -1258,33 +1449,33 @@ class ElastigroupScheduledTask(dict):
         if target_capacity is not None:
             pulumi.set(__self__, "target_capacity", target_capacity)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="taskType")
-    def task_type(self) -> str:
+    def task_type(self) -> _builtins.str:
         """
         The task type to run. Valid values: `"setCapacity"`.
         """
         return pulumi.get(self, "task_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="cronExpression")
-    def cron_expression(self) -> Optional[str]:
+    def cron_expression(self) -> Optional[_builtins.str]:
         """
         A valid cron expression. The cron is running in UTC time zone and is in [Unix cron format](https://en.wikipedia.org/wiki/Cron).
         """
         return pulumi.get(self, "cron_expression")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="isEnabled")
-    def is_enabled(self) -> Optional[bool]:
+    def is_enabled(self) -> Optional[_builtins.bool]:
         """
         Setting the task to being enabled or disabled.
         """
         return pulumi.get(self, "is_enabled")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="maxCapacity")
-    def max_capacity(self) -> Optional[str]:
+    def max_capacity(self) -> Optional[_builtins.str]:
         """
         The maximum number of instances the group should have.
 
@@ -1292,23 +1483,73 @@ class ElastigroupScheduledTask(dict):
         """
         return pulumi.get(self, "max_capacity")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="minCapacity")
-    def min_capacity(self) -> Optional[str]:
+    def min_capacity(self) -> Optional[_builtins.str]:
         """
         The minimum number of instances the group should have.
         """
         return pulumi.get(self, "min_capacity")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="targetCapacity")
-    def target_capacity(self) -> Optional[str]:
+    def target_capacity(self) -> Optional[_builtins.str]:
         """
         The desired number of instances the group should have.
         """
         return pulumi.get(self, "target_capacity")
 
 
+@pulumi.output_type
+class ElastigroupShieldedInstanceConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "enableIntegrityMonitoring":
+            suggest = "enable_integrity_monitoring"
+        elif key == "enableSecureBoot":
+            suggest = "enable_secure_boot"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ElastigroupShieldedInstanceConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ElastigroupShieldedInstanceConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ElastigroupShieldedInstanceConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 enable_integrity_monitoring: Optional[_builtins.bool] = None,
+                 enable_secure_boot: Optional[_builtins.bool] = None):
+        """
+        :param _builtins.bool enable_integrity_monitoring: Default: false
+        :param _builtins.bool enable_secure_boot: Default: false
+        """
+        if enable_integrity_monitoring is not None:
+            pulumi.set(__self__, "enable_integrity_monitoring", enable_integrity_monitoring)
+        if enable_secure_boot is not None:
+            pulumi.set(__self__, "enable_secure_boot", enable_secure_boot)
+
+    @_builtins.property
+    @pulumi.getter(name="enableIntegrityMonitoring")
+    def enable_integrity_monitoring(self) -> Optional[_builtins.bool]:
+        """
+        Default: false
+        """
+        return pulumi.get(self, "enable_integrity_monitoring")
+
+    @_builtins.property
+    @pulumi.getter(name="enableSecureBoot")
+    def enable_secure_boot(self) -> Optional[_builtins.bool]:
+        """
+        Default: false
+        """
+        return pulumi.get(self, "enable_secure_boot")
+
+
 @pulumi.output_type
 class ElastigroupSubnet(dict):
     @staticmethod
@@ -1329,26 +1570,26 @@ class ElastigroupSubnet(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 region: str,
-                 subnet_names: Sequence[str]):
+                 region: _builtins.str,
+                 subnet_names: Sequence[_builtins.str]):
         """
-        :param str region: The region for the group of subnets.
-        :param Sequence[str] subnet_names: The names of the subnets in the region.
+        :param _builtins.str region: The region for the group of subnets.
+        :param Sequence[_builtins.str] subnet_names: The names of the subnets in the region.
         """
         pulumi.set(__self__, "region", region)
         pulumi.set(__self__, "subnet_names", subnet_names)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def region(self) -> str:
+    def region(self) -> _builtins.str:
         """
         The region for the group of subnets.
         """
         return pulumi.get(self, "region")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="subnetNames")
-    def subnet_names(self) -> Sequence[str]:
+    def subnet_names(self) -> Sequence[_builtins.str]:
         """
         The names of the subnets in the region.
         """