pulumi-linode 5.4.0a1759990883__py3-none-any.whl → 5.5.0a1760077095__py3-none-any.whl

pulumi_linode/get_node_balancer.py

@@ -28,7 +28,7 @@ class GetNodeBalancerResult:
     """
     A collection of values returned by getNodeBalancer.
     """
-    def __init__(__self__, client_conn_throttle=None, client_udp_sess_throttle=None, created=None, firewalls=None, hostname=None, id=None, ipv4=None, ipv6=None, label=None, region=None, tags=None, transfers=None, updated=None):
+    def __init__(__self__, client_conn_throttle=None, client_udp_sess_throttle=None, created=None, firewalls=None, hostname=None, id=None, ipv4=None, ipv6=None, label=None, region=None, tags=None, transfers=None, updated=None, vpcs=None):
         if client_conn_throttle and not isinstance(client_conn_throttle, int):
             raise TypeError("Expected argument 'client_conn_throttle' to be a int")
         pulumi.set(__self__, "client_conn_throttle", client_conn_throttle)
@@ -68,6 +68,9 @@ class GetNodeBalancerResult:
         if updated and not isinstance(updated, str):
             raise TypeError("Expected argument 'updated' to be a str")
         pulumi.set(__self__, "updated", updated)
+        if vpcs and not isinstance(vpcs, list):
+            raise TypeError("Expected argument 'vpcs' to be a list")
+        pulumi.set(__self__, "vpcs", vpcs)
 
     @_builtins.property
     @pulumi.getter(name="clientConnThrottle")
@@ -167,6 +170,11 @@ class GetNodeBalancerResult:
         """
         return pulumi.get(self, "updated")
 
+    @_builtins.property
+    @pulumi.getter
+    def vpcs(self) -> Sequence['outputs.GetNodeBalancerVpcResult']:
+        return pulumi.get(self, "vpcs")
+
 
 class AwaitableGetNodeBalancerResult(GetNodeBalancerResult):
     # pylint: disable=using-constant-test
@@ -186,7 +194,8 @@ class AwaitableGetNodeBalancerResult(GetNodeBalancerResult):
             region=self.region,
             tags=self.tags,
             transfers=self.transfers,
-            updated=self.updated)
+            updated=self.updated,
+            vpcs=self.vpcs)
 
 
 def get_node_balancer(firewalls: Optional[Sequence[Union['GetNodeBalancerFirewallArgs', 'GetNodeBalancerFirewallArgsDict']]] = None,
@@ -227,7 +236,8 @@ def get_node_balancer(firewalls: Optional[Sequence[Union['GetNodeBalancerFirewal
         region=pulumi.get(__ret__, 'region'),
         tags=pulumi.get(__ret__, 'tags'),
         transfers=pulumi.get(__ret__, 'transfers'),
-        updated=pulumi.get(__ret__, 'updated'))
+        updated=pulumi.get(__ret__, 'updated'),
+        vpcs=pulumi.get(__ret__, 'vpcs'))
 def get_node_balancer_output(firewalls: Optional[pulumi.Input[Optional[Sequence[Union['GetNodeBalancerFirewallArgs', 'GetNodeBalancerFirewallArgsDict']]]]] = None,
                              id: Optional[pulumi.Input[_builtins.int]] = None,
                              opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetNodeBalancerResult]:
@@ -265,4 +275,5 @@ def get_node_balancer_output(firewalls: Optional[pulumi.Input[Optional[Sequence[
         region=pulumi.get(__response__, 'region'),
         tags=pulumi.get(__response__, 'tags'),
         transfers=pulumi.get(__response__, 'transfers'),
-        updated=pulumi.get(__response__, 'updated')))
+        updated=pulumi.get(__response__, 'updated'),
+        vpcs=pulumi.get(__response__, 'vpcs')))

pulumi_linode/get_node_balancer_node.py

@@ -26,7 +26,7 @@ class GetNodeBalancerNodeResult:
     """
     A collection of values returned by getNodeBalancerNode.
     """
-    def __init__(__self__, address=None, config_id=None, id=None, label=None, mode=None, nodebalancer_id=None, status=None, weight=None):
+    def __init__(__self__, address=None, config_id=None, id=None, label=None, mode=None, nodebalancer_id=None, status=None, subnet_id=None, vpc_config_id=None, weight=None):
         if address and not isinstance(address, str):
             raise TypeError("Expected argument 'address' to be a str")
         pulumi.set(__self__, "address", address)
@@ -48,6 +48,12 @@ class GetNodeBalancerNodeResult:
         if status and not isinstance(status, str):
             raise TypeError("Expected argument 'status' to be a str")
         pulumi.set(__self__, "status", status)
+        if subnet_id and not isinstance(subnet_id, int):
+            raise TypeError("Expected argument 'subnet_id' to be a int")
+        pulumi.set(__self__, "subnet_id", subnet_id)
+        if vpc_config_id and not isinstance(vpc_config_id, int):
+            raise TypeError("Expected argument 'vpc_config_id' to be a int")
+        pulumi.set(__self__, "vpc_config_id", vpc_config_id)
         if weight and not isinstance(weight, int):
             raise TypeError("Expected argument 'weight' to be a int")
         pulumi.set(__self__, "weight", weight)
@@ -99,6 +105,22 @@ class GetNodeBalancerNodeResult:
         """
         return pulumi.get(self, "status")
 
+    @_builtins.property
+    @pulumi.getter(name="subnetId")
+    def subnet_id(self) -> _builtins.int:
+        """
+        The ID of the related VPC subnet. This is only set for VPC nodes. NOTE: VPC-attached NodeBalancers may not currently be available to all users and may require the `api_version` provider argument must be set to `v4beta`.
+        """
+        return pulumi.get(self, "subnet_id")
+
+    @_builtins.property
+    @pulumi.getter(name="vpcConfigId")
+    def vpc_config_id(self) -> _builtins.int:
+        """
+        The ID of the related NodeBalancer-VPC configuration. This is only set for VPC nodes. NOTE: VPC-attached NodeBalancers may not currently be available to all users and may require the `api_version` provider argument must be set to `v4beta`.
+        """
+        return pulumi.get(self, "vpc_config_id")
+
     @_builtins.property
     @pulumi.getter
     def weight(self) -> _builtins.int:
@@ -121,6 +143,8 @@ class AwaitableGetNodeBalancerNodeResult(GetNodeBalancerNodeResult):
             mode=self.mode,
             nodebalancer_id=self.nodebalancer_id,
             status=self.status,
+            subnet_id=self.subnet_id,
+            vpc_config_id=self.vpc_config_id,
             weight=self.weight)
 
 
@@ -163,6 +187,8 @@ def get_node_balancer_node(config_id: Optional[_builtins.int] = None,
         mode=pulumi.get(__ret__, 'mode'),
         nodebalancer_id=pulumi.get(__ret__, 'nodebalancer_id'),
         status=pulumi.get(__ret__, 'status'),
+        subnet_id=pulumi.get(__ret__, 'subnet_id'),
+        vpc_config_id=pulumi.get(__ret__, 'vpc_config_id'),
         weight=pulumi.get(__ret__, 'weight'))
 def get_node_balancer_node_output(config_id: Optional[pulumi.Input[_builtins.int]] = None,
                                   id: Optional[pulumi.Input[_builtins.int]] = None,
@@ -202,4 +228,6 @@ def get_node_balancer_node_output(config_id: Optional[pulumi.Input[_builtins.int
         mode=pulumi.get(__response__, 'mode'),
         nodebalancer_id=pulumi.get(__response__, 'nodebalancer_id'),
         status=pulumi.get(__response__, 'status'),
+        subnet_id=pulumi.get(__response__, 'subnet_id'),
+        vpc_config_id=pulumi.get(__response__, 'vpc_config_id'),
         weight=pulumi.get(__response__, 'weight')))

pulumi_linode/get_nodebalancer_vpc.py

@@ -0,0 +1,166 @@
+# coding=utf-8
+# *** 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 as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+
+__all__ = [
+    'GetNodebalancerVpcResult',
+    'AwaitableGetNodebalancerVpcResult',
+    'get_nodebalancer_vpc',
+    'get_nodebalancer_vpc_output',
+]
+
+@pulumi.output_type
+class GetNodebalancerVpcResult:
+    """
+    A collection of values returned by getNodebalancerVpc.
+    """
+    def __init__(__self__, id=None, ipv4_range=None, nodebalancer_id=None, subnet_id=None, vpc_id=None):
+        if id and not isinstance(id, int):
+            raise TypeError("Expected argument 'id' to be a int")
+        pulumi.set(__self__, "id", id)
+        if ipv4_range and not isinstance(ipv4_range, str):
+            raise TypeError("Expected argument 'ipv4_range' to be a str")
+        pulumi.set(__self__, "ipv4_range", ipv4_range)
+        if nodebalancer_id and not isinstance(nodebalancer_id, int):
+            raise TypeError("Expected argument 'nodebalancer_id' to be a int")
+        pulumi.set(__self__, "nodebalancer_id", nodebalancer_id)
+        if subnet_id and not isinstance(subnet_id, int):
+            raise TypeError("Expected argument 'subnet_id' to be a int")
+        pulumi.set(__self__, "subnet_id", subnet_id)
+        if vpc_id and not isinstance(vpc_id, int):
+            raise TypeError("Expected argument 'vpc_id' to be a int")
+        pulumi.set(__self__, "vpc_id", vpc_id)
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.int:
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter(name="ipv4Range")
+    def ipv4_range(self) -> _builtins.str:
+        """
+        A CIDR range for the VPC's IPv4 addresses. The NodeBalancer sources IP addresses from this range when routing traffic to the backend VPC nodes.
+        """
+        return pulumi.get(self, "ipv4_range")
+
+    @_builtins.property
+    @pulumi.getter(name="nodebalancerId")
+    def nodebalancer_id(self) -> _builtins.int:
+        return pulumi.get(self, "nodebalancer_id")
+
+    @_builtins.property
+    @pulumi.getter(name="subnetId")
+    def subnet_id(self) -> _builtins.int:
+        """
+        The ID of this configuration's VPC subnet.
+        """
+        return pulumi.get(self, "subnet_id")
+
+    @_builtins.property
+    @pulumi.getter(name="vpcId")
+    def vpc_id(self) -> _builtins.int:
+        """
+        The ID of this configuration's VPC.
+        """
+        return pulumi.get(self, "vpc_id")
+
+
+class AwaitableGetNodebalancerVpcResult(GetNodebalancerVpcResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetNodebalancerVpcResult(
+            id=self.id,
+            ipv4_range=self.ipv4_range,
+            nodebalancer_id=self.nodebalancer_id,
+            subnet_id=self.subnet_id,
+            vpc_id=self.vpc_id)
+
+
+def get_nodebalancer_vpc(id: Optional[_builtins.int] = None,
+                         nodebalancer_id: Optional[_builtins.int] = None,
+                         opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetNodebalancerVpcResult:
+    """
+    > **Limited Availability** VPC-attached NodeBalancers may not currently be available to all users and may require the `api_version` provider argument must be set to `v4beta`.
+
+    Provides information about a NodeBalancer VPC configuration.
+    For more information, see the corresponding [Linode APIv4 documentation](https://techdocs.akamai.com/linode-api/reference/get-node-balancer-vpc-config).
+
+    ## Example Usage
+
+    Retrieve information about a NodeBalancer VPC configuration:
+
+    ```python
+    import pulumi
+    import pulumi_linode as linode
+
+    vpc_config = linode.get_nodebalancer_vpc(nodebalancer_id=123,
+        id=456)
+    ```
+
+
+    :param _builtins.int id: The ID of the VPC configuration.
+    :param _builtins.int nodebalancer_id: The ID of the parent NodeBalancer of the VPC configuration.
+    """
+    __args__ = dict()
+    __args__['id'] = id
+    __args__['nodebalancerId'] = nodebalancer_id
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('linode:index/getNodebalancerVpc:getNodebalancerVpc', __args__, opts=opts, typ=GetNodebalancerVpcResult).value
+
+    return AwaitableGetNodebalancerVpcResult(
+        id=pulumi.get(__ret__, 'id'),
+        ipv4_range=pulumi.get(__ret__, 'ipv4_range'),
+        nodebalancer_id=pulumi.get(__ret__, 'nodebalancer_id'),
+        subnet_id=pulumi.get(__ret__, 'subnet_id'),
+        vpc_id=pulumi.get(__ret__, 'vpc_id'))
+def get_nodebalancer_vpc_output(id: Optional[pulumi.Input[_builtins.int]] = None,
+                                nodebalancer_id: Optional[pulumi.Input[_builtins.int]] = None,
+                                opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetNodebalancerVpcResult]:
+    """
+    > **Limited Availability** VPC-attached NodeBalancers may not currently be available to all users and may require the `api_version` provider argument must be set to `v4beta`.
+
+    Provides information about a NodeBalancer VPC configuration.
+    For more information, see the corresponding [Linode APIv4 documentation](https://techdocs.akamai.com/linode-api/reference/get-node-balancer-vpc-config).
+
+    ## Example Usage
+
+    Retrieve information about a NodeBalancer VPC configuration:
+
+    ```python
+    import pulumi
+    import pulumi_linode as linode
+
+    vpc_config = linode.get_nodebalancer_vpc(nodebalancer_id=123,
+        id=456)
+    ```
+
+
+    :param _builtins.int id: The ID of the VPC configuration.
+    :param _builtins.int nodebalancer_id: The ID of the parent NodeBalancer of the VPC configuration.
+    """
+    __args__ = dict()
+    __args__['id'] = id
+    __args__['nodebalancerId'] = nodebalancer_id
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('linode:index/getNodebalancerVpc:getNodebalancerVpc', __args__, opts=opts, typ=GetNodebalancerVpcResult)
+    return __ret__.apply(lambda __response__: GetNodebalancerVpcResult(
+        id=pulumi.get(__response__, 'id'),
+        ipv4_range=pulumi.get(__response__, 'ipv4_range'),
+        nodebalancer_id=pulumi.get(__response__, 'nodebalancer_id'),
+        subnet_id=pulumi.get(__response__, 'subnet_id'),
+        vpc_id=pulumi.get(__response__, 'vpc_id')))

pulumi_linode/get_nodebalancer_vpcs.py

@@ -0,0 +1,238 @@
+# coding=utf-8
+# *** 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 as _builtins
+import warnings
+import sys
+import pulumi
+import pulumi.runtime
+from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
+from . import _utilities
+from . import outputs
+from ._inputs import *
+
+__all__ = [
+    'GetNodebalancerVpcsResult',
+    'AwaitableGetNodebalancerVpcsResult',
+    'get_nodebalancer_vpcs',
+    'get_nodebalancer_vpcs_output',
+]
+
+@pulumi.output_type
+class GetNodebalancerVpcsResult:
+    """
+    A collection of values returned by getNodebalancerVpcs.
+    """
+    def __init__(__self__, filters=None, id=None, nodebalancer_id=None, order=None, order_by=None, vpc_configs=None):
+        if filters and not isinstance(filters, list):
+            raise TypeError("Expected argument 'filters' to be a list")
+        pulumi.set(__self__, "filters", filters)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if nodebalancer_id and not isinstance(nodebalancer_id, int):
+            raise TypeError("Expected argument 'nodebalancer_id' to be a int")
+        pulumi.set(__self__, "nodebalancer_id", nodebalancer_id)
+        if order and not isinstance(order, str):
+            raise TypeError("Expected argument 'order' to be a str")
+        pulumi.set(__self__, "order", order)
+        if order_by and not isinstance(order_by, str):
+            raise TypeError("Expected argument 'order_by' to be a str")
+        pulumi.set(__self__, "order_by", order_by)
+        if vpc_configs and not isinstance(vpc_configs, list):
+            raise TypeError("Expected argument 'vpc_configs' to be a list")
+        pulumi.set(__self__, "vpc_configs", vpc_configs)
+
+    @_builtins.property
+    @pulumi.getter
+    def filters(self) -> Optional[Sequence['outputs.GetNodebalancerVpcsFilterResult']]:
+        return pulumi.get(self, "filters")
+
+    @_builtins.property
+    @pulumi.getter
+    def id(self) -> _builtins.str:
+        """
+        The ID of the VPC configuration.
+        """
+        return pulumi.get(self, "id")
+
+    @_builtins.property
+    @pulumi.getter(name="nodebalancerId")
+    def nodebalancer_id(self) -> _builtins.int:
+        """
+        The ID of the parent NodeBalancer for this VPC configuration.
+        """
+        return pulumi.get(self, "nodebalancer_id")
+
+    @_builtins.property
+    @pulumi.getter
+    def order(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "order")
+
+    @_builtins.property
+    @pulumi.getter(name="orderBy")
+    def order_by(self) -> Optional[_builtins.str]:
+        return pulumi.get(self, "order_by")
+
+    @_builtins.property
+    @pulumi.getter(name="vpcConfigs")
+    def vpc_configs(self) -> Sequence['outputs.GetNodebalancerVpcsVpcConfigResult']:
+        return pulumi.get(self, "vpc_configs")
+
+
+class AwaitableGetNodebalancerVpcsResult(GetNodebalancerVpcsResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetNodebalancerVpcsResult(
+            filters=self.filters,
+            id=self.id,
+            nodebalancer_id=self.nodebalancer_id,
+            order=self.order,
+            order_by=self.order_by,
+            vpc_configs=self.vpc_configs)
+
+
+def get_nodebalancer_vpcs(filters: Optional[Sequence[Union['GetNodebalancerVpcsFilterArgs', 'GetNodebalancerVpcsFilterArgsDict']]] = None,
+                          nodebalancer_id: Optional[_builtins.int] = None,
+                          order: Optional[_builtins.str] = None,
+                          order_by: Optional[_builtins.str] = None,
+                          opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetNodebalancerVpcsResult:
+    """
+    > **Limited Availability** VPC-attached NodeBalancers may not currently be available to all users and may require the `api_version` provider argument must be set to `v4beta`.
+
+    Provides information about Linode NodeBalancers VPC configurations that match a set of filters.
+    For more information, see the [Linode APIv4 docs](https://techdocs.akamai.com/linode-api/reference/get-node-balancers).
+
+    ## Example Usage
+
+    Retrieve all VPC configurations under a NodeBalancer:
+
+    ```python
+    import pulumi
+    import pulumi_linode as linode
+
+    vpc_configs = linode.get_nodebalancer_vpcs(nodebalancer_id=12345)
+    ```
+
+    Retrieve all VPC configurations under a NodeBalancer with an IPv4 range of "10.0.0.4/30":
+
+    ```python
+    import pulumi
+    import pulumi_linode as linode
+
+    vpc_configs = linode.get_nodebalancer_vpcs(nodebalancer_id=12345,
+        filters=[{
+            "name": "ipv4_range",
+            "values": ["10.0.0.4/30"],
+        }])
+    ```
+
+    ## Filterable Fields
+
+    * `id`
+
+    * `ipv4_range`
+
+    * `nodebalancer_id`
+
+    * `subnet_id`
+
+    * `vpc_id`
+
+
+    :param _builtins.int nodebalancer_id: The ID of the NodeBalancer to list VPC configurations for.
+           
+           * `filter` - (Optional) A set of filters used to select VPC configurations that meet certain requirements.
+    :param _builtins.str order: The order in which results should be returned. (`asc`, `desc`; default `asc`)
+    :param _builtins.str order_by: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.
+    """
+    __args__ = dict()
+    __args__['filters'] = filters
+    __args__['nodebalancerId'] = nodebalancer_id
+    __args__['order'] = order
+    __args__['orderBy'] = order_by
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('linode:index/getNodebalancerVpcs:getNodebalancerVpcs', __args__, opts=opts, typ=GetNodebalancerVpcsResult).value
+
+    return AwaitableGetNodebalancerVpcsResult(
+        filters=pulumi.get(__ret__, 'filters'),
+        id=pulumi.get(__ret__, 'id'),
+        nodebalancer_id=pulumi.get(__ret__, 'nodebalancer_id'),
+        order=pulumi.get(__ret__, 'order'),
+        order_by=pulumi.get(__ret__, 'order_by'),
+        vpc_configs=pulumi.get(__ret__, 'vpc_configs'))
+def get_nodebalancer_vpcs_output(filters: Optional[pulumi.Input[Optional[Sequence[Union['GetNodebalancerVpcsFilterArgs', 'GetNodebalancerVpcsFilterArgsDict']]]]] = None,
+                                 nodebalancer_id: Optional[pulumi.Input[_builtins.int]] = None,
+                                 order: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
+                                 order_by: Optional[pulumi.Input[Optional[_builtins.str]]] = None,
+                                 opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetNodebalancerVpcsResult]:
+    """
+    > **Limited Availability** VPC-attached NodeBalancers may not currently be available to all users and may require the `api_version` provider argument must be set to `v4beta`.
+
+    Provides information about Linode NodeBalancers VPC configurations that match a set of filters.
+    For more information, see the [Linode APIv4 docs](https://techdocs.akamai.com/linode-api/reference/get-node-balancers).
+
+    ## Example Usage
+
+    Retrieve all VPC configurations under a NodeBalancer:
+
+    ```python
+    import pulumi
+    import pulumi_linode as linode
+
+    vpc_configs = linode.get_nodebalancer_vpcs(nodebalancer_id=12345)
+    ```
+
+    Retrieve all VPC configurations under a NodeBalancer with an IPv4 range of "10.0.0.4/30":
+
+    ```python
+    import pulumi
+    import pulumi_linode as linode
+
+    vpc_configs = linode.get_nodebalancer_vpcs(nodebalancer_id=12345,
+        filters=[{
+            "name": "ipv4_range",
+            "values": ["10.0.0.4/30"],
+        }])
+    ```
+
+    ## Filterable Fields
+
+    * `id`
+
+    * `ipv4_range`
+
+    * `nodebalancer_id`
+
+    * `subnet_id`
+
+    * `vpc_id`
+
+
+    :param _builtins.int nodebalancer_id: The ID of the NodeBalancer to list VPC configurations for.
+           
+           * `filter` - (Optional) A set of filters used to select VPC configurations that meet certain requirements.
+    :param _builtins.str order: The order in which results should be returned. (`asc`, `desc`; default `asc`)
+    :param _builtins.str order_by: The attribute to order the results by. See the Filterable Fields section for a list of valid fields.
+    """
+    __args__ = dict()
+    __args__['filters'] = filters
+    __args__['nodebalancerId'] = nodebalancer_id
+    __args__['order'] = order
+    __args__['orderBy'] = order_by
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('linode:index/getNodebalancerVpcs:getNodebalancerVpcs', __args__, opts=opts, typ=GetNodebalancerVpcsResult)
+    return __ret__.apply(lambda __response__: GetNodebalancerVpcsResult(
+        filters=pulumi.get(__response__, 'filters'),
+        id=pulumi.get(__response__, 'id'),
+        nodebalancer_id=pulumi.get(__response__, 'nodebalancer_id'),
+        order=pulumi.get(__response__, 'order'),
+        order_by=pulumi.get(__response__, 'order_by'),
+        vpc_configs=pulumi.get(__response__, 'vpc_configs')))

pulumi_linode/get_user.py

@@ -28,7 +28,7 @@ class GetUserResult:
     """
     A collection of values returned by getUser.
     """
-    def __init__(__self__, database_grants=None, domain_grants=None, email=None, firewall_grants=None, global_grants=None, id=None, image_grants=None, linode_grants=None, longview_grants=None, nodebalancer_grants=None, password_created=None, placement_group_grants=None, restricted=None, ssh_keys=None, stackscript_grants=None, tfa_enabled=None, user_type=None, username=None, verified_phone_number=None, volume_grants=None, vpc_grants=None):
+    def __init__(__self__, database_grants=None, domain_grants=None, email=None, firewall_grants=None, global_grants=None, id=None, image_grants=None, linode_grants=None, longview_grants=None, nodebalancer_grants=None, password_created=None, restricted=None, ssh_keys=None, stackscript_grants=None, tfa_enabled=None, user_type=None, username=None, verified_phone_number=None, volume_grants=None, vpc_grants=None):
         if database_grants and not isinstance(database_grants, list):
             raise TypeError("Expected argument 'database_grants' to be a list")
         pulumi.set(__self__, "database_grants", database_grants)
@@ -62,9 +62,6 @@ class GetUserResult:
         if password_created and not isinstance(password_created, str):
             raise TypeError("Expected argument 'password_created' to be a str")
         pulumi.set(__self__, "password_created", password_created)
-        if placement_group_grants and not isinstance(placement_group_grants, list):
-            raise TypeError("Expected argument 'placement_group_grants' to be a list")
-        pulumi.set(__self__, "placement_group_grants", placement_group_grants)
         if restricted and not isinstance(restricted, bool):
             raise TypeError("Expected argument 'restricted' to be a bool")
         pulumi.set(__self__, "restricted", restricted)
@@ -157,11 +154,6 @@ class GetUserResult:
         """
         return pulumi.get(self, "password_created")
 
-    @_builtins.property
-    @pulumi.getter(name="placementGroupGrants")
-    def placement_group_grants(self) -> Sequence['outputs.GetUserPlacementGroupGrantResult']:
-        return pulumi.get(self, "placement_group_grants")
-
     @_builtins.property
     @pulumi.getter
     def restricted(self) -> _builtins.bool:
@@ -240,7 +232,6 @@ class AwaitableGetUserResult(GetUserResult):
             longview_grants=self.longview_grants,
             nodebalancer_grants=self.nodebalancer_grants,
             password_created=self.password_created,
-            placement_group_grants=self.placement_group_grants,
             restricted=self.restricted,
             ssh_keys=self.ssh_keys,
             stackscript_grants=self.stackscript_grants,
@@ -259,7 +250,6 @@ def get_user(database_grants: Optional[Sequence[Union['GetUserDatabaseGrantArgs'
              linode_grants: Optional[Sequence[Union['GetUserLinodeGrantArgs', 'GetUserLinodeGrantArgsDict']]] = None,
              longview_grants: Optional[Sequence[Union['GetUserLongviewGrantArgs', 'GetUserLongviewGrantArgsDict']]] = None,
              nodebalancer_grants: Optional[Sequence[Union['GetUserNodebalancerGrantArgs', 'GetUserNodebalancerGrantArgsDict']]] = None,
-             placement_group_grants: Optional[Sequence[Union['GetUserPlacementGroupGrantArgs', 'GetUserPlacementGroupGrantArgsDict']]] = None,
              stackscript_grants: Optional[Sequence[Union['GetUserStackscriptGrantArgs', 'GetUserStackscriptGrantArgsDict']]] = None,
              username: Optional[_builtins.str] = None,
              volume_grants: Optional[Sequence[Union['GetUserVolumeGrantArgs', 'GetUserVolumeGrantArgsDict']]] = None,
@@ -293,7 +283,6 @@ def get_user(database_grants: Optional[Sequence[Union['GetUserDatabaseGrantArgs'
     __args__['linodeGrants'] = linode_grants
     __args__['longviewGrants'] = longview_grants
     __args__['nodebalancerGrants'] = nodebalancer_grants
-    __args__['placementGroupGrants'] = placement_group_grants
     __args__['stackscriptGrants'] = stackscript_grants
     __args__['username'] = username
     __args__['volumeGrants'] = volume_grants
@@ -313,7 +302,6 @@ def get_user(database_grants: Optional[Sequence[Union['GetUserDatabaseGrantArgs'
         longview_grants=pulumi.get(__ret__, 'longview_grants'),
         nodebalancer_grants=pulumi.get(__ret__, 'nodebalancer_grants'),
         password_created=pulumi.get(__ret__, 'password_created'),
-        placement_group_grants=pulumi.get(__ret__, 'placement_group_grants'),
         restricted=pulumi.get(__ret__, 'restricted'),
         ssh_keys=pulumi.get(__ret__, 'ssh_keys'),
         stackscript_grants=pulumi.get(__ret__, 'stackscript_grants'),
@@ -330,7 +318,6 @@ def get_user_output(database_grants: Optional[pulumi.Input[Optional[Sequence[Uni
                     linode_grants: Optional[pulumi.Input[Optional[Sequence[Union['GetUserLinodeGrantArgs', 'GetUserLinodeGrantArgsDict']]]]] = None,
                     longview_grants: Optional[pulumi.Input[Optional[Sequence[Union['GetUserLongviewGrantArgs', 'GetUserLongviewGrantArgsDict']]]]] = None,
                     nodebalancer_grants: Optional[pulumi.Input[Optional[Sequence[Union['GetUserNodebalancerGrantArgs', 'GetUserNodebalancerGrantArgsDict']]]]] = None,
-                    placement_group_grants: Optional[pulumi.Input[Optional[Sequence[Union['GetUserPlacementGroupGrantArgs', 'GetUserPlacementGroupGrantArgsDict']]]]] = None,
                     stackscript_grants: Optional[pulumi.Input[Optional[Sequence[Union['GetUserStackscriptGrantArgs', 'GetUserStackscriptGrantArgsDict']]]]] = None,
                     username: Optional[pulumi.Input[_builtins.str]] = None,
                     volume_grants: Optional[pulumi.Input[Optional[Sequence[Union['GetUserVolumeGrantArgs', 'GetUserVolumeGrantArgsDict']]]]] = None,
@@ -364,7 +351,6 @@ def get_user_output(database_grants: Optional[pulumi.Input[Optional[Sequence[Uni
     __args__['linodeGrants'] = linode_grants
     __args__['longviewGrants'] = longview_grants
     __args__['nodebalancerGrants'] = nodebalancer_grants
-    __args__['placementGroupGrants'] = placement_group_grants
     __args__['stackscriptGrants'] = stackscript_grants
     __args__['username'] = username
     __args__['volumeGrants'] = volume_grants
@@ -383,7 +369,6 @@ def get_user_output(database_grants: Optional[pulumi.Input[Optional[Sequence[Uni
         longview_grants=pulumi.get(__response__, 'longview_grants'),
         nodebalancer_grants=pulumi.get(__response__, 'nodebalancer_grants'),
         password_created=pulumi.get(__response__, 'password_created'),
-        placement_group_grants=pulumi.get(__response__, 'placement_group_grants'),
         restricted=pulumi.get(__response__, 'restricted'),
         ssh_keys=pulumi.get(__response__, 'ssh_keys'),
         stackscript_grants=pulumi.get(__response__, 'stackscript_grants'),