pulumiverse-scaleway 1.35.0a1759392423__py3-none-any.whl → 1.35.0a1760445454__py3-none-any.whl

pulumiverse_scaleway/autoscaling/outputs.py

@@ -2,8 +2,7 @@
 # *** 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 builtins
-import copy
+import builtins as _builtins
 import warnings
 import sys
 import pulumi
@@ -49,13 +48,13 @@ class InstanceGroupCapacity(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 cooldown_delay: Optional[builtins.int] = None,
-                 max_replicas: Optional[builtins.int] = None,
-                 min_replicas: Optional[builtins.int] = None):
+                 cooldown_delay: Optional[_builtins.int] = None,
+                 max_replicas: Optional[_builtins.int] = None,
+                 min_replicas: Optional[_builtins.int] = None):
         """
-        :param builtins.int cooldown_delay: Time (in seconds) after a scaling action during which requests to carry out a new scaling action will be denied.
-        :param builtins.int max_replicas: The maximum count of Instances for the Instance group.
-        :param builtins.int min_replicas: The minimum count of Instances for the Instance group.
+        :param _builtins.int cooldown_delay: Time (in seconds) after a scaling action during which requests to carry out a new scaling action will be denied.
+        :param _builtins.int max_replicas: The maximum count of Instances for the Instance group.
+        :param _builtins.int min_replicas: The minimum count of Instances for the Instance group.
         """
         if cooldown_delay is not None:
             pulumi.set(__self__, "cooldown_delay", cooldown_delay)
@@ -64,25 +63,25 @@ class InstanceGroupCapacity(dict):
         if min_replicas is not None:
             pulumi.set(__self__, "min_replicas", min_replicas)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="cooldownDelay")
-    def cooldown_delay(self) -> Optional[builtins.int]:
+    def cooldown_delay(self) -> Optional[_builtins.int]:
         """
         Time (in seconds) after a scaling action during which requests to carry out a new scaling action will be denied.
         """
         return pulumi.get(self, "cooldown_delay")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="maxReplicas")
-    def max_replicas(self) -> Optional[builtins.int]:
+    def max_replicas(self) -> Optional[_builtins.int]:
         """
         The maximum count of Instances for the Instance group.
         """
         return pulumi.get(self, "max_replicas")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="minReplicas")
-    def min_replicas(self) -> Optional[builtins.int]:
+    def min_replicas(self) -> Optional[_builtins.int]:
         """
         The minimum count of Instances for the Instance group.
         """
@@ -111,13 +110,13 @@ class InstanceGroupLoadBalancer(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 backend_ids: Optional[Sequence[builtins.str]] = None,
-                 id: Optional[builtins.str] = None,
-                 private_network_id: Optional[builtins.str] = None):
+                 backend_ids: Optional[Sequence[_builtins.str]] = None,
+                 id: Optional[_builtins.str] = None,
+                 private_network_id: Optional[_builtins.str] = None):
         """
-        :param Sequence[builtins.str] backend_ids: The Load Balancer backend IDs.
-        :param builtins.str id: The ID of the Load Balancer.
-        :param builtins.str private_network_id: The ID of the Private Network attached to the Load Balancer.
+        :param Sequence[_builtins.str] backend_ids: The Load Balancer backend IDs.
+        :param _builtins.str id: The ID of the Load Balancer.
+        :param _builtins.str private_network_id: The ID of the Private Network attached to the Load Balancer.
         """
         if backend_ids is not None:
             pulumi.set(__self__, "backend_ids", backend_ids)
@@ -126,25 +125,25 @@ class InstanceGroupLoadBalancer(dict):
         if private_network_id is not None:
             pulumi.set(__self__, "private_network_id", private_network_id)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="backendIds")
-    def backend_ids(self) -> Optional[Sequence[builtins.str]]:
+    def backend_ids(self) -> Optional[Sequence[_builtins.str]]:
         """
         The Load Balancer backend IDs.
         """
         return pulumi.get(self, "backend_ids")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def id(self) -> Optional[builtins.str]:
+    def id(self) -> Optional[_builtins.str]:
         """
         The ID of the Load Balancer.
         """
         return pulumi.get(self, "id")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="privateNetworkId")
-    def private_network_id(self) -> Optional[builtins.str]:
+    def private_network_id(self) -> Optional[_builtins.str]:
         """
         The ID of the Private Network attached to the Load Balancer.
         """
@@ -175,21 +174,21 @@ class InstancePolicyMetric(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 aggregate: builtins.str,
-                 name: builtins.str,
-                 operator: builtins.str,
-                 cockpit_metric_name: Optional[builtins.str] = None,
-                 managed_metric: Optional[builtins.str] = None,
-                 sampling_range_min: Optional[builtins.int] = None,
-                 threshold: Optional[builtins.int] = None):
-        """
-        :param builtins.str aggregate: How the values sampled for the `metric` should be aggregated.
-        :param builtins.str name: Name or description of the metric policy.
-        :param builtins.str operator: Operator used when comparing the threshold value of the chosen `metric` to the actual sampled and aggregated value.
-        :param builtins.str cockpit_metric_name: The custom metric to use for this policy. This must be stored in Scaleway Cockpit. The metric forms the basis of the condition that will be checked to determine whether a scaling action should be triggered
-        :param builtins.str managed_metric: The managed metric to use for this policy. These are available by default in Cockpit without any configuration or `node_exporter`. The chosen metric forms the basis of the condition that will be checked to determine whether a scaling action should be triggered.
-        :param builtins.int sampling_range_min: The Interval of time, in minutes, during which metric is sampled.
-        :param builtins.int threshold: The threshold value to measure the aggregated sampled `metric` value against. Combined with the `operator` field, determines whether a scaling action should be triggered.
+                 aggregate: _builtins.str,
+                 name: _builtins.str,
+                 operator: _builtins.str,
+                 cockpit_metric_name: Optional[_builtins.str] = None,
+                 managed_metric: Optional[_builtins.str] = None,
+                 sampling_range_min: Optional[_builtins.int] = None,
+                 threshold: Optional[_builtins.int] = None):
+        """
+        :param _builtins.str aggregate: How the values sampled for the `metric` should be aggregated.
+        :param _builtins.str name: Name or description of the metric policy.
+        :param _builtins.str operator: Operator used when comparing the threshold value of the chosen `metric` to the actual sampled and aggregated value.
+        :param _builtins.str cockpit_metric_name: The custom metric to use for this policy. This must be stored in Scaleway Cockpit. The metric forms the basis of the condition that will be checked to determine whether a scaling action should be triggered
+        :param _builtins.str managed_metric: The managed metric to use for this policy. These are available by default in Cockpit without any configuration or `node_exporter`. The chosen metric forms the basis of the condition that will be checked to determine whether a scaling action should be triggered.
+        :param _builtins.int sampling_range_min: The Interval of time, in minutes, during which metric is sampled.
+        :param _builtins.int threshold: The threshold value to measure the aggregated sampled `metric` value against. Combined with the `operator` field, determines whether a scaling action should be triggered.
         """
         pulumi.set(__self__, "aggregate", aggregate)
         pulumi.set(__self__, "name", name)
@@ -203,57 +202,57 @@ class InstancePolicyMetric(dict):
         if threshold is not None:
             pulumi.set(__self__, "threshold", threshold)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def aggregate(self) -> builtins.str:
+    def aggregate(self) -> _builtins.str:
         """
         How the values sampled for the `metric` should be aggregated.
         """
         return pulumi.get(self, "aggregate")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         Name or description of the metric policy.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def operator(self) -> builtins.str:
+    def operator(self) -> _builtins.str:
         """
         Operator used when comparing the threshold value of the chosen `metric` to the actual sampled and aggregated value.
         """
         return pulumi.get(self, "operator")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="cockpitMetricName")
-    def cockpit_metric_name(self) -> Optional[builtins.str]:
+    def cockpit_metric_name(self) -> Optional[_builtins.str]:
         """
         The custom metric to use for this policy. This must be stored in Scaleway Cockpit. The metric forms the basis of the condition that will be checked to determine whether a scaling action should be triggered
         """
         return pulumi.get(self, "cockpit_metric_name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="managedMetric")
-    def managed_metric(self) -> Optional[builtins.str]:
+    def managed_metric(self) -> Optional[_builtins.str]:
         """
         The managed metric to use for this policy. These are available by default in Cockpit without any configuration or `node_exporter`. The chosen metric forms the basis of the condition that will be checked to determine whether a scaling action should be triggered.
         """
         return pulumi.get(self, "managed_metric")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="samplingRangeMin")
-    def sampling_range_min(self) -> Optional[builtins.int]:
+    def sampling_range_min(self) -> Optional[_builtins.int]:
         """
         The Interval of time, in minutes, during which metric is sampled.
         """
         return pulumi.get(self, "sampling_range_min")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def threshold(self) -> Optional[builtins.int]:
+    def threshold(self) -> Optional[_builtins.int]:
         """
         The threshold value to measure the aggregated sampled `metric` value against. Combined with the `operator` field, determines whether a scaling action should be triggered.
         """
@@ -286,21 +285,21 @@ class InstanceTemplateVolume(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 name: builtins.str,
-                 volume_type: builtins.str,
-                 boot: Optional[builtins.bool] = None,
+                 name: _builtins.str,
+                 volume_type: _builtins.str,
+                 boot: Optional[_builtins.bool] = None,
                  from_empty: Optional['outputs.InstanceTemplateVolumeFromEmpty'] = None,
                  from_snapshot: Optional['outputs.InstanceTemplateVolumeFromSnapshot'] = None,
-                 perf_iops: Optional[builtins.int] = None,
-                 tags: Optional[Sequence[builtins.str]] = None):
+                 perf_iops: Optional[_builtins.int] = None,
+                 tags: Optional[Sequence[_builtins.str]] = None):
         """
-        :param builtins.str name: The name of the volume.
-        :param builtins.str volume_type: The type of the volume.
-        :param builtins.bool boot: Force the Instance to boot on this volume.
+        :param _builtins.str name: The name of the volume.
+        :param _builtins.str volume_type: The type of the volume.
+        :param _builtins.bool boot: Force the Instance to boot on this volume.
         :param 'InstanceTemplateVolumeFromEmptyArgs' from_empty: Volume instance template from empty
         :param 'InstanceTemplateVolumeFromSnapshotArgs' from_snapshot: Volume instance template from snapshot
-        :param builtins.int perf_iops: The maximum IO/s expected, according to the different options available in stock (`5000 | 15000`).
-        :param Sequence[builtins.str] tags: The list of tags assigned to the volume.
+        :param _builtins.int perf_iops: The maximum IO/s expected, according to the different options available in stock (`5000 | 15000`).
+        :param Sequence[_builtins.str] tags: The list of tags assigned to the volume.
         """
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "volume_type", volume_type)
@@ -315,31 +314,31 @@ class InstanceTemplateVolume(dict):
         if tags is not None:
             pulumi.set(__self__, "tags", tags)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def name(self) -> builtins.str:
+    def name(self) -> _builtins.str:
         """
         The name of the volume.
         """
         return pulumi.get(self, "name")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="volumeType")
-    def volume_type(self) -> builtins.str:
+    def volume_type(self) -> _builtins.str:
         """
         The type of the volume.
         """
         return pulumi.get(self, "volume_type")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def boot(self) -> Optional[builtins.bool]:
+    def boot(self) -> Optional[_builtins.bool]:
         """
         Force the Instance to boot on this volume.
         """
         return pulumi.get(self, "boot")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="fromEmpty")
     def from_empty(self) -> Optional['outputs.InstanceTemplateVolumeFromEmpty']:
         """
@@ -347,7 +346,7 @@ class InstanceTemplateVolume(dict):
         """
         return pulumi.get(self, "from_empty")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="fromSnapshot")
     def from_snapshot(self) -> Optional['outputs.InstanceTemplateVolumeFromSnapshot']:
         """
@@ -355,17 +354,17 @@ class InstanceTemplateVolume(dict):
         """
         return pulumi.get(self, "from_snapshot")
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="perfIops")
-    def perf_iops(self) -> Optional[builtins.int]:
+    def perf_iops(self) -> Optional[_builtins.int]:
         """
         The maximum IO/s expected, according to the different options available in stock (`5000 | 15000`).
         """
         return pulumi.get(self, "perf_iops")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def tags(self) -> Optional[Sequence[builtins.str]]:
+    def tags(self) -> Optional[Sequence[_builtins.str]]:
         """
         The list of tags assigned to the volume.
         """
@@ -375,15 +374,15 @@ class InstanceTemplateVolume(dict):
 @pulumi.output_type
 class InstanceTemplateVolumeFromEmpty(dict):
     def __init__(__self__, *,
-                 size: builtins.int):
+                 size: _builtins.int):
         """
-        :param builtins.int size: Size in GB of the new empty volume
+        :param _builtins.int size: Size in GB of the new empty volume
         """
         pulumi.set(__self__, "size", size)
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def size(self) -> builtins.int:
+    def size(self) -> _builtins.int:
         """
         Size in GB of the new empty volume
         """
@@ -410,27 +409,27 @@ class InstanceTemplateVolumeFromSnapshot(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 snapshot_id: builtins.str,
-                 size: Optional[builtins.int] = None):
+                 snapshot_id: _builtins.str,
+                 size: Optional[_builtins.int] = None):
         """
-        :param builtins.str snapshot_id: ID of the snapshot to clone
-        :param builtins.int size: Override size (in GB) of the cloned volume
+        :param _builtins.str snapshot_id: ID of the snapshot to clone
+        :param _builtins.int size: Override size (in GB) of the cloned volume
         """
         pulumi.set(__self__, "snapshot_id", snapshot_id)
         if size is not None:
             pulumi.set(__self__, "size", size)
 
-    @property
+    @_builtins.property
     @pulumi.getter(name="snapshotId")
-    def snapshot_id(self) -> builtins.str:
+    def snapshot_id(self) -> _builtins.str:
         """
         ID of the snapshot to clone
         """
         return pulumi.get(self, "snapshot_id")
 
-    @property
+    @_builtins.property
     @pulumi.getter
-    def size(self) -> Optional[builtins.int]:
+    def size(self) -> Optional[_builtins.int]:
         """
         Override size (in GB) of the cloned volume
         """