pulumiverse-scaleway 1.35.0a1761031391__py3-none-any.whl → 1.39.0a1764841480__py3-none-any.whl

pulumiverse_scaleway/instance/outputs.py

@@ -17,11 +17,13 @@ from . import outputs
 
 __all__ = [
     'ImageAdditionalVolume',
+    'ImageRootVolume',
     'PrivateNicPrivateIp',
     'SecurityGroupInboundRule',
     'SecurityGroupOutboundRule',
     'SecurityGroupRulesInboundRule',
     'SecurityGroupRulesOutboundRule',
+    'ServerFilesystem',
     'ServerPrivateIp',
     'ServerPrivateNetwork',
     'ServerPublicIp',
@@ -30,6 +32,7 @@ __all__ = [
     'GetPrivateNicPrivateIpResult',
     'GetSecurityGroupInboundRuleResult',
     'GetSecurityGroupOutboundRuleResult',
+    'GetServerFilesystemResult',
     'GetServerPrivateIpResult',
     'GetServerPrivateNetworkResult',
     'GetServerPublicIpResult',
@@ -48,13 +51,7 @@ class ImageAdditionalVolume(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "creationDate":
-            suggest = "creation_date"
-        elif key == "exportUri":
-            suggest = "export_uri"
-        elif key == "modificationDate":
-            suggest = "modification_date"
-        elif key == "volumeType":
+        if key == "volumeType":
             suggest = "volume_type"
 
         if suggest:
@@ -69,76 +66,32 @@ class ImageAdditionalVolume(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 creation_date: Optional[_builtins.str] = None,
-                 export_uri: Optional[_builtins.str] = None,
                  id: Optional[_builtins.str] = None,
-                 modification_date: Optional[_builtins.str] = None,
                  name: Optional[_builtins.str] = None,
-                 organization: Optional[_builtins.str] = None,
-                 project: Optional[_builtins.str] = None,
                  server: Optional[Mapping[str, _builtins.str]] = None,
                  size: Optional[_builtins.int] = None,
-                 state: Optional[_builtins.str] = None,
                  tags: Optional[Sequence[_builtins.str]] = None,
-                 volume_type: Optional[_builtins.str] = None,
-                 zone: Optional[_builtins.str] = None):
+                 volume_type: Optional[_builtins.str] = None):
         """
-        :param _builtins.str creation_date: Date of the volume creation.
-        :param _builtins.str export_uri: The export URI of the volume.
         :param _builtins.str id: ID of the server containing the volume.
-        :param _builtins.str modification_date: Date of volume latest update.
         :param _builtins.str name: The name of the image. If not provided it will be randomly generated.
-        :param _builtins.str organization: The organization ID the volume is associated with.
-        :param _builtins.str project: ID of the project the volume is associated with
         :param Mapping[str, _builtins.str] server: Description of the server containing the volume (in case the image is a backup from a server).
         :param _builtins.int size: The size of the volume.
-        :param _builtins.str state: State of the volume.
         :param Sequence[_builtins.str] tags: A list of tags to apply to the image.
-        :param _builtins.str volume_type: The type of volume, possible values are `l_ssd` and `b_ssd`.
-        :param _builtins.str zone: The zone in which the image should be created.
+        :param _builtins.str volume_type: The type of volume, possible values are `l_ssd` and `sbs_snapshot`.
         """
-        if creation_date is not None:
-            pulumi.set(__self__, "creation_date", creation_date)
-        if export_uri is not None:
-            pulumi.set(__self__, "export_uri", export_uri)
         if id is not None:
             pulumi.set(__self__, "id", id)
-        if modification_date is not None:
-            pulumi.set(__self__, "modification_date", modification_date)
         if name is not None:
             pulumi.set(__self__, "name", name)
-        if organization is not None:
-            pulumi.set(__self__, "organization", organization)
-        if project is not None:
-            pulumi.set(__self__, "project", project)
         if server is not None:
             pulumi.set(__self__, "server", server)
         if size is not None:
             pulumi.set(__self__, "size", size)
-        if state is not None:
-            pulumi.set(__self__, "state", state)
         if tags is not None:
             pulumi.set(__self__, "tags", tags)
         if volume_type is not None:
             pulumi.set(__self__, "volume_type", volume_type)
-        if zone is not None:
-            pulumi.set(__self__, "zone", zone)
-
-    @_builtins.property
-    @pulumi.getter(name="creationDate")
-    def creation_date(self) -> Optional[_builtins.str]:
-        """
-        Date of the volume creation.
-        """
-        return pulumi.get(self, "creation_date")
-
-    @_builtins.property
-    @pulumi.getter(name="exportUri")
-    def export_uri(self) -> Optional[_builtins.str]:
-        """
-        The export URI of the volume.
-        """
-        return pulumi.get(self, "export_uri")
 
     @_builtins.property
     @pulumi.getter
@@ -148,14 +101,6 @@ class ImageAdditionalVolume(dict):
         """
         return pulumi.get(self, "id")
 
-    @_builtins.property
-    @pulumi.getter(name="modificationDate")
-    def modification_date(self) -> Optional[_builtins.str]:
-        """
-        Date of volume latest update.
-        """
-        return pulumi.get(self, "modification_date")
-
     @_builtins.property
     @pulumi.getter
     def name(self) -> Optional[_builtins.str]:
@@ -166,67 +111,107 @@ class ImageAdditionalVolume(dict):
 
     @_builtins.property
     @pulumi.getter
-    def organization(self) -> Optional[_builtins.str]:
+    def server(self) -> Optional[Mapping[str, _builtins.str]]:
         """
-        The organization ID the volume is associated with.
+        Description of the server containing the volume (in case the image is a backup from a server).
         """
-        return pulumi.get(self, "organization")
+        return pulumi.get(self, "server")
 
     @_builtins.property
     @pulumi.getter
-    def project(self) -> Optional[_builtins.str]:
+    def size(self) -> Optional[_builtins.int]:
         """
-        ID of the project the volume is associated with
+        The size of the volume.
         """
-        return pulumi.get(self, "project")
+        return pulumi.get(self, "size")
 
     @_builtins.property
     @pulumi.getter
-    def server(self) -> Optional[Mapping[str, _builtins.str]]:
+    def tags(self) -> Optional[Sequence[_builtins.str]]:
         """
-        Description of the server containing the volume (in case the image is a backup from a server).
+        A list of tags to apply to the image.
         """
-        return pulumi.get(self, "server")
+        return pulumi.get(self, "tags")
 
     @_builtins.property
-    @pulumi.getter
-    def size(self) -> Optional[_builtins.int]:
+    @pulumi.getter(name="volumeType")
+    def volume_type(self) -> Optional[_builtins.str]:
         """
-        The size of the volume.
+        The type of volume, possible values are `l_ssd` and `sbs_snapshot`.
         """
-        return pulumi.get(self, "size")
+        return pulumi.get(self, "volume_type")
+
+
+@pulumi.output_type
+class ImageRootVolume(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "volumeType":
+            suggest = "volume_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ImageRootVolume. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ImageRootVolume.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ImageRootVolume.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 id: Optional[_builtins.str] = None,
+                 name: Optional[_builtins.str] = None,
+                 size: Optional[_builtins.int] = None,
+                 volume_type: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str id: ID of the server containing the volume.
+        :param _builtins.str name: The name of the image. If not provided it will be randomly generated.
+        :param _builtins.int size: The size of the volume.
+        :param _builtins.str volume_type: The type of volume, possible values are `l_ssd` and `sbs_snapshot`.
+        """
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if size is not None:
+            pulumi.set(__self__, "size", size)
+        if volume_type is not None:
+            pulumi.set(__self__, "volume_type", volume_type)
 
     @_builtins.property
     @pulumi.getter
-    def state(self) -> Optional[_builtins.str]:
+    def id(self) -> Optional[_builtins.str]:
         """
-        State of the volume.
+        ID of the server containing the volume.
         """
-        return pulumi.get(self, "state")
+        return pulumi.get(self, "id")
 
     @_builtins.property
     @pulumi.getter
-    def tags(self) -> Optional[Sequence[_builtins.str]]:
+    def name(self) -> Optional[_builtins.str]:
         """
-        A list of tags to apply to the image.
+        The name of the image. If not provided it will be randomly generated.
         """
-        return pulumi.get(self, "tags")
+        return pulumi.get(self, "name")
 
     @_builtins.property
-    @pulumi.getter(name="volumeType")
-    def volume_type(self) -> Optional[_builtins.str]:
+    @pulumi.getter
+    def size(self) -> Optional[_builtins.int]:
         """
-        The type of volume, possible values are `l_ssd` and `b_ssd`.
+        The size of the volume.
         """
-        return pulumi.get(self, "volume_type")
+        return pulumi.get(self, "size")
 
     @_builtins.property
-    @pulumi.getter
-    def zone(self) -> Optional[_builtins.str]:
+    @pulumi.getter(name="volumeType")
+    def volume_type(self) -> Optional[_builtins.str]:
         """
-        The zone in which the image should be created.
+        The type of volume, possible values are `l_ssd` and `sbs_snapshot`.
         """
-        return pulumi.get(self, "zone")
+        return pulumi.get(self, "volume_type")
 
 
 @pulumi.output_type
@@ -652,6 +637,54 @@ class SecurityGroupRulesOutboundRule(dict):
         return pulumi.get(self, "protocol")
 
 
+@pulumi.output_type
+class ServerFilesystem(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "filesystemId":
+            suggest = "filesystem_id"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServerFilesystem. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServerFilesystem.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServerFilesystem.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 filesystem_id: Optional[_builtins.str] = None,
+                 status: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str filesystem_id: The unique ID of the filesystem attached to the server.
+        :param _builtins.str status: The state of the filesystem
+        """
+        if filesystem_id is not None:
+            pulumi.set(__self__, "filesystem_id", filesystem_id)
+        if status is not None:
+            pulumi.set(__self__, "status", status)
+
+    @_builtins.property
+    @pulumi.getter(name="filesystemId")
+    def filesystem_id(self) -> Optional[_builtins.str]:
+        """
+        The unique ID of the filesystem attached to the server.
+        """
+        return pulumi.get(self, "filesystem_id")
+
+    @_builtins.property
+    @pulumi.getter
+    def status(self) -> Optional[_builtins.str]:
+        """
+        The state of the filesystem
+        """
+        return pulumi.get(self, "status")
+
+
 @pulumi.output_type
 class ServerPrivateIp(dict):
     def __init__(__self__, *,
@@ -916,10 +949,11 @@ class ServerRootVolume(dict):
         """
         :param _builtins.bool boot: Set the volume where the boot the server
         :param _builtins.bool delete_on_termination: Forces deletion of the root volume on instance termination.
-        :param _builtins.str name: The name of the server.
+        :param _builtins.str name: Name of the root volume.
         :param _builtins.int sbs_iops: Choose IOPS of your sbs volume, has to be used with `sbs_volume` for root volume type.
                
-               > **Important:** Updates to `root_volume.size_in_gb` will be ignored after the creation of the server.
+               > **Important:** It is not possible to change `root_volume.size_in_gb` for local volumes (`l_ssd`). Changes to this field will recreate the server.
+               It is possible to increase `root_volume.size_in_gb` for SBS volumes, but they cannot be resized down without recreating the server.
         :param _builtins.int size_in_gb: Size of the root volume in gigabytes.
                To find the right size use [this endpoint](https://www.scaleway.com/en/developers/api/instance/#path-instances-list-all-instances) and
                check the `volumes_constraint.{min|max}_size` (in bytes) for your `commercial_type`.
@@ -962,7 +996,7 @@ class ServerRootVolume(dict):
     @pulumi.getter
     def name(self) -> Optional[_builtins.str]:
         """
-        The name of the server.
+        Name of the root volume.
         """
         return pulumi.get(self, "name")
 
@@ -972,7 +1006,8 @@ class ServerRootVolume(dict):
         """
         Choose IOPS of your sbs volume, has to be used with `sbs_volume` for root volume type.
 
-        > **Important:** Updates to `root_volume.size_in_gb` will be ignored after the creation of the server.
+        > **Important:** It is not possible to change `root_volume.size_in_gb` for local volumes (`l_ssd`). Changes to this field will recreate the server.
+        It is possible to increase `root_volume.size_in_gb` for SBS volumes, but they cannot be resized down without recreating the server.
         """
         return pulumi.get(self, "sbs_iops")
 
@@ -1216,14 +1251,43 @@ class GetSecurityGroupOutboundRuleResult(dict):
         return pulumi.get(self, "protocol")
 
 
+@pulumi.output_type
+class GetServerFilesystemResult(dict):
+    def __init__(__self__, *,
+                 filesystem_id: _builtins.str,
+                 status: _builtins.str):
+        """
+        :param _builtins.str filesystem_id: The filesystem ID attached to the server
+        :param _builtins.str status: The state of the filesystem
+        """
+        pulumi.set(__self__, "filesystem_id", filesystem_id)
+        pulumi.set(__self__, "status", status)
+
+    @_builtins.property
+    @pulumi.getter(name="filesystemId")
+    def filesystem_id(self) -> _builtins.str:
+        """
+        The filesystem ID attached to the server
+        """
+        return pulumi.get(self, "filesystem_id")
+
+    @_builtins.property
+    @pulumi.getter
+    def status(self) -> _builtins.str:
+        """
+        The state of the filesystem
+        """
+        return pulumi.get(self, "status")
+
+
 @pulumi.output_type
 class GetServerPrivateIpResult(dict):
     def __init__(__self__, *,
                  address: _builtins.str,
                  id: _builtins.str):
         """
-        :param _builtins.str address: The address of the IP
-        :param _builtins.str id: The ID of the IP
+        :param _builtins.str address: The private IP address.
+        :param _builtins.str id: The ID of the IP address resource.
         """
         pulumi.set(__self__, "address", address)
         pulumi.set(__self__, "id", id)
@@ -1232,7 +1296,7 @@ class GetServerPrivateIpResult(dict):
     @pulumi.getter
     def address(self) -> _builtins.str:
         """
-        The address of the IP
+        The private IP address.
         """
         return pulumi.get(self, "address")
 
@@ -1240,7 +1304,7 @@ class GetServerPrivateIpResult(dict):
     @pulumi.getter
     def id(self) -> _builtins.str:
         """
-        The ID of the IP
+        The ID of the IP address resource.
         """
         return pulumi.get(self, "id")
 
@@ -1318,11 +1382,11 @@ class GetServerPublicIpResult(dict):
                  netmask: _builtins.str,
                  provisioning_mode: _builtins.str):
         """
-        :param _builtins.str address: The address of the IP
+        :param _builtins.str address: The private IP address.
         :param _builtins.bool dynamic: Whether the IP is dynamic
         :param _builtins.str family: IP address family (inet or inet6)
         :param _builtins.str gateway: Gateway's IP address
-        :param _builtins.str id: The ID of the IP
+        :param _builtins.str id: The ID of the IP address resource.
         :param _builtins.str netmask: CIDR netmask
         :param _builtins.str provisioning_mode: Provisioning mode of the IP address
         """
@@ -1338,7 +1402,7 @@ class GetServerPublicIpResult(dict):
     @pulumi.getter
     def address(self) -> _builtins.str:
         """
-        The address of the IP
+        The private IP address.
         """
         return pulumi.get(self, "address")
 
@@ -1370,7 +1434,7 @@ class GetServerPublicIpResult(dict):
     @pulumi.getter
     def id(self) -> _builtins.str:
         """
-        The ID of the IP
+        The ID of the IP address resource.
         """
         return pulumi.get(self, "id")
 
@@ -1623,20 +1687,14 @@ class GetServersServerResult(dict):
                  boot_type: _builtins.str,
                  bootscript_id: _builtins.str,
                  enable_dynamic_ip: _builtins.bool,
-                 enable_ipv6: _builtins.bool,
                  id: _builtins.str,
                  image: _builtins.str,
-                 ipv6_address: _builtins.str,
-                 ipv6_gateway: _builtins.str,
-                 ipv6_prefix_length: _builtins.int,
                  name: _builtins.str,
                  organization_id: _builtins.str,
                  placement_group_id: _builtins.str,
                  placement_group_policy_respected: _builtins.bool,
-                 private_ip: _builtins.str,
                  private_ips: Sequence['outputs.GetServersServerPrivateIpResult'],
                  project_id: _builtins.str,
-                 public_ip: _builtins.str,
                  public_ips: Sequence['outputs.GetServersServerPublicIpResult'],
                  security_group_id: _builtins.str,
                  state: _builtins.str,
@@ -1647,20 +1705,14 @@ class GetServersServerResult(dict):
         :param _builtins.str boot_type: The boot Type of the server. Possible values are: `local`, `bootscript` or `rescue`.
         :param _builtins.str bootscript_id: UUID of the bootscript
         :param _builtins.bool enable_dynamic_ip: If true a dynamic IP will be attached to the server.
-        :param _builtins.bool enable_ipv6: Determines if IPv6 is enabled for the server.
         :param _builtins.str id: The ID of the IP
         :param _builtins.str image: The UUID or the label of the base image used by the server.
-        :param _builtins.str ipv6_address: The default ipv6 address routed to the server. ( Only set when enable_ipv6 is set to true )
-        :param _builtins.str ipv6_gateway: The ipv6 gateway address. ( Only set when enable_ipv6 is set to true )
-        :param _builtins.int ipv6_prefix_length: The prefix length of the ipv6 subnet routed to the server. ( Only set when enable_ipv6 is set to true )
         :param _builtins.str name: The server name used as filter. Servers with a name like it are listed.
         :param _builtins.str organization_id: The organization ID the server is associated with.
         :param _builtins.str placement_group_id: The [placement group](https://developers.scaleway.com/en/products/instance/api/#placement-groups-d8f653) the server is attached to.
         :param _builtins.bool placement_group_policy_respected: Whether the placement group policy respected or not
-        :param _builtins.str private_ip: The Scaleway internal IP address of the server.
         :param Sequence['GetServersServerPrivateIpArgs'] private_ips: The list of private IPv4 and IPv6 addresses associated with the server.
         :param _builtins.str project_id: The ID of the project the server is associated with.
-        :param _builtins.str public_ip: The public IP address of the server.
         :param Sequence['GetServersServerPublicIpArgs'] public_ips: The list of public IPs of the server
         :param _builtins.str security_group_id: The [security group](https://developers.scaleway.com/en/products/instance/api/#security-groups-8d7f89) the server is attached to.
         :param _builtins.str state: The state of the server. Possible values are: `started`, `stopped` or `standby`.
@@ -1671,20 +1723,14 @@ class GetServersServerResult(dict):
         pulumi.set(__self__, "boot_type", boot_type)
         pulumi.set(__self__, "bootscript_id", bootscript_id)
         pulumi.set(__self__, "enable_dynamic_ip", enable_dynamic_ip)
-        pulumi.set(__self__, "enable_ipv6", enable_ipv6)
         pulumi.set(__self__, "id", id)
         pulumi.set(__self__, "image", image)
-        pulumi.set(__self__, "ipv6_address", ipv6_address)
-        pulumi.set(__self__, "ipv6_gateway", ipv6_gateway)
-        pulumi.set(__self__, "ipv6_prefix_length", ipv6_prefix_length)
         pulumi.set(__self__, "name", name)
         pulumi.set(__self__, "organization_id", organization_id)
         pulumi.set(__self__, "placement_group_id", placement_group_id)
         pulumi.set(__self__, "placement_group_policy_respected", placement_group_policy_respected)
-        pulumi.set(__self__, "private_ip", private_ip)
         pulumi.set(__self__, "private_ips", private_ips)
         pulumi.set(__self__, "project_id", project_id)
-        pulumi.set(__self__, "public_ip", public_ip)
         pulumi.set(__self__, "public_ips", public_ips)
         pulumi.set(__self__, "security_group_id", security_group_id)
         pulumi.set(__self__, "state", state)
@@ -1718,14 +1764,6 @@ class GetServersServerResult(dict):
         """
         return pulumi.get(self, "enable_dynamic_ip")
 
-    @_builtins.property
-    @pulumi.getter(name="enableIpv6")
-    def enable_ipv6(self) -> _builtins.bool:
-        """
-        Determines if IPv6 is enabled for the server.
-        """
-        return pulumi.get(self, "enable_ipv6")
-
     @_builtins.property
     @pulumi.getter
     def id(self) -> _builtins.str:
@@ -1742,30 +1780,6 @@ class GetServersServerResult(dict):
         """
         return pulumi.get(self, "image")
 
-    @_builtins.property
-    @pulumi.getter(name="ipv6Address")
-    def ipv6_address(self) -> _builtins.str:
-        """
-        The default ipv6 address routed to the server. ( Only set when enable_ipv6 is set to true )
-        """
-        return pulumi.get(self, "ipv6_address")
-
-    @_builtins.property
-    @pulumi.getter(name="ipv6Gateway")
-    def ipv6_gateway(self) -> _builtins.str:
-        """
-        The ipv6 gateway address. ( Only set when enable_ipv6 is set to true )
-        """
-        return pulumi.get(self, "ipv6_gateway")
-
-    @_builtins.property
-    @pulumi.getter(name="ipv6PrefixLength")
-    def ipv6_prefix_length(self) -> _builtins.int:
-        """
-        The prefix length of the ipv6 subnet routed to the server. ( Only set when enable_ipv6 is set to true )
-        """
-        return pulumi.get(self, "ipv6_prefix_length")
-
     @_builtins.property
     @pulumi.getter
     def name(self) -> _builtins.str:
@@ -1798,14 +1812,6 @@ class GetServersServerResult(dict):
         """
         return pulumi.get(self, "placement_group_policy_respected")
 
-    @_builtins.property
-    @pulumi.getter(name="privateIp")
-    def private_ip(self) -> _builtins.str:
-        """
-        The Scaleway internal IP address of the server.
-        """
-        return pulumi.get(self, "private_ip")
-
     @_builtins.property
     @pulumi.getter(name="privateIps")
     def private_ips(self) -> Sequence['outputs.GetServersServerPrivateIpResult']:
@@ -1822,15 +1828,6 @@ class GetServersServerResult(dict):
         """
         return pulumi.get(self, "project_id")
 
-    @_builtins.property
-    @pulumi.getter(name="publicIp")
-    @_utilities.deprecated("""Use public_ips instead""")
-    def public_ip(self) -> _builtins.str:
-        """
-        The public IP address of the server.
-        """
-        return pulumi.get(self, "public_ip")
-
     @_builtins.property
     @pulumi.getter(name="publicIps")
     def public_ips(self) -> Sequence['outputs.GetServersServerPublicIpResult']: