pulumiverse-scaleway 1.27.1__py3-none-any.whl → 1.28.0__py3-none-any.whl

pulumiverse_scaleway/get_instance_private_nic.py

@@ -13,6 +13,7 @@ if sys.version_info >= (3, 11):
 else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from . import _utilities
+from . import outputs
 
 __all__ = [
     'GetInstancePrivateNicResult',
@@ -28,7 +29,7 @@ class GetInstancePrivateNicResult:
     """
     A collection of values returned by getInstancePrivateNic.
     """
-    def __init__(__self__, id=None, ip_ids=None, ipam_ip_ids=None, mac_address=None, private_network_id=None, private_nic_id=None, server_id=None, tags=None, zone=None):
+    def __init__(__self__, id=None, ip_ids=None, ipam_ip_ids=None, mac_address=None, private_ips=None, private_network_id=None, private_nic_id=None, server_id=None, tags=None, zone=None):
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
@@ -41,6 +42,9 @@ class GetInstancePrivateNicResult:
         if mac_address and not isinstance(mac_address, str):
             raise TypeError("Expected argument 'mac_address' to be a str")
         pulumi.set(__self__, "mac_address", mac_address)
+        if private_ips and not isinstance(private_ips, list):
+            raise TypeError("Expected argument 'private_ips' to be a list")
+        pulumi.set(__self__, "private_ips", private_ips)
         if private_network_id and not isinstance(private_network_id, str):
             raise TypeError("Expected argument 'private_network_id' to be a str")
         pulumi.set(__self__, "private_network_id", private_network_id)
@@ -80,6 +84,11 @@ class GetInstancePrivateNicResult:
     def mac_address(self) -> str:
         return pulumi.get(self, "mac_address")
 
+    @property
+    @pulumi.getter(name="privateIps")
+    def private_ips(self) -> Sequence['outputs.GetInstancePrivateNicPrivateIpResult']:
+        return pulumi.get(self, "private_ips")
+
     @property
     @pulumi.getter(name="privateNetworkId")
     def private_network_id(self) -> Optional[str]:
@@ -116,6 +125,7 @@ class AwaitableGetInstancePrivateNicResult(GetInstancePrivateNicResult):
             ip_ids=self.ip_ids,
             ipam_ip_ids=self.ipam_ip_ids,
             mac_address=self.mac_address,
+            private_ips=self.private_ips,
             private_network_id=self.private_network_id,
             private_nic_id=self.private_nic_id,
             server_id=self.server_id,
@@ -171,6 +181,7 @@ def get_instance_private_nic(private_network_id: Optional[str] = None,
         ip_ids=pulumi.get(__ret__, 'ip_ids'),
         ipam_ip_ids=pulumi.get(__ret__, 'ipam_ip_ids'),
         mac_address=pulumi.get(__ret__, 'mac_address'),
+        private_ips=pulumi.get(__ret__, 'private_ips'),
         private_network_id=pulumi.get(__ret__, 'private_network_id'),
         private_nic_id=pulumi.get(__ret__, 'private_nic_id'),
         server_id=pulumi.get(__ret__, 'server_id'),
@@ -223,6 +234,7 @@ def get_instance_private_nic_output(private_network_id: Optional[pulumi.Input[Op
         ip_ids=pulumi.get(__response__, 'ip_ids'),
         ipam_ip_ids=pulumi.get(__response__, 'ipam_ip_ids'),
         mac_address=pulumi.get(__response__, 'mac_address'),
+        private_ips=pulumi.get(__response__, 'private_ips'),
         private_network_id=pulumi.get(__response__, 'private_network_id'),
         private_nic_id=pulumi.get(__response__, 'private_nic_id'),
         server_id=pulumi.get(__response__, 'server_id'),

pulumiverse_scaleway/get_instance_server.py

@@ -29,7 +29,7 @@ class GetInstanceServerResult:
     """
     A collection of values returned by getInstanceServer.
     """
-    def __init__(__self__, additional_volume_ids=None, boot_type=None, bootscript_id=None, cloud_init=None, enable_dynamic_ip=None, enable_ipv6=None, id=None, image=None, ip_id=None, ip_ids=None, ipv6_address=None, ipv6_gateway=None, ipv6_prefix_length=None, name=None, organization_id=None, placement_group_id=None, placement_group_policy_respected=None, private_ip=None, private_networks=None, project_id=None, protected=None, public_ip=None, public_ips=None, replace_on_type_change=None, root_volumes=None, security_group_id=None, server_id=None, state=None, tags=None, type=None, user_data=None, zone=None):
+    def __init__(__self__, additional_volume_ids=None, boot_type=None, bootscript_id=None, cloud_init=None, enable_dynamic_ip=None, enable_ipv6=None, id=None, image=None, ip_id=None, ip_ids=None, ipv6_address=None, ipv6_gateway=None, ipv6_prefix_length=None, name=None, organization_id=None, placement_group_id=None, placement_group_policy_respected=None, private_ip=None, private_ips=None, private_networks=None, project_id=None, protected=None, public_ip=None, public_ips=None, replace_on_type_change=None, root_volumes=None, security_group_id=None, server_id=None, state=None, tags=None, type=None, user_data=None, zone=None):
         if additional_volume_ids and not isinstance(additional_volume_ids, list):
             raise TypeError("Expected argument 'additional_volume_ids' to be a list")
         pulumi.set(__self__, "additional_volume_ids", additional_volume_ids)
@@ -84,6 +84,9 @@ class GetInstanceServerResult:
         if private_ip and not isinstance(private_ip, str):
             raise TypeError("Expected argument 'private_ip' to be a str")
         pulumi.set(__self__, "private_ip", private_ip)
+        if private_ips and not isinstance(private_ips, list):
+            raise TypeError("Expected argument 'private_ips' to be a list")
+        pulumi.set(__self__, "private_ips", private_ips)
         if private_networks and not isinstance(private_networks, list):
             raise TypeError("Expected argument 'private_networks' to be a list")
         pulumi.set(__self__, "private_networks", private_networks)
@@ -257,6 +260,11 @@ class GetInstanceServerResult:
         """
         return pulumi.get(self, "private_ip")
 
+    @property
+    @pulumi.getter(name="privateIps")
+    def private_ips(self) -> Sequence['outputs.GetInstanceServerPrivateIpResult']:
+        return pulumi.get(self, "private_ips")
+
     @property
     @pulumi.getter(name="privateNetworks")
     def private_networks(self) -> Sequence['outputs.GetInstanceServerPrivateNetworkResult']:
@@ -374,6 +382,7 @@ class AwaitableGetInstanceServerResult(GetInstanceServerResult):
             placement_group_id=self.placement_group_id,
             placement_group_policy_respected=self.placement_group_policy_respected,
             private_ip=self.private_ip,
+            private_ips=self.private_ips,
             private_networks=self.private_networks,
             project_id=self.project_id,
             protected=self.protected,
@@ -432,6 +441,7 @@ def get_instance_server(name: Optional[str] = None,
         placement_group_id=pulumi.get(__ret__, 'placement_group_id'),
         placement_group_policy_respected=pulumi.get(__ret__, 'placement_group_policy_respected'),
         private_ip=pulumi.get(__ret__, 'private_ip'),
+        private_ips=pulumi.get(__ret__, 'private_ips'),
         private_networks=pulumi.get(__ret__, 'private_networks'),
         project_id=pulumi.get(__ret__, 'project_id'),
         protected=pulumi.get(__ret__, 'protected'),
@@ -487,6 +497,7 @@ def get_instance_server_output(name: Optional[pulumi.Input[Optional[str]]] = Non
         placement_group_id=pulumi.get(__response__, 'placement_group_id'),
         placement_group_policy_respected=pulumi.get(__response__, 'placement_group_policy_respected'),
         private_ip=pulumi.get(__response__, 'private_ip'),
+        private_ips=pulumi.get(__response__, 'private_ips'),
         private_networks=pulumi.get(__response__, 'private_networks'),
         project_id=pulumi.get(__response__, 'project_id'),
         protected=pulumi.get(__response__, 'protected'),

pulumiverse_scaleway/get_lb_route.py

@@ -28,7 +28,7 @@ class GetLbRouteResult:
     """
     A collection of values returned by getLbRoute.
     """
-    def __init__(__self__, backend_id=None, created_at=None, frontend_id=None, id=None, match_host_header=None, match_sni=None, match_subdomains=None, route_id=None, updated_at=None):
+    def __init__(__self__, backend_id=None, created_at=None, frontend_id=None, id=None, match_host_header=None, match_path_begin=None, match_sni=None, match_subdomains=None, route_id=None, updated_at=None):
         if backend_id and not isinstance(backend_id, str):
             raise TypeError("Expected argument 'backend_id' to be a str")
         pulumi.set(__self__, "backend_id", backend_id)
@@ -44,6 +44,9 @@ class GetLbRouteResult:
         if match_host_header and not isinstance(match_host_header, str):
             raise TypeError("Expected argument 'match_host_header' to be a str")
         pulumi.set(__self__, "match_host_header", match_host_header)
+        if match_path_begin and not isinstance(match_path_begin, str):
+            raise TypeError("Expected argument 'match_path_begin' to be a str")
+        pulumi.set(__self__, "match_path_begin", match_path_begin)
         if match_sni and not isinstance(match_sni, str):
             raise TypeError("Expected argument 'match_sni' to be a str")
         pulumi.set(__self__, "match_sni", match_sni)
@@ -85,6 +88,11 @@ class GetLbRouteResult:
     def match_host_header(self) -> str:
         return pulumi.get(self, "match_host_header")
 
+    @property
+    @pulumi.getter(name="matchPathBegin")
+    def match_path_begin(self) -> str:
+        return pulumi.get(self, "match_path_begin")
+
     @property
     @pulumi.getter(name="matchSni")
     def match_sni(self) -> str:
@@ -117,6 +125,7 @@ class AwaitableGetLbRouteResult(GetLbRouteResult):
             frontend_id=self.frontend_id,
             id=self.id,
             match_host_header=self.match_host_header,
+            match_path_begin=self.match_path_begin,
             match_sni=self.match_sni,
             match_subdomains=self.match_subdomains,
             route_id=self.route_id,
@@ -173,6 +182,7 @@ def get_lb_route(route_id: Optional[str] = None,
         frontend_id=pulumi.get(__ret__, 'frontend_id'),
         id=pulumi.get(__ret__, 'id'),
         match_host_header=pulumi.get(__ret__, 'match_host_header'),
+        match_path_begin=pulumi.get(__ret__, 'match_path_begin'),
         match_sni=pulumi.get(__ret__, 'match_sni'),
         match_subdomains=pulumi.get(__ret__, 'match_subdomains'),
         route_id=pulumi.get(__ret__, 'route_id'),
@@ -226,6 +236,7 @@ def get_lb_route_output(route_id: Optional[pulumi.Input[str]] = None,
         frontend_id=pulumi.get(__response__, 'frontend_id'),
         id=pulumi.get(__response__, 'id'),
         match_host_header=pulumi.get(__response__, 'match_host_header'),
+        match_path_begin=pulumi.get(__response__, 'match_path_begin'),
         match_sni=pulumi.get(__response__, 'match_sni'),
         match_subdomains=pulumi.get(__response__, 'match_subdomains'),
         route_id=pulumi.get(__response__, 'route_id'),

pulumiverse_scaleway/get_loadbalancer.py

@@ -29,7 +29,7 @@ class GetLoadbalancerResult:
     """
     A collection of values returned by getLoadbalancer.
     """
-    def __init__(__self__, assign_flexible_ip=None, assign_flexible_ipv6=None, description=None, id=None, ip_address=None, ip_id=None, ip_ids=None, ipv6_address=None, lb_id=None, name=None, organization_id=None, private_networks=None, project_id=None, region=None, release_ip=None, ssl_compatibility_level=None, tags=None, type=None, zone=None):
+    def __init__(__self__, assign_flexible_ip=None, assign_flexible_ipv6=None, description=None, id=None, ip_address=None, ip_id=None, ip_ids=None, ipv6_address=None, lb_id=None, name=None, organization_id=None, private_ips=None, private_networks=None, project_id=None, region=None, release_ip=None, ssl_compatibility_level=None, tags=None, type=None, zone=None):
         if assign_flexible_ip and not isinstance(assign_flexible_ip, bool):
             raise TypeError("Expected argument 'assign_flexible_ip' to be a bool")
         pulumi.set(__self__, "assign_flexible_ip", assign_flexible_ip)
@@ -63,6 +63,9 @@ class GetLoadbalancerResult:
         if organization_id and not isinstance(organization_id, str):
             raise TypeError("Expected argument 'organization_id' to be a str")
         pulumi.set(__self__, "organization_id", organization_id)
+        if private_ips and not isinstance(private_ips, list):
+            raise TypeError("Expected argument 'private_ips' to be a list")
+        pulumi.set(__self__, "private_ips", private_ips)
         if private_networks and not isinstance(private_networks, list):
             raise TypeError("Expected argument 'private_networks' to be a list")
         pulumi.set(__self__, "private_networks", private_networks)
@@ -149,6 +152,11 @@ class GetLoadbalancerResult:
     def organization_id(self) -> str:
         return pulumi.get(self, "organization_id")
 
+    @property
+    @pulumi.getter(name="privateIps")
+    def private_ips(self) -> Sequence['outputs.GetLoadbalancerPrivateIpResult']:
+        return pulumi.get(self, "private_ips")
+
     @property
     @pulumi.getter(name="privateNetworks")
     def private_networks(self) -> Sequence['outputs.GetLoadbalancerPrivateNetworkResult']:
@@ -216,6 +224,7 @@ class AwaitableGetLoadbalancerResult(GetLoadbalancerResult):
             lb_id=self.lb_id,
             name=self.name,
             organization_id=self.organization_id,
+            private_ips=self.private_ips,
             private_networks=self.private_networks,
             project_id=self.project_id,
             region=self.region,
@@ -276,6 +285,7 @@ def get_loadbalancer(lb_id: Optional[str] = None,
         lb_id=pulumi.get(__ret__, 'lb_id'),
         name=pulumi.get(__ret__, 'name'),
         organization_id=pulumi.get(__ret__, 'organization_id'),
+        private_ips=pulumi.get(__ret__, 'private_ips'),
         private_networks=pulumi.get(__ret__, 'private_networks'),
         project_id=pulumi.get(__ret__, 'project_id'),
         region=pulumi.get(__ret__, 'region'),
@@ -333,6 +343,7 @@ def get_loadbalancer_output(lb_id: Optional[pulumi.Input[Optional[str]]] = None,
         lb_id=pulumi.get(__response__, 'lb_id'),
         name=pulumi.get(__response__, 'name'),
         organization_id=pulumi.get(__response__, 'organization_id'),
+        private_ips=pulumi.get(__response__, 'private_ips'),
         private_networks=pulumi.get(__response__, 'private_networks'),
         project_id=pulumi.get(__response__, 'project_id'),
         region=pulumi.get(__response__, 'region'),

pulumiverse_scaleway/get_redis_cluster.py

@@ -29,7 +29,7 @@ class GetRedisClusterResult:
     """
     A collection of values returned by getRedisCluster.
     """
-    def __init__(__self__, acls=None, certificate=None, cluster_id=None, cluster_size=None, created_at=None, id=None, name=None, node_type=None, password=None, private_networks=None, project_id=None, public_networks=None, settings=None, tags=None, tls_enabled=None, updated_at=None, user_name=None, version=None, zone=None):
+    def __init__(__self__, acls=None, certificate=None, cluster_id=None, cluster_size=None, created_at=None, id=None, name=None, node_type=None, password=None, private_ips=None, private_networks=None, project_id=None, public_networks=None, settings=None, tags=None, tls_enabled=None, updated_at=None, user_name=None, version=None, zone=None):
         if acls and not isinstance(acls, list):
             raise TypeError("Expected argument 'acls' to be a list")
         pulumi.set(__self__, "acls", acls)
@@ -57,6 +57,9 @@ class GetRedisClusterResult:
         if password and not isinstance(password, str):
             raise TypeError("Expected argument 'password' to be a str")
         pulumi.set(__self__, "password", password)
+        if private_ips and not isinstance(private_ips, list):
+            raise TypeError("Expected argument 'private_ips' to be a list")
+        pulumi.set(__self__, "private_ips", private_ips)
         if private_networks and not isinstance(private_networks, list):
             raise TypeError("Expected argument 'private_networks' to be a list")
         pulumi.set(__self__, "private_networks", private_networks)
@@ -154,6 +157,11 @@ class GetRedisClusterResult:
         """
         return pulumi.get(self, "password")
 
+    @property
+    @pulumi.getter(name="privateIps")
+    def private_ips(self) -> Sequence['outputs.GetRedisClusterPrivateIpResult']:
+        return pulumi.get(self, "private_ips")
+
     @property
     @pulumi.getter(name="privateNetworks")
     def private_networks(self) -> Sequence['outputs.GetRedisClusterPrivateNetworkResult']:
@@ -244,6 +252,7 @@ class AwaitableGetRedisClusterResult(GetRedisClusterResult):
             name=self.name,
             node_type=self.node_type,
             password=self.password,
+            private_ips=self.private_ips,
             private_networks=self.private_networks,
             project_id=self.project_id,
             public_networks=self.public_networks,
@@ -293,6 +302,7 @@ def get_redis_cluster(cluster_id: Optional[str] = None,
         name=pulumi.get(__ret__, 'name'),
         node_type=pulumi.get(__ret__, 'node_type'),
         password=pulumi.get(__ret__, 'password'),
+        private_ips=pulumi.get(__ret__, 'private_ips'),
         private_networks=pulumi.get(__ret__, 'private_networks'),
         project_id=pulumi.get(__ret__, 'project_id'),
         public_networks=pulumi.get(__ret__, 'public_networks'),
@@ -339,6 +349,7 @@ def get_redis_cluster_output(cluster_id: Optional[pulumi.Input[Optional[str]]] =
         name=pulumi.get(__response__, 'name'),
         node_type=pulumi.get(__response__, 'node_type'),
         password=pulumi.get(__response__, 'password'),
+        private_ips=pulumi.get(__response__, 'private_ips'),
         private_networks=pulumi.get(__response__, 'private_networks'),
         project_id=pulumi.get(__response__, 'project_id'),
         public_networks=pulumi.get(__response__, 'public_networks'),

pulumiverse_scaleway/get_vpc_gateway_network.py

@@ -29,7 +29,7 @@ class GetVpcGatewayNetworkResult:
     """
     A collection of values returned by getVpcGatewayNetwork.
     """
-    def __init__(__self__, cleanup_dhcp=None, created_at=None, dhcp_id=None, enable_dhcp=None, enable_masquerade=None, gateway_id=None, gateway_network_id=None, id=None, ipam_configs=None, mac_address=None, private_network_id=None, static_address=None, status=None, updated_at=None, zone=None):
+    def __init__(__self__, cleanup_dhcp=None, created_at=None, dhcp_id=None, enable_dhcp=None, enable_masquerade=None, gateway_id=None, gateway_network_id=None, id=None, ipam_configs=None, mac_address=None, private_ips=None, private_network_id=None, static_address=None, status=None, updated_at=None, zone=None):
         if cleanup_dhcp and not isinstance(cleanup_dhcp, bool):
             raise TypeError("Expected argument 'cleanup_dhcp' to be a bool")
         pulumi.set(__self__, "cleanup_dhcp", cleanup_dhcp)
@@ -60,6 +60,9 @@ class GetVpcGatewayNetworkResult:
         if mac_address and not isinstance(mac_address, str):
             raise TypeError("Expected argument 'mac_address' to be a str")
         pulumi.set(__self__, "mac_address", mac_address)
+        if private_ips and not isinstance(private_ips, list):
+            raise TypeError("Expected argument 'private_ips' to be a list")
+        pulumi.set(__self__, "private_ips", private_ips)
         if private_network_id and not isinstance(private_network_id, str):
             raise TypeError("Expected argument 'private_network_id' to be a str")
         pulumi.set(__self__, "private_network_id", private_network_id)
@@ -129,6 +132,11 @@ class GetVpcGatewayNetworkResult:
     def mac_address(self) -> str:
         return pulumi.get(self, "mac_address")
 
+    @property
+    @pulumi.getter(name="privateIps")
+    def private_ips(self) -> Sequence['outputs.GetVpcGatewayNetworkPrivateIpResult']:
+        return pulumi.get(self, "private_ips")
+
     @property
     @pulumi.getter(name="privateNetworkId")
     def private_network_id(self) -> Optional[str]:
@@ -171,6 +179,7 @@ class AwaitableGetVpcGatewayNetworkResult(GetVpcGatewayNetworkResult):
             id=self.id,
             ipam_configs=self.ipam_configs,
             mac_address=self.mac_address,
+            private_ips=self.private_ips,
             private_network_id=self.private_network_id,
             static_address=self.static_address,
             status=self.status,
@@ -229,6 +238,7 @@ def get_vpc_gateway_network(dhcp_id: Optional[str] = None,
         id=pulumi.get(__ret__, 'id'),
         ipam_configs=pulumi.get(__ret__, 'ipam_configs'),
         mac_address=pulumi.get(__ret__, 'mac_address'),
+        private_ips=pulumi.get(__ret__, 'private_ips'),
         private_network_id=pulumi.get(__ret__, 'private_network_id'),
         static_address=pulumi.get(__ret__, 'static_address'),
         status=pulumi.get(__ret__, 'status'),
@@ -284,6 +294,7 @@ def get_vpc_gateway_network_output(dhcp_id: Optional[pulumi.Input[Optional[str]]
         id=pulumi.get(__response__, 'id'),
         ipam_configs=pulumi.get(__response__, 'ipam_configs'),
         mac_address=pulumi.get(__response__, 'mac_address'),
+        private_ips=pulumi.get(__response__, 'private_ips'),
         private_network_id=pulumi.get(__response__, 'private_network_id'),
         static_address=pulumi.get(__response__, 'static_address'),
         status=pulumi.get(__response__, 'status'),

pulumiverse_scaleway/inference/__init__.py

@@ -6,5 +6,7 @@ from .. import _utilities
 import typing
 # Export this package's modules as members:
 from .deployment import *
+from .get_model import *
+from .model import *
 from ._inputs import *
 from . import outputs

pulumiverse_scaleway/inference/_inputs.py

@@ -19,6 +19,10 @@ __all__ = [
     'DeploymentPrivateEndpointArgsDict',
     'DeploymentPublicEndpointArgs',
     'DeploymentPublicEndpointArgsDict',
+    'ModelNodesSupportArgs',
+    'ModelNodesSupportArgsDict',
+    'ModelNodesSupportQuantizationArgs',
+    'ModelNodesSupportQuantizationArgsDict',
 ]
 
 MYPY = False
@@ -207,3 +211,127 @@ class DeploymentPublicEndpointArgs:
         pulumi.set(self, "url", value)
 
 
+if not MYPY:
+    class ModelNodesSupportArgsDict(TypedDict):
+        node_type_name: NotRequired[pulumi.Input[str]]
+        """
+        The type of node supported.
+        """
+        quantizations: NotRequired[pulumi.Input[Sequence[pulumi.Input['ModelNodesSupportQuantizationArgsDict']]]]
+        """
+        A list of supported quantization options, including:
+        """
+elif False:
+    ModelNodesSupportArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ModelNodesSupportArgs:
+    def __init__(__self__, *,
+                 node_type_name: Optional[pulumi.Input[str]] = None,
+                 quantizations: Optional[pulumi.Input[Sequence[pulumi.Input['ModelNodesSupportQuantizationArgs']]]] = None):
+        """
+        :param pulumi.Input[str] node_type_name: The type of node supported.
+        :param pulumi.Input[Sequence[pulumi.Input['ModelNodesSupportQuantizationArgs']]] quantizations: A list of supported quantization options, including:
+        """
+        if node_type_name is not None:
+            pulumi.set(__self__, "node_type_name", node_type_name)
+        if quantizations is not None:
+            pulumi.set(__self__, "quantizations", quantizations)
+
+    @property
+    @pulumi.getter(name="nodeTypeName")
+    def node_type_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        The type of node supported.
+        """
+        return pulumi.get(self, "node_type_name")
+
+    @node_type_name.setter
+    def node_type_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "node_type_name", value)
+
+    @property
+    @pulumi.getter
+    def quantizations(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['ModelNodesSupportQuantizationArgs']]]]:
+        """
+        A list of supported quantization options, including:
+        """
+        return pulumi.get(self, "quantizations")
+
+    @quantizations.setter
+    def quantizations(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['ModelNodesSupportQuantizationArgs']]]]):
+        pulumi.set(self, "quantizations", value)
+
+
+if not MYPY:
+    class ModelNodesSupportQuantizationArgsDict(TypedDict):
+        allowed: NotRequired[pulumi.Input[bool]]
+        """
+        Whether this quantization is allowed.
+        """
+        max_context_size: NotRequired[pulumi.Input[int]]
+        """
+        Maximum context length supported by this quantization.
+        """
+        quantization_bits: NotRequired[pulumi.Input[int]]
+        """
+        Number of bits used for quantization (e.g., 8, 16).
+        """
+elif False:
+    ModelNodesSupportQuantizationArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ModelNodesSupportQuantizationArgs:
+    def __init__(__self__, *,
+                 allowed: Optional[pulumi.Input[bool]] = None,
+                 max_context_size: Optional[pulumi.Input[int]] = None,
+                 quantization_bits: Optional[pulumi.Input[int]] = None):
+        """
+        :param pulumi.Input[bool] allowed: Whether this quantization is allowed.
+        :param pulumi.Input[int] max_context_size: Maximum context length supported by this quantization.
+        :param pulumi.Input[int] quantization_bits: Number of bits used for quantization (e.g., 8, 16).
+        """
+        if allowed is not None:
+            pulumi.set(__self__, "allowed", allowed)
+        if max_context_size is not None:
+            pulumi.set(__self__, "max_context_size", max_context_size)
+        if quantization_bits is not None:
+            pulumi.set(__self__, "quantization_bits", quantization_bits)
+
+    @property
+    @pulumi.getter
+    def allowed(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Whether this quantization is allowed.
+        """
+        return pulumi.get(self, "allowed")
+
+    @allowed.setter
+    def allowed(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "allowed", value)
+
+    @property
+    @pulumi.getter(name="maxContextSize")
+    def max_context_size(self) -> Optional[pulumi.Input[int]]:
+        """
+        Maximum context length supported by this quantization.
+        """
+        return pulumi.get(self, "max_context_size")
+
+    @max_context_size.setter
+    def max_context_size(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "max_context_size", value)
+
+    @property
+    @pulumi.getter(name="quantizationBits")
+    def quantization_bits(self) -> Optional[pulumi.Input[int]]:
+        """
+        Number of bits used for quantization (e.g., 8, 16).
+        """
+        return pulumi.get(self, "quantization_bits")
+
+    @quantization_bits.setter
+    def quantization_bits(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "quantization_bits", value)
+
+