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

pulumiverse_scaleway/outputs.py

@@ -41,6 +41,7 @@ __all__ = [
     'DatabaseInstancePrivateIp',
     'DatabaseInstancePrivateNetwork',
     'DatabaseInstanceReadReplica',
+    'DatabaseInstanceUpgradableVersion',
     'DatabaseReadReplicaDirectAccess',
     'DatabaseReadReplicaPrivateNetwork',
     'DomainRecordGeoIp',
@@ -63,11 +64,13 @@ __all__ = [
     'InferenceDeploymentPrivateIp',
     'InferenceDeploymentPublicEndpoint',
     'InstanceImageAdditionalVolume',
+    'InstanceImageRootVolume',
     'InstancePrivateNicPrivateIp',
     'InstanceSecurityGroupInboundRule',
     'InstanceSecurityGroupOutboundRule',
     'InstanceSecurityGroupRulesInboundRule',
     'InstanceSecurityGroupRulesOutboundRule',
+    'InstanceServerFilesystem',
     'InstanceServerPrivateIp',
     'InstanceServerPrivateNetwork',
     'InstanceServerPublicIp',
@@ -166,6 +169,7 @@ __all__ = [
     'GetDatabaseInstancePrivateIpResult',
     'GetDatabaseInstancePrivateNetworkResult',
     'GetDatabaseInstanceReadReplicaResult',
+    'GetDatabaseInstanceUpgradableVersionResult',
     'GetDomainRecordGeoIpResult',
     'GetDomainRecordGeoIpMatchResult',
     'GetDomainRecordHttpServiceResult',
@@ -176,6 +180,7 @@ __all__ = [
     'GetInstancePrivateNicPrivateIpResult',
     'GetInstanceSecurityGroupInboundRuleResult',
     'GetInstanceSecurityGroupOutboundRuleResult',
+    'GetInstanceServerFilesystemResult',
     'GetInstanceServerPrivateIpResult',
     'GetInstanceServerPrivateNetworkResult',
     'GetInstanceServerPublicIpResult',
@@ -1574,7 +1579,7 @@ class DatabaseInstancePrivateIp(dict):
                  id: Optional[_builtins.str] = None):
         """
         :param _builtins.str address: The private IPv4 address.
-        :param _builtins.str id: The ID of the IPv4 address resource.
+        :param _builtins.str id: Version ID to use in upgrade requests.
         """
         if address is not None:
             pulumi.set(__self__, "address", address)
@@ -1593,7 +1598,7 @@ class DatabaseInstancePrivateIp(dict):
     @pulumi.getter
     def id(self) -> Optional[_builtins.str]:
         """
-        The ID of the IPv4 address resource.
+        Version ID to use in upgrade requests.
         """
         return pulumi.get(self, "id")
 
@@ -1778,6 +1783,78 @@ class DatabaseInstanceReadReplica(dict):
         return pulumi.get(self, "port")
 
 
+@pulumi.output_type
+class DatabaseInstanceUpgradableVersion(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "minorVersion":
+            suggest = "minor_version"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in DatabaseInstanceUpgradableVersion. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        DatabaseInstanceUpgradableVersion.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        DatabaseInstanceUpgradableVersion.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 id: Optional[_builtins.str] = None,
+                 minor_version: Optional[_builtins.str] = None,
+                 name: Optional[_builtins.str] = None,
+                 version: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str id: Version ID to use in upgrade requests.
+        :param _builtins.str minor_version: Minor version string (e.g., `15.5.0`).
+        :param _builtins.str name: The name of the Database Instance.
+        :param _builtins.str version: Version string (e.g., `15.5`).
+        """
+        if id is not None:
+            pulumi.set(__self__, "id", id)
+        if minor_version is not None:
+            pulumi.set(__self__, "minor_version", minor_version)
+        if name is not None:
+            pulumi.set(__self__, "name", name)
+        if version is not None:
+            pulumi.set(__self__, "version", version)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> Optional[_builtins.str]:
+        """
+        Version ID to use in upgrade requests.
+        """
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter(name="minorVersion")
+    def minor_version(self) -> Optional[_builtins.str]:
+        """
+        Minor version string (e.g., `15.5.0`).
+        """
+        return pulumi.get(self, "minor_version")
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> Optional[_builtins.str]:
+        """
+        The name of the Database Instance.
+        """
+        return pulumi.get(self, "name")
+
+    @_builtins.property
+    @pulumi.getter
+    def version(self) -> Optional[_builtins.str]:
+        """
+        Version string (e.g., `15.5`).
+        """
+        return pulumi.get(self, "version")
+
+
 @pulumi.output_type
 class DatabaseReadReplicaDirectAccess(dict):
     @staticmethod
@@ -3066,13 +3143,7 @@ class InstanceImageAdditionalVolume(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:
@@ -3087,76 +3158,32 @@ class InstanceImageAdditionalVolume(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
@@ -3166,14 +3193,6 @@ class InstanceImageAdditionalVolume(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]:
@@ -3184,67 +3203,107 @@ class InstanceImageAdditionalVolume(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 InstanceImageRootVolume(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 InstanceImageRootVolume. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstanceImageRootVolume.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstanceImageRootVolume.__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
@@ -3670,6 +3729,54 @@ class InstanceSecurityGroupRulesOutboundRule(dict):
         return pulumi.get(self, "protocol")
 
 
+@pulumi.output_type
+class InstanceServerFilesystem(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 InstanceServerFilesystem. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstanceServerFilesystem.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstanceServerFilesystem.__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 InstanceServerPrivateIp(dict):
     def __init__(__self__, *,
@@ -3934,10 +4041,11 @@ class InstanceServerRootVolume(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`.
@@ -3980,7 +4088,7 @@ class InstanceServerRootVolume(dict):
     @pulumi.getter
     def name(self) -> Optional[_builtins.str]:
         """
-        The name of the server.
+        Name of the root volume.
         """
         return pulumi.get(self, "name")
 
@@ -3990,7 +4098,8 @@ class InstanceServerRootVolume(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")
 
@@ -4392,8 +4501,8 @@ class IpamIpCustomResource(dict):
                  mac_address: _builtins.str,
                  name: Optional[_builtins.str] = None):
         """
-        :param _builtins.str mac_address: The MAC address of the resource the IP is attached to.
-        :param _builtins.str name: The name of the resource the IP is attached to.
+        :param _builtins.str mac_address: The MAC address of the custom resource.
+        :param _builtins.str name: When the resource is in a Private Network, a DNS record is available to resolve the resource name.
         """
         pulumi.set(__self__, "mac_address", mac_address)
         if name is not None:
@@ -4403,7 +4512,7 @@ class IpamIpCustomResource(dict):
     @pulumi.getter(name="macAddress")
     def mac_address(self) -> _builtins.str:
         """
-        The MAC address of the resource the IP is attached to.
+        The MAC address of the custom resource.
         """
         return pulumi.get(self, "mac_address")
 
@@ -4411,7 +4520,7 @@ class IpamIpCustomResource(dict):
     @pulumi.getter
     def name(self) -> Optional[_builtins.str]:
         """
-        The name of the resource the IP is attached to.
+        When the resource is in a Private Network, a DNS record is available to resolve the resource name.
         """
         return pulumi.get(self, "name")
 
@@ -6092,8 +6201,8 @@ class LoadbalancerPrivateNetwork(dict):
             suggest = "dhcp_config"
         elif key == "ipamIds":
             suggest = "ipam_ids"
-        elif key == "staticConfig":
-            suggest = "static_config"
+        elif key == "staticConfigs":
+            suggest = "static_configs"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in LoadbalancerPrivateNetwork. Access the value via the '{suggest}' property getter instead.")
@@ -6110,7 +6219,7 @@ class LoadbalancerPrivateNetwork(dict):
                  private_network_id: _builtins.str,
                  dhcp_config: Optional[_builtins.bool] = None,
                  ipam_ids: Optional[_builtins.str] = None,
-                 static_config: Optional[_builtins.str] = None,
+                 static_configs: Optional[Sequence[_builtins.str]] = None,
                  status: Optional[_builtins.str] = None,
                  zone: Optional[_builtins.str] = None):
         """
@@ -6118,7 +6227,7 @@ class LoadbalancerPrivateNetwork(dict):
                - > **Important:** Updates to `private_network` will recreate the attachment.
         :param _builtins.bool dhcp_config: Set to true if you want to let DHCP assign IP addresses
         :param _builtins.str ipam_ids: IPAM ID of a pre-reserved IP address to assign to the Load Balancer on this Private Network.
-        :param _builtins.str static_config: Define an IP address in the subnet of your private network that will be assigned to your load balancer instance
+        :param Sequence[_builtins.str] static_configs: Define an IP address in the subnet of your private network that will be assigned to your load balancer instance
         :param _builtins.str status: The status of the private network connection.
         :param _builtins.str zone: `zone`) The zone of the Load Balancer.
         """
@@ -6127,8 +6236,8 @@ class LoadbalancerPrivateNetwork(dict):
             pulumi.set(__self__, "dhcp_config", dhcp_config)
         if ipam_ids is not None:
             pulumi.set(__self__, "ipam_ids", ipam_ids)
-        if static_config is not None:
-            pulumi.set(__self__, "static_config", static_config)
+        if static_configs is not None:
+            pulumi.set(__self__, "static_configs", static_configs)
         if status is not None:
             pulumi.set(__self__, "status", status)
         if zone is not None:
@@ -6161,13 +6270,13 @@ class LoadbalancerPrivateNetwork(dict):
         return pulumi.get(self, "ipam_ids")
 
     @_builtins.property
-    @pulumi.getter(name="staticConfig")
+    @pulumi.getter(name="staticConfigs")
     @_utilities.deprecated("""static_config field is deprecated, please use `private_network_id` or `ipam_ids` instead""")
-    def static_config(self) -> Optional[_builtins.str]:
+    def static_configs(self) -> Optional[Sequence[_builtins.str]]:
         """
         Define an IP address in the subnet of your private network that will be assigned to your load balancer instance
         """
-        return pulumi.get(self, "static_config")
+        return pulumi.get(self, "static_configs")
 
     @_builtins.property
     @pulumi.getter
@@ -9407,6 +9516,57 @@ class GetDatabaseInstanceReadReplicaResult(dict):
         return pulumi.get(self, "port")
 
 
+@pulumi.output_type
+class GetDatabaseInstanceUpgradableVersionResult(dict):
+    def __init__(__self__, *,
+                 id: _builtins.str,
+                 minor_version: _builtins.str,
+                 name: _builtins.str,
+                 version: _builtins.str):
+        """
+        :param _builtins.str id: The ID of the Database Instance.
+        :param _builtins.str minor_version: Minor version string
+        :param _builtins.str name: The name of the RDB instance.
+        :param _builtins.str version: Version string
+        """
+        pulumi.set(__self__, "id", id)
+        pulumi.set(__self__, "minor_version", minor_version)
+        pulumi.set(__self__, "name", name)
+        pulumi.set(__self__, "version", version)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The ID of the Database Instance.
+        """
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter(name="minorVersion")
+    def minor_version(self) -> _builtins.str:
+        """
+        Minor version string
+        """
+        return pulumi.get(self, "minor_version")
+
+    @_builtins.property
+    @pulumi.getter
+    def name(self) -> _builtins.str:
+        """
+        The name of the RDB instance.
+        """
+        return pulumi.get(self, "name")
+
+    @_builtins.property
+    @pulumi.getter
+    def version(self) -> _builtins.str:
+        """
+        Version string
+        """
+        return pulumi.get(self, "version")
+
+
 @pulumi.output_type
 class GetDomainRecordGeoIpResult(dict):
     def __init__(__self__, *,
@@ -9992,14 +10152,43 @@ class GetInstanceSecurityGroupOutboundRuleResult(dict):
         return pulumi.get(self, "protocol")
 
 
+@pulumi.output_type
+class GetInstanceServerFilesystemResult(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 GetInstanceServerPrivateIpResult(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)
@@ -10008,7 +10197,7 @@ class GetInstanceServerPrivateIpResult(dict):
     @pulumi.getter
     def address(self) -> _builtins.str:
         """
-        The address of the IP
+        The private IP address.
         """
         return pulumi.get(self, "address")
 
@@ -10016,7 +10205,7 @@ class GetInstanceServerPrivateIpResult(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")
 
@@ -10094,11 +10283,11 @@ class GetInstanceServerPublicIpResult(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
         """
@@ -10114,7 +10303,7 @@ class GetInstanceServerPublicIpResult(dict):
     @pulumi.getter
     def address(self) -> _builtins.str:
         """
-        The address of the IP
+        The private IP address.
         """
         return pulumi.get(self, "address")
 
@@ -10146,7 +10335,7 @@ class GetInstanceServerPublicIpResult(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")
 
@@ -10257,20 +10446,14 @@ class GetInstanceServersServerResult(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.GetInstanceServersServerPrivateIpResult'],
                  project_id: _builtins.str,
-                 public_ip: _builtins.str,
                  public_ips: Sequence['outputs.GetInstanceServersServerPublicIpResult'],
                  security_group_id: _builtins.str,
                  state: _builtins.str,
@@ -10281,20 +10464,14 @@ class GetInstanceServersServerResult(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['GetInstanceServersServerPrivateIpArgs'] 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['GetInstanceServersServerPublicIpArgs'] 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`.
@@ -10305,20 +10482,14 @@ class GetInstanceServersServerResult(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)
@@ -10352,14 +10523,6 @@ class GetInstanceServersServerResult(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:
@@ -10376,30 +10539,6 @@ class GetInstanceServersServerResult(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:
@@ -10432,14 +10571,6 @@ class GetInstanceServersServerResult(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.GetInstanceServersServerPrivateIpResult']:
@@ -10456,15 +10587,6 @@ class GetInstanceServersServerResult(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.GetInstanceServersServerPublicIpResult']: