pulumi-spotinst 3.115.0a1742873189__py3-none-any.whl → 3.128.0a1767140134__py3-none-any.whl

pulumi_spotinst/ecs/outputs.py

@@ -1,8 +1,8 @@
 # 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
@@ -79,25 +79,25 @@ class OceanAutoscaler(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 auto_headroom_percentage: Optional[int] = None,
-                 cooldown: Optional[int] = None,
+                 auto_headroom_percentage: Optional[_builtins.int] = None,
+                 cooldown: Optional[_builtins.int] = None,
                  down: Optional['outputs.OceanAutoscalerDown'] = None,
-                 enable_automatic_and_manual_headroom: Optional[bool] = None,
+                 enable_automatic_and_manual_headroom: Optional[_builtins.bool] = None,
                  headroom: Optional['outputs.OceanAutoscalerHeadroom'] = None,
-                 is_auto_config: Optional[bool] = None,
-                 is_enabled: Optional[bool] = None,
+                 is_auto_config: Optional[_builtins.bool] = None,
+                 is_enabled: Optional[_builtins.bool] = None,
                  resource_limits: Optional['outputs.OceanAutoscalerResourceLimits'] = None,
-                 should_scale_down_non_service_tasks: Optional[bool] = None):
+                 should_scale_down_non_service_tasks: Optional[_builtins.bool] = None):
         """
-        :param int auto_headroom_percentage: The auto-headroom percentage. Set a number between 0-200 to control the headroom % of the cluster. Relevant when `isAutoConfig`= true.
-        :param int cooldown: Cooldown period between scaling actions.
+        :param _builtins.int auto_headroom_percentage: The auto-headroom percentage. Set a number between 0-200 to control the headroom % of the cluster. Relevant when `isAutoConfig`= true.
+        :param _builtins.int cooldown: Cooldown period between scaling actions.
         :param 'OceanAutoscalerDownArgs' down: Auto Scaling scale down operations.
-        :param bool enable_automatic_and_manual_headroom: When set to true, both automatic and per custom launch specification manual headroom to be saved concurrently and independently in the cluster. prerequisite: isAutoConfig must be true
+        :param _builtins.bool enable_automatic_and_manual_headroom: When set to true, both automatic and per custom launch specification manual headroom to be saved concurrently and independently in the cluster. prerequisite: isAutoConfig must be true
         :param 'OceanAutoscalerHeadroomArgs' headroom: Spare resource capacity management enabling fast assignment of tasks without waiting for new resources to launch.
-        :param bool is_auto_config: Automatically configure and optimize headroom resources.
-        :param bool is_enabled: Enable the Ocean ECS autoscaler.
+        :param _builtins.bool is_auto_config: Automatically configure and optimize headroom resources.
+        :param _builtins.bool is_enabled: Enable the Ocean ECS autoscaler.
         :param 'OceanAutoscalerResourceLimitsArgs' resource_limits: Optionally set upper and lower bounds on the resource usage of the cluster.
-        :param bool should_scale_down_non_service_tasks: Option to scale down non-service tasks. If not set, Ocean does not scale down standalone tasks.
+        :param _builtins.bool should_scale_down_non_service_tasks: Option to scale down non-service tasks. If not set, Ocean does not scale down standalone tasks.
         """
         if auto_headroom_percentage is not None:
             pulumi.set(__self__, "auto_headroom_percentage", auto_headroom_percentage)
@@ -118,23 +118,23 @@ class OceanAutoscaler(dict):
         if should_scale_down_non_service_tasks is not None:
             pulumi.set(__self__, "should_scale_down_non_service_tasks", should_scale_down_non_service_tasks)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="autoHeadroomPercentage")
-    def auto_headroom_percentage(self) -> Optional[int]:
+    def auto_headroom_percentage(self) -> Optional[_builtins.int]:
         """
         The auto-headroom percentage. Set a number between 0-200 to control the headroom % of the cluster. Relevant when `isAutoConfig`= true.
         """
         return pulumi.get(self, "auto_headroom_percentage")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def cooldown(self) -> Optional[int]:
+    def cooldown(self) -> Optional[_builtins.int]:
         """
         Cooldown period between scaling actions.
         """
         return pulumi.get(self, "cooldown")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def down(self) -> Optional['outputs.OceanAutoscalerDown']:
         """
@@ -142,15 +142,15 @@ class OceanAutoscaler(dict):
         """
         return pulumi.get(self, "down")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="enableAutomaticAndManualHeadroom")
-    def enable_automatic_and_manual_headroom(self) -> Optional[bool]:
+    def enable_automatic_and_manual_headroom(self) -> Optional[_builtins.bool]:
         """
         When set to true, both automatic and per custom launch specification manual headroom to be saved concurrently and independently in the cluster. prerequisite: isAutoConfig must be true
         """
         return pulumi.get(self, "enable_automatic_and_manual_headroom")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def headroom(self) -> Optional['outputs.OceanAutoscalerHeadroom']:
         """
@@ -158,23 +158,23 @@ class OceanAutoscaler(dict):
         """
         return pulumi.get(self, "headroom")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="isAutoConfig")
-    def is_auto_config(self) -> Optional[bool]:
+    def is_auto_config(self) -> Optional[_builtins.bool]:
         """
         Automatically configure and optimize headroom resources.
         """
         return pulumi.get(self, "is_auto_config")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="isEnabled")
-    def is_enabled(self) -> Optional[bool]:
+    def is_enabled(self) -> Optional[_builtins.bool]:
         """
         Enable the Ocean ECS autoscaler.
         """
         return pulumi.get(self, "is_enabled")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="resourceLimits")
     def resource_limits(self) -> Optional['outputs.OceanAutoscalerResourceLimits']:
         """
@@ -182,9 +182,9 @@ class OceanAutoscaler(dict):
         """
         return pulumi.get(self, "resource_limits")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="shouldScaleDownNonServiceTasks")
-    def should_scale_down_non_service_tasks(self) -> Optional[bool]:
+    def should_scale_down_non_service_tasks(self) -> Optional[_builtins.bool]:
         """
         Option to scale down non-service tasks. If not set, Ocean does not scale down standalone tasks.
         """
@@ -211,16 +211,16 @@ class OceanAutoscalerDown(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 max_scale_down_percentage: Optional[float] = None):
+                 max_scale_down_percentage: Optional[_builtins.float] = None):
         """
-        :param float max_scale_down_percentage: Would represent the maximum % to scale-down. Number between 1-100.
+        :param _builtins.float max_scale_down_percentage: Would represent the maximum % to scale-down. Number between 1-100.
         """
         if max_scale_down_percentage is not None:
             pulumi.set(__self__, "max_scale_down_percentage", max_scale_down_percentage)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="maxScaleDownPercentage")
-    def max_scale_down_percentage(self) -> Optional[float]:
+    def max_scale_down_percentage(self) -> Optional[_builtins.float]:
         """
         Would represent the maximum % to scale-down. Number between 1-100.
         """
@@ -251,13 +251,13 @@ class OceanAutoscalerHeadroom(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):
         """
-        :param int cpu_per_unit: Optionally configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
-        :param int memory_per_unit: Optionally configure the amount of memory (MB) to allocate the headroom.
-        :param int num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
+        :param _builtins.int cpu_per_unit: Optionally configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
+        :param _builtins.int memory_per_unit: Optionally configure the amount of memory (MB) to allocate the headroom.
+        :param _builtins.int num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
         """
         if cpu_per_unit is not None:
             pulumi.set(__self__, "cpu_per_unit", cpu_per_unit)
@@ -266,25 +266,25 @@ class OceanAutoscalerHeadroom(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]:
         """
         Optionally configure the number of CPUs to allocate the headroom. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
         """
         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]:
         """
         Optionally configure the amount of memory (MB) to allocate the headroom.
         """
         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]:
         """
         The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
         """
@@ -313,28 +313,28 @@ class OceanAutoscalerResourceLimits(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 max_memory_gib: Optional[int] = None,
-                 max_vcpu: Optional[int] = None):
+                 max_memory_gib: Optional[_builtins.int] = None,
+                 max_vcpu: Optional[_builtins.int] = None):
         """
-        :param int max_memory_gib: The maximum memory in GiB units that can be allocated to the cluster.
-        :param int max_vcpu: The maximum cpu in vCPU units that can be allocated to the cluster.
+        :param _builtins.int max_memory_gib: The maximum memory in GiB units that can be allocated to the cluster.
+        :param _builtins.int max_vcpu: The maximum cpu in vCPU units that can be allocated to the cluster.
         """
         if max_memory_gib is not None:
             pulumi.set(__self__, "max_memory_gib", max_memory_gib)
         if max_vcpu is not None:
             pulumi.set(__self__, "max_vcpu", max_vcpu)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="maxMemoryGib")
-    def max_memory_gib(self) -> Optional[int]:
+    def max_memory_gib(self) -> Optional[_builtins.int]:
         """
         The maximum memory in GiB units that can be allocated to the cluster.
         """
         return pulumi.get(self, "max_memory_gib")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="maxVcpu")
-    def max_vcpu(self) -> Optional[int]:
+    def max_vcpu(self) -> Optional[_builtins.int]:
         """
         The maximum cpu in vCPU units that can be allocated to the cluster.
         """
@@ -365,14 +365,14 @@ class OceanBlockDeviceMapping(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 device_name: str,
+                 device_name: _builtins.str,
                  ebs: Optional['outputs.OceanBlockDeviceMappingEbs'] = None,
-                 no_device: Optional[str] = None,
-                 virtual_name: Optional[str] = None):
+                 no_device: Optional[_builtins.str] = None,
+                 virtual_name: Optional[_builtins.str] = None):
         """
-        :param str device_name: String. Set device name. Example: `/dev/xvda1`.
+        :param _builtins.str device_name: String. Set device name. Example: `/dev/xvda1`.
         :param 'OceanBlockDeviceMappingEbsArgs' ebs: Object. Set Elastic Block Store properties.
-        :param str no_device: String. Suppresses the specified device included in the block device mapping of the AMI.
+        :param _builtins.str no_device: String. Suppresses the specified device included in the block device mapping of the AMI.
         """
         pulumi.set(__self__, "device_name", device_name)
         if ebs is not None:
@@ -382,15 +382,15 @@ class OceanBlockDeviceMapping(dict):
         if virtual_name is not None:
             pulumi.set(__self__, "virtual_name", virtual_name)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="deviceName")
-    def device_name(self) -> str:
+    def device_name(self) -> _builtins.str:
         """
         String. Set device name. Example: `/dev/xvda1`.
         """
         return pulumi.get(self, "device_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def ebs(self) -> Optional['outputs.OceanBlockDeviceMappingEbs']:
         """
@@ -398,17 +398,17 @@ class OceanBlockDeviceMapping(dict):
         """
         return pulumi.get(self, "ebs")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="noDevice")
-    def no_device(self) -> Optional[str]:
+    def no_device(self) -> Optional[_builtins.str]:
         """
         String. Suppresses the specified device included in the block device mapping of the AMI.
         """
         return pulumi.get(self, "no_device")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="virtualName")
-    def virtual_name(self) -> Optional[str]:
+    def virtual_name(self) -> Optional[_builtins.str]:
         return pulumi.get(self, "virtual_name")
 
 
@@ -442,25 +442,25 @@ class OceanBlockDeviceMappingEbs(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 delete_on_termination: Optional[bool] = None,
+                 delete_on_termination: Optional[_builtins.bool] = None,
                  dynamic_volume_size: Optional['outputs.OceanBlockDeviceMappingEbsDynamicVolumeSize'] = None,
-                 encrypted: Optional[bool] = None,
-                 iops: Optional[int] = None,
-                 kms_key_id: Optional[str] = None,
-                 snapshot_id: Optional[str] = None,
-                 throughput: Optional[int] = None,
-                 volume_size: Optional[int] = None,
-                 volume_type: Optional[str] = None):
-        """
-        :param bool delete_on_termination: Boolean. Toggles EBS deletion upon instance termination.
+                 encrypted: Optional[_builtins.bool] = None,
+                 iops: Optional[_builtins.int] = None,
+                 kms_key_id: Optional[_builtins.str] = None,
+                 snapshot_id: Optional[_builtins.str] = None,
+                 throughput: Optional[_builtins.int] = None,
+                 volume_size: Optional[_builtins.int] = None,
+                 volume_type: Optional[_builtins.str] = None):
+        """
+        :param _builtins.bool delete_on_termination: Boolean. Toggles EBS deletion upon instance termination.
         :param 'OceanBlockDeviceMappingEbsDynamicVolumeSizeArgs' dynamic_volume_size: Object. Set dynamic volume size properties. When using this object, you cannot use volumeSize. You must use one or the other.
-        :param bool encrypted: Boolean. Enables [EBS encryption](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html) on the volume.
-        :param int iops: Int. The number of I/O operations per second (IOPS) that the volume supports.
-        :param str kms_key_id: String. Identifier (key ID, key alias, ID ARN, or alias ARN) for a customer managed CMK under which the EBS volume is encrypted.
-        :param str snapshot_id: (Optional) String. The snapshot ID to mount by.
-        :param int throughput: The amount of data transferred to or from a storage device per second, you can use this param just in a case that `volume_type` = gp3.
-        :param int volume_size: Int. The size (in GB) of the volume.
-        :param str volume_type: String. The type of the volume. Example: `gp2`.
+        :param _builtins.bool encrypted: Boolean. Enables [EBS encryption](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html) on the volume.
+        :param _builtins.int iops: Int. The number of I/O operations per second (IOPS) that the volume supports.
+        :param _builtins.str kms_key_id: String. Identifier (key ID, key alias, ID ARN, or alias ARN) for a customer managed CMK under which the EBS volume is encrypted.
+        :param _builtins.str snapshot_id: (Optional) String. The snapshot ID to mount by.
+        :param _builtins.int throughput: The amount of data transferred to or from a storage device per second, you can use this param just in a case that `volume_type` = gp3.
+        :param _builtins.int volume_size: Int. The size (in GB) of the volume.
+        :param _builtins.str volume_type: String. The type of the volume. Example: `gp2`.
         """
         if delete_on_termination is not None:
             pulumi.set(__self__, "delete_on_termination", delete_on_termination)
@@ -481,15 +481,15 @@ class OceanBlockDeviceMappingEbs(dict):
         if volume_type is not None:
             pulumi.set(__self__, "volume_type", volume_type)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="deleteOnTermination")
-    def delete_on_termination(self) -> Optional[bool]:
+    def delete_on_termination(self) -> Optional[_builtins.bool]:
         """
         Boolean. Toggles EBS deletion upon instance termination.
         """
         return pulumi.get(self, "delete_on_termination")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="dynamicVolumeSize")
     def dynamic_volume_size(self) -> Optional['outputs.OceanBlockDeviceMappingEbsDynamicVolumeSize']:
         """
@@ -497,57 +497,57 @@ class OceanBlockDeviceMappingEbs(dict):
         """
         return pulumi.get(self, "dynamic_volume_size")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def encrypted(self) -> Optional[bool]:
+    def encrypted(self) -> Optional[_builtins.bool]:
         """
         Boolean. Enables [EBS encryption](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html) on the volume.
         """
         return pulumi.get(self, "encrypted")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def iops(self) -> Optional[int]:
+    def iops(self) -> Optional[_builtins.int]:
         """
         Int. The number of I/O operations per second (IOPS) that the volume supports.
         """
         return pulumi.get(self, "iops")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="kmsKeyId")
-    def kms_key_id(self) -> Optional[str]:
+    def kms_key_id(self) -> Optional[_builtins.str]:
         """
         String. Identifier (key ID, key alias, ID ARN, or alias ARN) for a customer managed CMK under which the EBS volume is encrypted.
         """
         return pulumi.get(self, "kms_key_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="snapshotId")
-    def snapshot_id(self) -> Optional[str]:
+    def snapshot_id(self) -> Optional[_builtins.str]:
         """
         (Optional) String. The snapshot ID to mount by.
         """
         return pulumi.get(self, "snapshot_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def throughput(self) -> Optional[int]:
+    def throughput(self) -> Optional[_builtins.int]:
         """
         The amount of data transferred to or from a storage device per second, you can use this param just in a case that `volume_type` = gp3.
         """
         return pulumi.get(self, "throughput")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="volumeSize")
-    def volume_size(self) -> Optional[int]:
+    def volume_size(self) -> Optional[_builtins.int]:
         """
         Int. The size (in GB) of the volume.
         """
         return pulumi.get(self, "volume_size")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="volumeType")
-    def volume_type(self) -> Optional[str]:
+    def volume_type(self) -> Optional[_builtins.str]:
         """
         String. The type of the volume. Example: `gp2`.
         """
@@ -576,37 +576,37 @@ class OceanBlockDeviceMappingEbsDynamicVolumeSize(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 base_size: int,
-                 resource: str,
-                 size_per_resource_unit: int):
+                 base_size: _builtins.int,
+                 resource: _builtins.str,
+                 size_per_resource_unit: _builtins.int):
         """
-        :param int base_size: Int. Initial size for volume. Example: `50`.
-        :param str resource: String. Resource type to increase volume size dynamically by. Valid values: `CPU`.
-        :param int size_per_resource_unit: Int. Additional size (in GB) per resource unit. Example: When the `baseSize=50`, `sizePerResourceUnit=20`, and instance with two CPUs is launched, its total disk size will be: 90GB.
+        :param _builtins.int base_size: Int. Initial size for volume. Example: `50`.
+        :param _builtins.str resource: String. Resource type to increase volume size dynamically by. Valid values: `CPU`.
+        :param _builtins.int size_per_resource_unit: Int. Additional size (in GB) per resource unit. Example: When the `baseSize=50`, `sizePerResourceUnit=20`, and instance with two CPUs is launched, its total disk size will be: 90GB.
         """
         pulumi.set(__self__, "base_size", base_size)
         pulumi.set(__self__, "resource", resource)
         pulumi.set(__self__, "size_per_resource_unit", size_per_resource_unit)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="baseSize")
-    def base_size(self) -> int:
+    def base_size(self) -> _builtins.int:
         """
         Int. Initial size for volume. Example: `50`.
         """
         return pulumi.get(self, "base_size")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def resource(self) -> str:
+    def resource(self) -> _builtins.str:
         """
         String. Resource type to increase volume size dynamically by. Valid values: `CPU`.
         """
         return pulumi.get(self, "resource")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="sizePerResourceUnit")
-    def size_per_resource_unit(self) -> int:
+    def size_per_resource_unit(self) -> _builtins.int:
         """
         Int. Additional size (in GB) per resource unit. Example: When the `baseSize=50`, `sizePerResourceUnit=20`, and instance with two CPUs is launched, its total disk size will be: 90GB.
         """
@@ -633,16 +633,16 @@ class OceanClusterOrientation(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 availability_vs_cost: Optional[str] = None):
+                 availability_vs_cost: Optional[_builtins.str] = None):
         """
-        :param str availability_vs_cost: You can control the approach that Ocean takes while launching nodes by configuring this value. Possible values: `costOriented`,`balanced`,`cheapest`.
+        :param _builtins.str availability_vs_cost: You can control the approach that Ocean takes while launching nodes by configuring this value. Possible values: `costOriented`,`balanced`,`cheapest`.
         """
         if availability_vs_cost is not None:
             pulumi.set(__self__, "availability_vs_cost", availability_vs_cost)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="availabilityVsCost")
-    def availability_vs_cost(self) -> Optional[str]:
+    def availability_vs_cost(self) -> Optional[_builtins.str]:
         """
         You can control the approach that Ocean takes while launching nodes by configuring this value. Possible values: `costOriented`,`balanced`,`cheapest`.
         """
@@ -699,43 +699,43 @@ class OceanFilters(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 architectures: Optional[Sequence[str]] = None,
-                 categories: Optional[Sequence[str]] = None,
-                 disk_types: Optional[Sequence[str]] = None,
-                 exclude_families: Optional[Sequence[str]] = None,
-                 exclude_metal: Optional[bool] = None,
-                 hypervisors: Optional[Sequence[str]] = None,
-                 include_families: Optional[Sequence[str]] = None,
-                 is_ena_supported: Optional[str] = None,
-                 max_gpu: Optional[int] = None,
-                 max_memory_gib: Optional[float] = None,
-                 max_network_performance: Optional[int] = None,
-                 max_vcpu: Optional[int] = None,
-                 min_enis: Optional[int] = None,
-                 min_gpu: Optional[int] = None,
-                 min_memory_gib: Optional[float] = None,
-                 min_network_performance: Optional[int] = None,
-                 min_vcpu: Optional[int] = None,
-                 root_device_types: Optional[Sequence[str]] = None,
-                 virtualization_types: Optional[Sequence[str]] = None):
-        """
-        :param Sequence[str] architectures: The filtered instance types will support at least one of the architectures from this list.
-        :param Sequence[str] categories: The filtered instance types will belong to one of the categories types from this list.
-        :param Sequence[str] disk_types: The filtered instance types will have one of the disk type from this list.
-        :param Sequence[str] exclude_families: Types belonging to a family from the ExcludeFamilies will not be available for scaling (asterisk wildcard is also supported). For example, C* will exclude instance types from these families: c5, c4, c4a, etc.
-        :param bool exclude_metal: In case excludeMetal is set to true, metal types will not be available for scaling.
-        :param Sequence[str] hypervisors: The filtered instance types will have a hypervisor type from this list.
-        :param Sequence[str] include_families: Types belonging to a family from the IncludeFamilies will be available for scaling (asterisk wildcard is also supported). For example, C* will include instance types from these families: c5, c4, c4a, etc.
-        :param str is_ena_supported: Ena is supported or not.
-        :param int max_gpu: Maximum total number of GPUs.
-        :param int max_network_performance: Maximum Bandwidth in Gib/s of network performance.
-        :param int min_enis: Minimum number of network interfaces (ENIs).
-        :param int min_gpu: Minimum total number of GPUs.
-        :param float min_memory_gib: Minimum amount of Memory (GiB).
-        :param int min_network_performance: Minimum Bandwidth in Gib/s of network performance.
-        :param int min_vcpu: Minimum number of vcpus available.
-        :param Sequence[str] root_device_types: The filtered instance types will have a root device types from this list.
-        :param Sequence[str] virtualization_types: The filtered instance types will support at least one of the virtualization types from this list.
+                 architectures: Optional[Sequence[_builtins.str]] = None,
+                 categories: Optional[Sequence[_builtins.str]] = None,
+                 disk_types: Optional[Sequence[_builtins.str]] = None,
+                 exclude_families: Optional[Sequence[_builtins.str]] = None,
+                 exclude_metal: Optional[_builtins.bool] = None,
+                 hypervisors: Optional[Sequence[_builtins.str]] = None,
+                 include_families: Optional[Sequence[_builtins.str]] = None,
+                 is_ena_supported: Optional[_builtins.str] = None,
+                 max_gpu: Optional[_builtins.int] = None,
+                 max_memory_gib: Optional[_builtins.float] = None,
+                 max_network_performance: Optional[_builtins.int] = None,
+                 max_vcpu: Optional[_builtins.int] = None,
+                 min_enis: Optional[_builtins.int] = None,
+                 min_gpu: Optional[_builtins.int] = None,
+                 min_memory_gib: Optional[_builtins.float] = None,
+                 min_network_performance: Optional[_builtins.int] = None,
+                 min_vcpu: Optional[_builtins.int] = None,
+                 root_device_types: Optional[Sequence[_builtins.str]] = None,
+                 virtualization_types: Optional[Sequence[_builtins.str]] = None):
+        """
+        :param Sequence[_builtins.str] architectures: The filtered instance types will support at least one of the architectures from this list.
+        :param Sequence[_builtins.str] categories: The filtered instance types will belong to one of the categories types from this list.
+        :param Sequence[_builtins.str] disk_types: The filtered instance types will have one of the disk type from this list.
+        :param Sequence[_builtins.str] exclude_families: Types belonging to a family from the ExcludeFamilies will not be available for scaling (asterisk wildcard is also supported). For example, C* will exclude instance types from these families: c5, c4, c4a, etc.
+        :param _builtins.bool exclude_metal: In case excludeMetal is set to true, metal types will not be available for scaling.
+        :param Sequence[_builtins.str] hypervisors: The filtered instance types will have a hypervisor type from this list.
+        :param Sequence[_builtins.str] include_families: Types belonging to a family from the IncludeFamilies will be available for scaling (asterisk wildcard is also supported). For example, C* will include instance types from these families: c5, c4, c4a, etc.
+        :param _builtins.str is_ena_supported: Ena is supported or not.
+        :param _builtins.int max_gpu: Maximum total number of GPUs.
+        :param _builtins.int max_network_performance: Maximum Bandwidth in Gib/s of network performance.
+        :param _builtins.int min_enis: Minimum number of network interfaces (ENIs).
+        :param _builtins.int min_gpu: Minimum total number of GPUs.
+        :param _builtins.float min_memory_gib: Minimum amount of Memory (GiB).
+        :param _builtins.int min_network_performance: Minimum Bandwidth in Gib/s of network performance.
+        :param _builtins.int min_vcpu: Minimum number of vcpus available.
+        :param Sequence[_builtins.str] root_device_types: The filtered instance types will have a root device types from this list.
+        :param Sequence[_builtins.str] virtualization_types: The filtered instance types will support at least one of the virtualization types from this list.
         """
         if architectures is not None:
             pulumi.set(__self__, "architectures", architectures)
@@ -776,147 +776,147 @@ class OceanFilters(dict):
         if virtualization_types is not None:
             pulumi.set(__self__, "virtualization_types", virtualization_types)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def architectures(self) -> Optional[Sequence[str]]:
+    def architectures(self) -> Optional[Sequence[_builtins.str]]:
         """
         The filtered instance types will support at least one of the architectures from this list.
         """
         return pulumi.get(self, "architectures")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def categories(self) -> Optional[Sequence[str]]:
+    def categories(self) -> Optional[Sequence[_builtins.str]]:
         """
         The filtered instance types will belong to one of the categories types from this list.
         """
         return pulumi.get(self, "categories")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="diskTypes")
-    def disk_types(self) -> Optional[Sequence[str]]:
+    def disk_types(self) -> Optional[Sequence[_builtins.str]]:
         """
         The filtered instance types will have one of the disk type from this list.
         """
         return pulumi.get(self, "disk_types")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="excludeFamilies")
-    def exclude_families(self) -> Optional[Sequence[str]]:
+    def exclude_families(self) -> Optional[Sequence[_builtins.str]]:
         """
         Types belonging to a family from the ExcludeFamilies will not be available for scaling (asterisk wildcard is also supported). For example, C* will exclude instance types from these families: c5, c4, c4a, etc.
         """
         return pulumi.get(self, "exclude_families")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="excludeMetal")
-    def exclude_metal(self) -> Optional[bool]:
+    def exclude_metal(self) -> Optional[_builtins.bool]:
         """
         In case excludeMetal is set to true, metal types will not be available for scaling.
         """
         return pulumi.get(self, "exclude_metal")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def hypervisors(self) -> Optional[Sequence[str]]:
+    def hypervisors(self) -> Optional[Sequence[_builtins.str]]:
         """
         The filtered instance types will have a hypervisor type from this list.
         """
         return pulumi.get(self, "hypervisors")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="includeFamilies")
-    def include_families(self) -> Optional[Sequence[str]]:
+    def include_families(self) -> Optional[Sequence[_builtins.str]]:
         """
         Types belonging to a family from the IncludeFamilies will be available for scaling (asterisk wildcard is also supported). For example, C* will include instance types from these families: c5, c4, c4a, etc.
         """
         return pulumi.get(self, "include_families")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="isEnaSupported")
-    def is_ena_supported(self) -> Optional[str]:
+    def is_ena_supported(self) -> Optional[_builtins.str]:
         """
         Ena is supported or not.
         """
         return pulumi.get(self, "is_ena_supported")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="maxGpu")
-    def max_gpu(self) -> Optional[int]:
+    def max_gpu(self) -> Optional[_builtins.int]:
         """
         Maximum total number of GPUs.
         """
         return pulumi.get(self, "max_gpu")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="maxMemoryGib")
-    def max_memory_gib(self) -> Optional[float]:
+    def max_memory_gib(self) -> Optional[_builtins.float]:
         return pulumi.get(self, "max_memory_gib")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="maxNetworkPerformance")
-    def max_network_performance(self) -> Optional[int]:
+    def max_network_performance(self) -> Optional[_builtins.int]:
         """
         Maximum Bandwidth in Gib/s of network performance.
         """
         return pulumi.get(self, "max_network_performance")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="maxVcpu")
-    def max_vcpu(self) -> Optional[int]:
+    def max_vcpu(self) -> Optional[_builtins.int]:
         return pulumi.get(self, "max_vcpu")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="minEnis")
-    def min_enis(self) -> Optional[int]:
+    def min_enis(self) -> Optional[_builtins.int]:
         """
         Minimum number of network interfaces (ENIs).
         """
         return pulumi.get(self, "min_enis")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="minGpu")
-    def min_gpu(self) -> Optional[int]:
+    def min_gpu(self) -> Optional[_builtins.int]:
         """
         Minimum total number of GPUs.
         """
         return pulumi.get(self, "min_gpu")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="minMemoryGib")
-    def min_memory_gib(self) -> Optional[float]:
+    def min_memory_gib(self) -> Optional[_builtins.float]:
         """
         Minimum amount of Memory (GiB).
         """
         return pulumi.get(self, "min_memory_gib")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="minNetworkPerformance")
-    def min_network_performance(self) -> Optional[int]:
+    def min_network_performance(self) -> Optional[_builtins.int]:
         """
         Minimum Bandwidth in Gib/s of network performance.
         """
         return pulumi.get(self, "min_network_performance")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="minVcpu")
-    def min_vcpu(self) -> Optional[int]:
+    def min_vcpu(self) -> Optional[_builtins.int]:
         """
         Minimum number of vcpus available.
         """
         return pulumi.get(self, "min_vcpu")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="rootDeviceTypes")
-    def root_device_types(self) -> Optional[Sequence[str]]:
+    def root_device_types(self) -> Optional[Sequence[_builtins.str]]:
         """
         The filtered instance types will have a root device types from this list.
         """
         return pulumi.get(self, "root_device_types")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="virtualizationTypes")
-    def virtualization_types(self) -> Optional[Sequence[str]]:
+    def virtualization_types(self) -> Optional[Sequence[_builtins.str]]:
         """
         The filtered instance types will support at least one of the virtualization types from this list.
         """
@@ -945,27 +945,27 @@ class OceanInstanceMetadataOptions(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 http_tokens: str,
-                 http_put_response_hop_limit: Optional[int] = None):
+                 http_tokens: _builtins.str,
+                 http_put_response_hop_limit: Optional[_builtins.int] = None):
         """
-        :param str http_tokens: Determines if a signed token is required or not. Valid values: `optional` or `required`.
-        :param int http_put_response_hop_limit: An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
+        :param _builtins.str http_tokens: Determines if a signed token is required or not. Valid values: `optional` or `required`.
+        :param _builtins.int http_put_response_hop_limit: An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
         """
         pulumi.set(__self__, "http_tokens", http_tokens)
         if http_put_response_hop_limit is not None:
             pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpTokens")
-    def http_tokens(self) -> str:
+    def http_tokens(self) -> _builtins.str:
         """
         Determines if a signed token is required or not. Valid values: `optional` or `required`.
         """
         return pulumi.get(self, "http_tokens")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpPutResponseHopLimit")
-    def http_put_response_hop_limit(self) -> Optional[int]:
+    def http_put_response_hop_limit(self) -> Optional[_builtins.int]:
         """
         An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
         """
@@ -975,26 +975,26 @@ class OceanInstanceMetadataOptions(dict):
 @pulumi.output_type
 class OceanLaunchSpecAttribute(dict):
     def __init__(__self__, *,
-                 key: str,
-                 value: str):
+                 key: _builtins.str,
+                 value: _builtins.str):
         """
-        :param str key: The label key.
-        :param str value: The label value.
+        :param _builtins.str key: The label key.
+        :param _builtins.str value: The label 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:
         """
         The label key.
         """
         return pulumi.get(self, "key")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> str:
+    def value(self) -> _builtins.str:
         """
         The label value.
         """
@@ -1025,13 +1025,13 @@ class OceanLaunchSpecAutoscaleHeadroom(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 num_of_units: int,
-                 cpu_per_unit: Optional[int] = None,
-                 memory_per_unit: Optional[int] = None):
+                 num_of_units: _builtins.int,
+                 cpu_per_unit: Optional[_builtins.int] = None,
+                 memory_per_unit: Optional[_builtins.int] = None):
         """
-        :param int num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
-        :param int cpu_per_unit: Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in CPU units, where 1024 units = 1 vCPU.
-        :param int memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
+        :param _builtins.int num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
+        :param _builtins.int cpu_per_unit: Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in CPU units, where 1024 units = 1 vCPU.
+        :param _builtins.int memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
         """
         pulumi.set(__self__, "num_of_units", num_of_units)
         if cpu_per_unit is not None:
@@ -1039,25 +1039,25 @@ class OceanLaunchSpecAutoscaleHeadroom(dict):
         if memory_per_unit is not None:
             pulumi.set(__self__, "memory_per_unit", memory_per_unit)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="numOfUnits")
-    def num_of_units(self) -> int:
+    def num_of_units(self) -> _builtins.int:
         """
         The number of units to retain as headroom, where each unit has the defined headroom CPU and memory.
         """
         return pulumi.get(self, "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]:
         """
         Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in CPU units, where 1024 units = 1 vCPU.
         """
         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]:
         """
         Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
         """
@@ -1088,14 +1088,14 @@ class OceanLaunchSpecBlockDeviceMapping(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 device_name: str,
+                 device_name: _builtins.str,
                  ebs: Optional['outputs.OceanLaunchSpecBlockDeviceMappingEbs'] = None,
-                 no_device: Optional[str] = None,
-                 virtual_name: Optional[str] = None):
+                 no_device: Optional[_builtins.str] = None,
+                 virtual_name: Optional[_builtins.str] = None):
         """
-        :param str device_name: String. Set device name. (Example: "/dev/xvda1").
+        :param _builtins.str device_name: String. Set device name. (Example: "/dev/xvda1").
         :param 'OceanLaunchSpecBlockDeviceMappingEbsArgs' ebs: Object. Set Elastic Block Store properties .
-        :param str no_device: String. suppresses the specified device included in the block device mapping of the AMI.
+        :param _builtins.str no_device: String. suppresses the specified device included in the block device mapping of the AMI.
         """
         pulumi.set(__self__, "device_name", device_name)
         if ebs is not None:
@@ -1105,15 +1105,15 @@ class OceanLaunchSpecBlockDeviceMapping(dict):
         if virtual_name is not None:
             pulumi.set(__self__, "virtual_name", virtual_name)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="deviceName")
-    def device_name(self) -> str:
+    def device_name(self) -> _builtins.str:
         """
         String. Set device name. (Example: "/dev/xvda1").
         """
         return pulumi.get(self, "device_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def ebs(self) -> Optional['outputs.OceanLaunchSpecBlockDeviceMappingEbs']:
         """
@@ -1121,17 +1121,17 @@ class OceanLaunchSpecBlockDeviceMapping(dict):
         """
         return pulumi.get(self, "ebs")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="noDevice")
-    def no_device(self) -> Optional[str]:
+    def no_device(self) -> Optional[_builtins.str]:
         """
         String. suppresses the specified device included in the block device mapping of the AMI.
         """
         return pulumi.get(self, "no_device")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="virtualName")
-    def virtual_name(self) -> Optional[str]:
+    def virtual_name(self) -> Optional[_builtins.str]:
         return pulumi.get(self, "virtual_name")
 
 
@@ -1165,25 +1165,25 @@ class OceanLaunchSpecBlockDeviceMappingEbs(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 delete_on_termination: Optional[bool] = None,
+                 delete_on_termination: Optional[_builtins.bool] = None,
                  dynamic_volume_size: Optional['outputs.OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSize'] = None,
-                 encrypted: Optional[bool] = None,
-                 iops: Optional[int] = None,
-                 kms_key_id: Optional[str] = None,
-                 snapshot_id: Optional[str] = None,
-                 throughput: Optional[int] = None,
-                 volume_size: Optional[int] = None,
-                 volume_type: Optional[str] = None):
-        """
-        :param bool delete_on_termination: Boolean. Flag to delete the EBS on instance termination.
+                 encrypted: Optional[_builtins.bool] = None,
+                 iops: Optional[_builtins.int] = None,
+                 kms_key_id: Optional[_builtins.str] = None,
+                 snapshot_id: Optional[_builtins.str] = None,
+                 throughput: Optional[_builtins.int] = None,
+                 volume_size: Optional[_builtins.int] = None,
+                 volume_type: Optional[_builtins.str] = None):
+        """
+        :param _builtins.bool delete_on_termination: Boolean. Flag to delete the EBS on instance termination.
         :param 'OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSizeArgs' dynamic_volume_size: Object. Set dynamic volume size properties. When using this object, you cannot use volumeSize. You must use one or the other.
-        :param bool encrypted: Boolean. Enables [EBS encryption](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html) on the volume.
-        :param int iops: Int. The number of I/O operations per second (IOPS) that the volume supports.
-        :param str kms_key_id: String. Identifier (key ID, key alias, ID ARN, or alias ARN) for a customer managed CMK under which the EBS volume is encrypted.
-        :param str snapshot_id: (Optional) String. The Snapshot ID to mount by.
-        :param int throughput: The amount of data transferred to or from a storage device per second, you can use this param just in a case that `volume_type` = gp3.
-        :param int volume_size: Int. The size, in GB of the volume.
-        :param str volume_type: String. The type of the volume (example: "gp2").
+        :param _builtins.bool encrypted: Boolean. Enables [EBS encryption](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html) on the volume.
+        :param _builtins.int iops: Int. The number of I/O operations per second (IOPS) that the volume supports.
+        :param _builtins.str kms_key_id: String. Identifier (key ID, key alias, ID ARN, or alias ARN) for a customer managed CMK under which the EBS volume is encrypted.
+        :param _builtins.str snapshot_id: (Optional) String. The Snapshot ID to mount by.
+        :param _builtins.int throughput: The amount of data transferred to or from a storage device per second, you can use this param just in a case that `volume_type` = gp3.
+        :param _builtins.int volume_size: Int. The size, in GB of the volume.
+        :param _builtins.str volume_type: String. The type of the volume (example: "gp2").
         """
         if delete_on_termination is not None:
             pulumi.set(__self__, "delete_on_termination", delete_on_termination)
@@ -1204,15 +1204,15 @@ class OceanLaunchSpecBlockDeviceMappingEbs(dict):
         if volume_type is not None:
             pulumi.set(__self__, "volume_type", volume_type)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="deleteOnTermination")
-    def delete_on_termination(self) -> Optional[bool]:
+    def delete_on_termination(self) -> Optional[_builtins.bool]:
         """
         Boolean. Flag to delete the EBS on instance termination.
         """
         return pulumi.get(self, "delete_on_termination")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="dynamicVolumeSize")
     def dynamic_volume_size(self) -> Optional['outputs.OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSize']:
         """
@@ -1220,57 +1220,57 @@ class OceanLaunchSpecBlockDeviceMappingEbs(dict):
         """
         return pulumi.get(self, "dynamic_volume_size")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def encrypted(self) -> Optional[bool]:
+    def encrypted(self) -> Optional[_builtins.bool]:
         """
         Boolean. Enables [EBS encryption](https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html) on the volume.
         """
         return pulumi.get(self, "encrypted")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def iops(self) -> Optional[int]:
+    def iops(self) -> Optional[_builtins.int]:
         """
         Int. The number of I/O operations per second (IOPS) that the volume supports.
         """
         return pulumi.get(self, "iops")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="kmsKeyId")
-    def kms_key_id(self) -> Optional[str]:
+    def kms_key_id(self) -> Optional[_builtins.str]:
         """
         String. Identifier (key ID, key alias, ID ARN, or alias ARN) for a customer managed CMK under which the EBS volume is encrypted.
         """
         return pulumi.get(self, "kms_key_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="snapshotId")
-    def snapshot_id(self) -> Optional[str]:
+    def snapshot_id(self) -> Optional[_builtins.str]:
         """
         (Optional) String. The Snapshot ID to mount by.
         """
         return pulumi.get(self, "snapshot_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def throughput(self) -> Optional[int]:
+    def throughput(self) -> Optional[_builtins.int]:
         """
         The amount of data transferred to or from a storage device per second, you can use this param just in a case that `volume_type` = gp3.
         """
         return pulumi.get(self, "throughput")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="volumeSize")
-    def volume_size(self) -> Optional[int]:
+    def volume_size(self) -> Optional[_builtins.int]:
         """
         Int. The size, in GB of the volume.
         """
         return pulumi.get(self, "volume_size")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="volumeType")
-    def volume_type(self) -> Optional[str]:
+    def volume_type(self) -> Optional[_builtins.str]:
         """
         String. The type of the volume (example: "gp2").
         """
@@ -1299,37 +1299,37 @@ class OceanLaunchSpecBlockDeviceMappingEbsDynamicVolumeSize(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 base_size: int,
-                 resource: str,
-                 size_per_resource_unit: int):
+                 base_size: _builtins.int,
+                 resource: _builtins.str,
+                 size_per_resource_unit: _builtins.int):
         """
-        :param int base_size: Int. Initial size for volume. (Example: 50)
-        :param str resource: String. Resource type to increase volume size dynamically by. (valid values: "CPU")
-        :param int size_per_resource_unit: Int. Additional size (in GB) per resource unit. (Example: baseSize= 50, sizePerResourceUnit=20, and instance with 2 CPU is launched - its total disk size will be: 90GB)
+        :param _builtins.int base_size: Int. Initial size for volume. (Example: 50)
+        :param _builtins.str resource: String. Resource type to increase volume size dynamically by. (valid values: "CPU")
+        :param _builtins.int size_per_resource_unit: Int. Additional size (in GB) per resource unit. (Example: baseSize= 50, sizePerResourceUnit=20, and instance with 2 CPU is launched - its total disk size will be: 90GB)
         """
         pulumi.set(__self__, "base_size", base_size)
         pulumi.set(__self__, "resource", resource)
         pulumi.set(__self__, "size_per_resource_unit", size_per_resource_unit)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="baseSize")
-    def base_size(self) -> int:
+    def base_size(self) -> _builtins.int:
         """
         Int. Initial size for volume. (Example: 50)
         """
         return pulumi.get(self, "base_size")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def resource(self) -> str:
+    def resource(self) -> _builtins.str:
         """
         String. Resource type to increase volume size dynamically by. (valid values: "CPU")
         """
         return pulumi.get(self, "resource")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="sizePerResourceUnit")
-    def size_per_resource_unit(self) -> int:
+    def size_per_resource_unit(self) -> _builtins.int:
         """
         Int. Additional size (in GB) per resource unit. (Example: baseSize= 50, sizePerResourceUnit=20, and instance with 2 CPU is launched - its total disk size will be: 90GB)
         """
@@ -1356,16 +1356,16 @@ class OceanLaunchSpecImage(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 image_id: Optional[str] = None):
+                 image_id: Optional[_builtins.str] = None):
         """
-        :param str image_id: Identifier of the image in AWS. Valid values: any string which is not empty or null.
+        :param _builtins.str image_id: Identifier of the image in AWS. Valid values: any string which is not empty or null.
         """
         if image_id is not None:
             pulumi.set(__self__, "image_id", image_id)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="imageId")
-    def image_id(self) -> Optional[str]:
+    def image_id(self) -> Optional[_builtins.str]:
         """
         Identifier of the image in AWS. Valid values: any string which is not empty or null.
         """
@@ -1394,27 +1394,27 @@ class OceanLaunchSpecInstanceMetadataOptions(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 http_tokens: str,
-                 http_put_response_hop_limit: Optional[int] = None):
+                 http_tokens: _builtins.str,
+                 http_put_response_hop_limit: Optional[_builtins.int] = None):
         """
-        :param str http_tokens: Determines if a signed token is required or not. Valid values: `optional` or `required`.
-        :param int http_put_response_hop_limit: An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
+        :param _builtins.str http_tokens: Determines if a signed token is required or not. Valid values: `optional` or `required`.
+        :param _builtins.int http_put_response_hop_limit: An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
         """
         pulumi.set(__self__, "http_tokens", http_tokens)
         if http_put_response_hop_limit is not None:
             pulumi.set(__self__, "http_put_response_hop_limit", http_put_response_hop_limit)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpTokens")
-    def http_tokens(self) -> str:
+    def http_tokens(self) -> _builtins.str:
         """
         Determines if a signed token is required or not. Valid values: `optional` or `required`.
         """
         return pulumi.get(self, "http_tokens")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="httpPutResponseHopLimit")
-    def http_put_response_hop_limit(self) -> Optional[int]:
+    def http_put_response_hop_limit(self) -> Optional[_builtins.int]:
         """
         An integer from 1 through 64. The desired HTTP PUT response hop limit for instance metadata requests. The larger the number, the further the instance metadata requests can travel.
         """
@@ -1447,14 +1447,14 @@ class OceanLaunchSpecSchedulingTask(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 cron_expression: str,
-                 is_enabled: bool,
-                 task_type: str,
+                 cron_expression: _builtins.str,
+                 is_enabled: _builtins.bool,
+                 task_type: _builtins.str,
                  task_headrooms: Optional[Sequence['outputs.OceanLaunchSpecSchedulingTaskTaskHeadroom']] = None):
         """
-        :param str cron_expression: A valid cron expression. For example : " * * * * * ". The cron job runs in UTC time and is in Unix cron format.
-        :param bool is_enabled: Describes whether the task is enabled. When `true`, the task runs. When `false`, it does not run.
-        :param str task_type: The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
+        :param _builtins.str cron_expression: A valid cron expression. For example : " * * * * * ". The cron job runs in UTC time and is in Unix cron format.
+        :param _builtins.bool is_enabled: Describes whether the task is enabled. When `true`, the task runs. When `false`, it does not run.
+        :param _builtins.str task_type: The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
         :param Sequence['OceanLaunchSpecSchedulingTaskTaskHeadroomArgs'] task_headrooms: The config of this scheduled task. Depends on the value of taskType.
         """
         pulumi.set(__self__, "cron_expression", cron_expression)
@@ -1463,31 +1463,31 @@ class OceanLaunchSpecSchedulingTask(dict):
         if task_headrooms is not None:
             pulumi.set(__self__, "task_headrooms", task_headrooms)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="cronExpression")
-    def cron_expression(self) -> str:
+    def cron_expression(self) -> _builtins.str:
         """
         A valid cron expression. For example : " * * * * * ". The cron job runs in UTC time and is in Unix cron format.
         """
         return pulumi.get(self, "cron_expression")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="isEnabled")
-    def is_enabled(self) -> bool:
+    def is_enabled(self) -> _builtins.bool:
         """
         Describes whether the task is enabled. When `true`, the task runs. When `false`, it does not run.
         """
         return pulumi.get(self, "is_enabled")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="taskType")
-    def task_type(self) -> str:
+    def task_type(self) -> _builtins.str:
         """
         The activity that you are scheduling. Valid values: "manualHeadroomUpdate".
         """
         return pulumi.get(self, "task_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="taskHeadrooms")
     def task_headrooms(self) -> Optional[Sequence['outputs.OceanLaunchSpecSchedulingTaskTaskHeadroom']]:
         """
@@ -1520,13 +1520,13 @@ class OceanLaunchSpecSchedulingTaskTaskHeadroom(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 num_of_units: int,
-                 cpu_per_unit: Optional[int] = None,
-                 memory_per_unit: Optional[int] = None):
+                 num_of_units: _builtins.int,
+                 cpu_per_unit: Optional[_builtins.int] = None,
+                 memory_per_unit: Optional[_builtins.int] = None):
         """
-        :param int num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
-        :param int cpu_per_unit: Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
-        :param int memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
+        :param _builtins.int num_of_units: The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
+        :param _builtins.int cpu_per_unit: Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
+        :param _builtins.int memory_per_unit: Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
         """
         pulumi.set(__self__, "num_of_units", num_of_units)
         if cpu_per_unit is not None:
@@ -1534,25 +1534,25 @@ class OceanLaunchSpecSchedulingTaskTaskHeadroom(dict):
         if memory_per_unit is not None:
             pulumi.set(__self__, "memory_per_unit", memory_per_unit)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="numOfUnits")
-    def num_of_units(self) -> int:
+    def num_of_units(self) -> _builtins.int:
         """
         The number of units to retain as headroom, where each unit has the defined headroom CPU, memory and GPU.
         """
         return pulumi.get(self, "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]:
         """
         Optionally configure the number of CPUs to allocate for each headroom unit. CPUs are denoted in millicores, where 1000 millicores = 1 vCPU.
         """
         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]:
         """
         Optionally configure the amount of memory (MiB) to allocate for each headroom unit.
         """
@@ -1579,16 +1579,16 @@ class OceanLaunchSpecStrategy(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 spot_percentage: Optional[int] = None):
+                 spot_percentage: Optional[_builtins.int] = None):
         """
-        :param int spot_percentage: When set, Ocean will proactively try to maintain as close as possible to the percentage of Spot instances out of all the Virtual Node Group instances.
+        :param _builtins.int spot_percentage: When set, Ocean will proactively try to maintain as close as possible to the percentage of Spot instances out of all the Virtual Node Group instances.
         """
         if spot_percentage is not None:
             pulumi.set(__self__, "spot_percentage", spot_percentage)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="spotPercentage")
-    def spot_percentage(self) -> Optional[int]:
+    def spot_percentage(self) -> Optional[_builtins.int]:
         """
         When set, Ocean will proactively try to maintain as close as possible to the percentage of Spot instances out of all the Virtual Node Group instances.
         """
@@ -1598,26 +1598,26 @@ class OceanLaunchSpecStrategy(dict):
 @pulumi.output_type
 class OceanLaunchSpecTag(dict):
     def __init__(__self__, *,
-                 key: str,
-                 value: str):
+                 key: _builtins.str,
+                 value: _builtins.str):
         """
-        :param str key: The label key.
-        :param str value: The label value.
+        :param _builtins.str key: The label key.
+        :param _builtins.str value: The label 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:
         """
         The label key.
         """
         return pulumi.get(self, "key")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> str:
+    def value(self) -> _builtins.str:
         """
         The label value.
         """
@@ -1634,7 +1634,7 @@ class OceanLogging(dict):
         if export is not None:
             pulumi.set(__self__, "export", export)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def export(self) -> Optional['outputs.OceanLoggingExport']:
         """
@@ -1653,7 +1653,7 @@ class OceanLoggingExport(dict):
         if s3s is not None:
             pulumi.set(__self__, "s3s", s3s)
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def s3s(self) -> Optional[Sequence['outputs.OceanLoggingExportS3']]:
         """
@@ -1665,15 +1665,15 @@ class OceanLoggingExport(dict):
 @pulumi.output_type
 class OceanLoggingExportS3(dict):
     def __init__(__self__, *,
-                 id: str):
+                 id: _builtins.str):
         """
-        :param str id: The identifier of The S3 data integration to export the logs to.
+        :param _builtins.str id: The identifier of The S3 data integration to export the logs to.
         """
         pulumi.set(__self__, "id", id)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> str:
+    def id(self) -> _builtins.str:
         """
         The identifier of The S3 data integration to export the logs to.
         """
@@ -1704,38 +1704,38 @@ class OceanOptimizeImages(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 perform_at: str,
-                 should_optimize_ecs_ami: bool,
-                 time_windows: Optional[Sequence[str]] = None):
+                 perform_at: _builtins.str,
+                 should_optimize_ecs_ami: _builtins.bool,
+                 time_windows: Optional[Sequence[_builtins.str]] = None):
         """
-        :param str perform_at: String. Valid values: "always" "never" "timeWindow".
-        :param bool should_optimize_ecs_ami: Boolean. Enable auto image (AMI) update for the ECS container instances. The auto update applies for ECS-Optimized AMIs.
-        :param Sequence[str] time_windows: Array of strings. Set time windows for image update, at least one time window. Each string is in the format of ddd:hh:mm-ddd:hh:mm ddd. Time windows should not overlap.
+        :param _builtins.str perform_at: String. Valid values: "always" "never" "timeWindow".
+        :param _builtins.bool should_optimize_ecs_ami: Boolean. Enable auto image (AMI) update for the ECS container instances. The auto update applies for ECS-Optimized AMIs.
+        :param Sequence[_builtins.str] time_windows: Array of strings. Set time windows for image update, at least one time window. Each string is in the format of ddd:hh:mm-ddd:hh:mm ddd. Time windows should not overlap.
         """
         pulumi.set(__self__, "perform_at", perform_at)
         pulumi.set(__self__, "should_optimize_ecs_ami", should_optimize_ecs_ami)
         if time_windows is not None:
             pulumi.set(__self__, "time_windows", time_windows)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="performAt")
-    def perform_at(self) -> str:
+    def perform_at(self) -> _builtins.str:
         """
         String. Valid values: "always" "never" "timeWindow".
         """
         return pulumi.get(self, "perform_at")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="shouldOptimizeEcsAmi")
-    def should_optimize_ecs_ami(self) -> bool:
+    def should_optimize_ecs_ami(self) -> _builtins.bool:
         """
         Boolean. Enable auto image (AMI) update for the ECS container instances. The auto update applies for ECS-Optimized AMIs.
         """
         return pulumi.get(self, "should_optimize_ecs_ami")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="timeWindows")
-    def time_windows(self) -> Optional[Sequence[str]]:
+    def time_windows(self) -> Optional[Sequence[_builtins.str]]:
         """
         Array of strings. Set time windows for image update, at least one time window. Each string is in the format of ddd:hh:mm-ddd:hh:mm ddd. Time windows should not overlap.
         """
@@ -1773,7 +1773,7 @@ class OceanScheduledTask(dict):
         if tasks is not None:
             pulumi.set(__self__, "tasks", tasks)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="shutdownHours")
     def shutdown_hours(self) -> Optional['outputs.OceanScheduledTaskShutdownHours']:
         """
@@ -1781,7 +1781,7 @@ class OceanScheduledTask(dict):
         """
         return pulumi.get(self, "shutdown_hours")
 
-    @property
+    @_builtins.property
     @pulumi.getter
     def tasks(self) -> Optional[Sequence['outputs.OceanScheduledTaskTask']]:
         """
@@ -1812,27 +1812,27 @@ class OceanScheduledTaskShutdownHours(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 time_windows: Sequence[str],
-                 is_enabled: Optional[bool] = None):
+                 time_windows: Sequence[_builtins.str],
+                 is_enabled: Optional[_builtins.bool] = None):
         """
-        :param Sequence[str] time_windows: Set time windows for shutdown hours. Specify a list of `timeWindows` with at least one time window Each string is in the format of `ddd:hh:mm-ddd:hh:mm` (ddd = day of week = Sun | Mon | Tue | Wed | Thu | Fri | Sat hh = hour 24 = 0 -23 mm = minute = 0 - 59). Time windows should not overlap. Required when `cluster.scheduling.isEnabled` is true. API Times are in UTC. Example: `Fri:15:30-Wed:14:30`.
-        :param bool is_enabled: Flag to enable / disable the shutdown hours.
+        :param Sequence[_builtins.str] time_windows: Set time windows for shutdown hours. Specify a list of `timeWindows` with at least one time window Each string is in the format of `ddd:hh:mm-ddd:hh:mm` (ddd = day of week = Sun | Mon | Tue | Wed | Thu | Fri | Sat hh = hour 24 = 0 -23 mm = minute = 0 - 59). Time windows should not overlap. Required when `cluster.scheduling.isEnabled` is true. API Times are in UTC. Example: `Fri:15:30-Wed:14:30`.
+        :param _builtins.bool is_enabled: Flag to enable / disable the shutdown hours.
         """
         pulumi.set(__self__, "time_windows", time_windows)
         if is_enabled is not None:
             pulumi.set(__self__, "is_enabled", is_enabled)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="timeWindows")
-    def time_windows(self) -> Sequence[str]:
+    def time_windows(self) -> Sequence[_builtins.str]:
         """
         Set time windows for shutdown hours. Specify a list of `timeWindows` with at least one time window Each string is in the format of `ddd:hh:mm-ddd:hh:mm` (ddd = day of week = Sun | Mon | Tue | Wed | Thu | Fri | Sat hh = hour 24 = 0 -23 mm = minute = 0 - 59). Time windows should not overlap. Required when `cluster.scheduling.isEnabled` is true. API Times are in UTC. Example: `Fri:15:30-Wed:14:30`.
         """
         return pulumi.get(self, "time_windows")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="isEnabled")
-    def is_enabled(self) -> Optional[bool]:
+    def is_enabled(self) -> Optional[_builtins.bool]:
         """
         Flag to enable / disable the shutdown hours.
         """
@@ -1863,37 +1863,37 @@ class OceanScheduledTaskTask(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 cron_expression: str,
-                 is_enabled: bool,
-                 task_type: str):
+                 cron_expression: _builtins.str,
+                 is_enabled: _builtins.bool,
+                 task_type: _builtins.str):
         """
-        :param str cron_expression: A valid cron expression. The cron is running in UTC time zone and is in Unix cron format Cron Expression Validator Script. Only one of `frequency` or `cronExpression` should be used at a time. Required for `cluster.scheduling.tasks` object. Example: `0 1 * * *`.
-        :param bool is_enabled: Describes whether the task is enabled. When true the task should run when false it should not run. Required for `cluster.scheduling.tasks` object.
-        :param str task_type: Valid values: "clusterRoll". Required for `cluster.scheduling.tasks object`. Example: `clusterRoll`.
+        :param _builtins.str cron_expression: A valid cron expression. The cron is running in UTC time zone and is in Unix cron format Cron Expression Validator Script. Only one of `frequency` or `cronExpression` should be used at a time. Required for `cluster.scheduling.tasks` object. Example: `0 1 * * *`.
+        :param _builtins.bool is_enabled: Describes whether the task is enabled. When true the task should run when false it should not run. Required for `cluster.scheduling.tasks` object.
+        :param _builtins.str task_type: Valid values: "clusterRoll". Required for `cluster.scheduling.tasks object`. Example: `clusterRoll`.
         """
         pulumi.set(__self__, "cron_expression", cron_expression)
         pulumi.set(__self__, "is_enabled", is_enabled)
         pulumi.set(__self__, "task_type", task_type)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="cronExpression")
-    def cron_expression(self) -> str:
+    def cron_expression(self) -> _builtins.str:
         """
         A valid cron expression. The cron is running in UTC time zone and is in Unix cron format Cron Expression Validator Script. Only one of `frequency` or `cronExpression` should be used at a time. Required for `cluster.scheduling.tasks` object. Example: `0 1 * * *`.
         """
         return pulumi.get(self, "cron_expression")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="isEnabled")
-    def is_enabled(self) -> bool:
+    def is_enabled(self) -> _builtins.bool:
         """
         Describes whether the task is enabled. When true the task should run when false it should not run. Required for `cluster.scheduling.tasks` object.
         """
         return pulumi.get(self, "is_enabled")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="taskType")
-    def task_type(self) -> str:
+    def task_type(self) -> _builtins.str:
         """
         Valid values: "clusterRoll". Required for `cluster.scheduling.tasks object`. Example: `clusterRoll`.
         """
@@ -1903,27 +1903,27 @@ class OceanScheduledTaskTask(dict):
 @pulumi.output_type
 class OceanTag(dict):
     def __init__(__self__, *,
-                 key: str,
-                 value: str):
+                 key: _builtins.str,
+                 value: _builtins.str):
         """
-        :param str key: The tag key.
-        :param str value: The tag value.
+        :param _builtins.str key: The tag key.
+        :param _builtins.str value: The tag value.
                * `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
         """
         pulumi.set(__self__, "key", key)
         pulumi.set(__self__, "value", value)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def key(self) -> str:
+    def key(self) -> _builtins.str:
         """
         The tag key.
         """
         return pulumi.get(self, "key")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def value(self) -> str:
+    def value(self) -> _builtins.str:
         """
         The tag value.
         * `instanceTypes` - (Optional) The type of instances that may or may not be a part of the Ocean cluster.
@@ -1957,14 +1957,14 @@ class OceanUpdatePolicy(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 should_roll: bool,
-                 auto_apply_tags: Optional[bool] = None,
-                 conditioned_roll: Optional[bool] = None,
+                 should_roll: _builtins.bool,
+                 auto_apply_tags: Optional[_builtins.bool] = None,
+                 conditioned_roll: Optional[_builtins.bool] = None,
                  roll_config: Optional['outputs.OceanUpdatePolicyRollConfig'] = None):
         """
-        :param bool should_roll: Enables the roll.
-        :param bool auto_apply_tags: will update instance tags on the fly without rolling the cluster.
-        :param bool conditioned_roll: Spot will perform a cluster Roll in accordance with a relevant modification of the cluster’s settings. When set to true , only specific changes in the cluster’s configuration will trigger a cluster roll (such as AMI, Key Pair, user data, instance types, load balancers, etc).
+        :param _builtins.bool should_roll: Enables the roll.
+        :param _builtins.bool auto_apply_tags: will update instance tags on the fly without rolling the cluster.
+        :param _builtins.bool conditioned_roll: Spot will perform a cluster Roll in accordance with a relevant modification of the cluster’s settings. When set to true , only specific changes in the cluster’s configuration will trigger a cluster roll (such as AMI, Key Pair, user data, instance types, load balancers, etc).
         """
         pulumi.set(__self__, "should_roll", should_roll)
         if auto_apply_tags is not None:
@@ -1974,31 +1974,31 @@ class OceanUpdatePolicy(dict):
         if roll_config is not None:
             pulumi.set(__self__, "roll_config", roll_config)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="shouldRoll")
-    def should_roll(self) -> bool:
+    def should_roll(self) -> _builtins.bool:
         """
         Enables the roll.
         """
         return pulumi.get(self, "should_roll")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="autoApplyTags")
-    def auto_apply_tags(self) -> Optional[bool]:
+    def auto_apply_tags(self) -> Optional[_builtins.bool]:
         """
         will update instance tags on the fly without rolling the cluster.
         """
         return pulumi.get(self, "auto_apply_tags")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="conditionedRoll")
-    def conditioned_roll(self) -> Optional[bool]:
+    def conditioned_roll(self) -> Optional[_builtins.bool]:
         """
         Spot will perform a cluster Roll in accordance with a relevant modification of the cluster’s settings. When set to true , only specific changes in the cluster’s configuration will trigger a cluster roll (such as AMI, Key Pair, user data, instance types, load balancers, etc).
         """
         return pulumi.get(self, "conditioned_roll")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="rollConfig")
     def roll_config(self) -> Optional['outputs.OceanUpdatePolicyRollConfig']:
         return pulumi.get(self, "roll_config")
@@ -2026,27 +2026,27 @@ class OceanUpdatePolicyRollConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 batch_size_percentage: int,
-                 batch_min_healthy_percentage: Optional[int] = None):
+                 batch_size_percentage: _builtins.int,
+                 batch_min_healthy_percentage: Optional[_builtins.int] = None):
         """
-        :param int batch_size_percentage: Sets the percentage of the instances to deploy in each batch.
-        :param int batch_min_healthy_percentage: Default: 50. Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
+        :param _builtins.int batch_size_percentage: Sets the percentage of the instances to deploy in each batch.
+        :param _builtins.int batch_min_healthy_percentage: Default: 50. Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
         """
         pulumi.set(__self__, "batch_size_percentage", batch_size_percentage)
         if batch_min_healthy_percentage is not None:
             pulumi.set(__self__, "batch_min_healthy_percentage", batch_min_healthy_percentage)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="batchSizePercentage")
-    def batch_size_percentage(self) -> int:
+    def batch_size_percentage(self) -> _builtins.int:
         """
         Sets the percentage of the instances to deploy in each batch.
         """
         return pulumi.get(self, "batch_size_percentage")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="batchMinHealthyPercentage")
-    def batch_min_healthy_percentage(self) -> Optional[int]:
+    def batch_min_healthy_percentage(self) -> Optional[_builtins.int]:
         """
         Default: 50. Indicates the threshold of minimum healthy instances in single batch. If the amount of healthy instances in single batch is under the threshold, the cluster roll will fail. If exists, the parameter value will be in range of 1-100. In case of null as value, the default value in the backend will be 50%. Value of param should represent the number in percentage (%) of the batch.
         """