pulumi-digitalocean 4.46.0a1748901174__tar.gz → 4.46.0a1749009476__tar.gz

{pulumi_digitalocean-4.46.0a1748901174 → pulumi_digitalocean-4.46.0a1749009476}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pulumi_digitalocean
-Version: 4.46.0a1748901174
+Version: 4.46.0a1749009476
 Summary: A Pulumi package for creating and managing DigitalOcean cloud resources.
 License: Apache-2.0
 Project-URL: Homepage, https://pulumi.io

{pulumi_digitalocean-4.46.0a1748901174 → pulumi_digitalocean-4.46.0a1749009476}/pulumi_digitalocean/__init__.py

@@ -78,6 +78,7 @@ from .get_tags import *
 from .get_volume import *
 from .get_volume_snapshot import *
 from .get_vpc import *
+from .get_vpc_nat_gateway import *
 from .get_vpc_peering import *
 from .kubernetes_cluster import *
 from .kubernetes_node_pool import *
@@ -105,6 +106,7 @@ from .volume import *
 from .volume_attachment import *
 from .volume_snapshot import *
 from .vpc import *
+from .vpc_nat_gateway import *
 from .vpc_peering import *
 from ._inputs import *
 from . import outputs
@@ -535,6 +537,14 @@ _utilities.register(
    "digitalocean:index/vpc:Vpc": "Vpc"
   }
  },
+ {
+  "pkg": "digitalocean",
+  "mod": "index/vpcNatGateway",
+  "fqn": "pulumi_digitalocean",
+  "classes": {
+   "digitalocean:index/vpcNatGateway:VpcNatGateway": "VpcNatGateway"
+  }
+ },
  {
   "pkg": "digitalocean",
   "mod": "index/vpcPeering",

{pulumi_digitalocean-4.46.0a1748901174 → pulumi_digitalocean-4.46.0a1749009476}/pulumi_digitalocean/_inputs.py

@@ -303,6 +303,12 @@ __all__ = [
     'UptimeAlertNotificationArgsDict',
     'UptimeAlertNotificationSlackArgs',
     'UptimeAlertNotificationSlackArgsDict',
+    'VpcNatGatewayEgressArgs',
+    'VpcNatGatewayEgressArgsDict',
+    'VpcNatGatewayEgressPublicGatewayArgs',
+    'VpcNatGatewayEgressPublicGatewayArgsDict',
+    'VpcNatGatewayVpcArgs',
+    'VpcNatGatewayVpcArgsDict',
     'GetAppDedicatedIpArgs',
     'GetAppDedicatedIpArgsDict',
     'GetDomainsFilterArgs',
@@ -11054,9 +11060,12 @@ class KubernetesClusterClusterAutoscalerConfigurationArgs:
 if not MYPY:
     class KubernetesClusterControlPlaneFirewallArgsDict(TypedDict):
         allowed_addresses: pulumi.Input[Sequence[pulumi.Input[builtins.str]]]
+        """
+        A list of addresses allowed (CIDR notation).
+        """
         enabled: pulumi.Input[builtins.bool]
         """
-        Boolean flag whether the routing-agent is enabled or not.
+        Boolean flag whether the firewall should be enabled or not.
         """
 elif False:
     KubernetesClusterControlPlaneFirewallArgsDict: TypeAlias = Mapping[str, Any]
@@ -11067,7 +11076,8 @@ class KubernetesClusterControlPlaneFirewallArgs:
                  allowed_addresses: pulumi.Input[Sequence[pulumi.Input[builtins.str]]],
                  enabled: pulumi.Input[builtins.bool]):
         """
-        :param pulumi.Input[builtins.bool] enabled: Boolean flag whether the routing-agent is enabled or not.
+        :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] allowed_addresses: A list of addresses allowed (CIDR notation).
+        :param pulumi.Input[builtins.bool] enabled: Boolean flag whether the firewall should be enabled or not.
         """
         pulumi.set(__self__, "allowed_addresses", allowed_addresses)
         pulumi.set(__self__, "enabled", enabled)
@@ -11075,6 +11085,9 @@ class KubernetesClusterControlPlaneFirewallArgs:
     @property
     @pulumi.getter(name="allowedAddresses")
     def allowed_addresses(self) -> pulumi.Input[Sequence[pulumi.Input[builtins.str]]]:
+        """
+        A list of addresses allowed (CIDR notation).
+        """
         return pulumi.get(self, "allowed_addresses")
 
     @allowed_addresses.setter
@@ -11085,7 +11098,7 @@ class KubernetesClusterControlPlaneFirewallArgs:
     @pulumi.getter
     def enabled(self) -> pulumi.Input[builtins.bool]:
         """
-        Boolean flag whether the routing-agent is enabled or not.
+        Boolean flag whether the firewall should be enabled or not.
         """
         return pulumi.get(self, "enabled")
 
@@ -12009,7 +12022,7 @@ if not MYPY:
         """
         certificate_id: NotRequired[pulumi.Input[builtins.str]]
         """
-        The certificate id associated with the domain used for TLS handshaking.
+        **Deprecated** The certificate ID to be used for TLS handshaking.
         """
         certificate_name: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -12041,7 +12054,7 @@ class LoadBalancerDomainArgs:
                  verification_error_reasons: Optional[pulumi.Input[Sequence[pulumi.Input[builtins.str]]]] = None):
         """
         :param pulumi.Input[builtins.str] name: The domain name to be used for ingressing traffic to a Global Load Balancer.
-        :param pulumi.Input[builtins.str] certificate_id: The certificate id associated with the domain used for TLS handshaking.
+        :param pulumi.Input[builtins.str] certificate_id: **Deprecated** The certificate ID to be used for TLS handshaking.
         :param pulumi.Input[builtins.str] certificate_name: The certificate name to be used for TLS handshaking.
         :param pulumi.Input[builtins.bool] is_managed: Control flag to specify whether the domain is managed by DigitalOcean.
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] ssl_validation_error_reasons: list of domain SSL validation errors
@@ -12075,7 +12088,7 @@ class LoadBalancerDomainArgs:
     @pulumi.getter(name="certificateId")
     def certificate_id(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        The certificate id associated with the domain used for TLS handshaking.
+        **Deprecated** The certificate ID to be used for TLS handshaking.
         """
         return pulumi.get(self, "certificate_id")
 
@@ -12207,7 +12220,7 @@ if not MYPY:
         """
         certificate_id: NotRequired[pulumi.Input[builtins.str]]
         """
-        **Deprecated** The ID of the TLS certificate to be used for SSL termination.
+        **Deprecated** The ID of the TLS certificate to be used for SSL termination. Use `certificate_name` instead.
         """
         certificate_name: NotRequired[pulumi.Input[builtins.str]]
         """
@@ -12235,7 +12248,7 @@ class LoadBalancerForwardingRuleArgs:
         :param pulumi.Input[builtins.str] entry_protocol: The protocol used for traffic to the Load Balancer. The possible values are: `http`, `https`, `http2`, `http3`, `tcp`, or `udp`.
         :param pulumi.Input[builtins.int] target_port: An integer representing the port on the backend Droplets to which the Load Balancer will send traffic.
         :param pulumi.Input[builtins.str] target_protocol: The protocol used for traffic from the Load Balancer to the backend Droplets. The possible values are: `http`, `https`, `http2`, `tcp`, or `udp`.
-        :param pulumi.Input[builtins.str] certificate_id: **Deprecated** The ID of the TLS certificate to be used for SSL termination.
+        :param pulumi.Input[builtins.str] certificate_id: **Deprecated** The ID of the TLS certificate to be used for SSL termination. Use `certificate_name` instead.
         :param pulumi.Input[builtins.str] certificate_name: The unique name of the TLS certificate to be used for SSL termination.
         :param pulumi.Input[builtins.bool] tls_passthrough: A boolean value indicating whether SSL encrypted traffic will be passed through to the backend Droplets. The default value is `false`.
         """
@@ -12306,7 +12319,7 @@ class LoadBalancerForwardingRuleArgs:
     @_utilities.deprecated("""Certificate IDs may change, for example when a Let's Encrypt certificate is auto-renewed. Please specify 'certificate_name' instead.""")
     def certificate_id(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        **Deprecated** The ID of the TLS certificate to be used for SSL termination.
+        **Deprecated** The ID of the TLS certificate to be used for SSL termination. Use `certificate_name` instead.
         """
         return pulumi.get(self, "certificate_id")
 
@@ -13510,6 +13523,141 @@ class UptimeAlertNotificationSlackArgs:
         pulumi.set(self, "url", value)
 
 
+if not MYPY:
+    class VpcNatGatewayEgressArgsDict(TypedDict):
+        public_gateways: NotRequired[pulumi.Input[Sequence[pulumi.Input['VpcNatGatewayEgressPublicGatewayArgsDict']]]]
+        """
+        List of public gateway IPs
+        """
+elif False:
+    VpcNatGatewayEgressArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class VpcNatGatewayEgressArgs:
+    def __init__(__self__, *,
+                 public_gateways: Optional[pulumi.Input[Sequence[pulumi.Input['VpcNatGatewayEgressPublicGatewayArgs']]]] = None):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input['VpcNatGatewayEgressPublicGatewayArgs']]] public_gateways: List of public gateway IPs
+        """
+        if public_gateways is not None:
+            pulumi.set(__self__, "public_gateways", public_gateways)
+
+    @property
+    @pulumi.getter(name="publicGateways")
+    def public_gateways(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['VpcNatGatewayEgressPublicGatewayArgs']]]]:
+        """
+        List of public gateway IPs
+        """
+        return pulumi.get(self, "public_gateways")
+
+    @public_gateways.setter
+    def public_gateways(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['VpcNatGatewayEgressPublicGatewayArgs']]]]):
+        pulumi.set(self, "public_gateways", value)
+
+
+if not MYPY:
+    class VpcNatGatewayEgressPublicGatewayArgsDict(TypedDict):
+        ipv4: NotRequired[pulumi.Input[builtins.str]]
+        """
+        IPv4 address
+        """
+elif False:
+    VpcNatGatewayEgressPublicGatewayArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class VpcNatGatewayEgressPublicGatewayArgs:
+    def __init__(__self__, *,
+                 ipv4: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.str] ipv4: IPv4 address
+        """
+        if ipv4 is not None:
+            pulumi.set(__self__, "ipv4", ipv4)
+
+    @property
+    @pulumi.getter
+    def ipv4(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        IPv4 address
+        """
+        return pulumi.get(self, "ipv4")
+
+    @ipv4.setter
+    def ipv4(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "ipv4", value)
+
+
+if not MYPY:
+    class VpcNatGatewayVpcArgsDict(TypedDict):
+        vpc_uuid: pulumi.Input[builtins.str]
+        """
+        The ID of the ingress VPC
+        """
+        default_gateway: NotRequired[pulumi.Input[builtins.bool]]
+        """
+        Boolean flag indicating if this should be the default gateway in this VPC
+        """
+        gateway_ip: NotRequired[pulumi.Input[builtins.str]]
+        """
+        The private IP of the VPC NAT Gateway
+        """
+elif False:
+    VpcNatGatewayVpcArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class VpcNatGatewayVpcArgs:
+    def __init__(__self__, *,
+                 vpc_uuid: pulumi.Input[builtins.str],
+                 default_gateway: Optional[pulumi.Input[builtins.bool]] = None,
+                 gateway_ip: Optional[pulumi.Input[builtins.str]] = None):
+        """
+        :param pulumi.Input[builtins.str] vpc_uuid: The ID of the ingress VPC
+        :param pulumi.Input[builtins.bool] default_gateway: Boolean flag indicating if this should be the default gateway in this VPC
+        :param pulumi.Input[builtins.str] gateway_ip: The private IP of the VPC NAT Gateway
+        """
+        pulumi.set(__self__, "vpc_uuid", vpc_uuid)
+        if default_gateway is not None:
+            pulumi.set(__self__, "default_gateway", default_gateway)
+        if gateway_ip is not None:
+            pulumi.set(__self__, "gateway_ip", gateway_ip)
+
+    @property
+    @pulumi.getter(name="vpcUuid")
+    def vpc_uuid(self) -> pulumi.Input[builtins.str]:
+        """
+        The ID of the ingress VPC
+        """
+        return pulumi.get(self, "vpc_uuid")
+
+    @vpc_uuid.setter
+    def vpc_uuid(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "vpc_uuid", value)
+
+    @property
+    @pulumi.getter(name="defaultGateway")
+    def default_gateway(self) -> Optional[pulumi.Input[builtins.bool]]:
+        """
+        Boolean flag indicating if this should be the default gateway in this VPC
+        """
+        return pulumi.get(self, "default_gateway")
+
+    @default_gateway.setter
+    def default_gateway(self, value: Optional[pulumi.Input[builtins.bool]]):
+        pulumi.set(self, "default_gateway", value)
+
+    @property
+    @pulumi.getter(name="gatewayIp")
+    def gateway_ip(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        The private IP of the VPC NAT Gateway
+        """
+        return pulumi.get(self, "gateway_ip")
+
+    @gateway_ip.setter
+    def gateway_ip(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "gateway_ip", value)
+
+
 if not MYPY:
     class GetAppDedicatedIpArgsDict(TypedDict):
         id: builtins.str

{pulumi_digitalocean-4.46.0a1748901174 → pulumi_digitalocean-4.46.0a1749009476}/pulumi_digitalocean/get_partner_attachment.py

@@ -29,7 +29,7 @@ class GetPartnerAttachmentResult:
     """
     A collection of values returned by getPartnerAttachment.
     """
-    def __init__(__self__, bgp=None, connection_bandwidth_in_mbps=None, created_at=None, id=None, naas_provider=None, name=None, region=None, state=None, vpc_ids=None):
+    def __init__(__self__, bgp=None, connection_bandwidth_in_mbps=None, created_at=None, id=None, naas_provider=None, name=None, redundancy_zone=None, region=None, state=None, vpc_ids=None):
         if bgp and not isinstance(bgp, dict):
             raise TypeError("Expected argument 'bgp' to be a dict")
         pulumi.set(__self__, "bgp", bgp)
@@ -48,6 +48,9 @@ class GetPartnerAttachmentResult:
         if name and not isinstance(name, str):
             raise TypeError("Expected argument 'name' to be a str")
         pulumi.set(__self__, "name", name)
+        if redundancy_zone and not isinstance(redundancy_zone, str):
+            raise TypeError("Expected argument 'redundancy_zone' to be a str")
+        pulumi.set(__self__, "redundancy_zone", redundancy_zone)
         if region and not isinstance(region, str):
             raise TypeError("Expected argument 'region' to be a str")
         pulumi.set(__self__, "region", region)
@@ -88,6 +91,11 @@ class GetPartnerAttachmentResult:
     def name(self) -> builtins.str:
         return pulumi.get(self, "name")
 
+    @property
+    @pulumi.getter(name="redundancyZone")
+    def redundancy_zone(self) -> Optional[builtins.str]:
+        return pulumi.get(self, "redundancy_zone")
+
     @property
     @pulumi.getter
     def region(self) -> builtins.str:
@@ -116,6 +124,7 @@ class AwaitableGetPartnerAttachmentResult(GetPartnerAttachmentResult):
             id=self.id,
             naas_provider=self.naas_provider,
             name=self.name,
+            redundancy_zone=self.redundancy_zone,
             region=self.region,
             state=self.state,
             vpc_ids=self.vpc_ids)
@@ -124,6 +133,7 @@ class AwaitableGetPartnerAttachmentResult(GetPartnerAttachmentResult):
 def get_partner_attachment(bgp: Optional[Union['GetPartnerAttachmentBgpArgs', 'GetPartnerAttachmentBgpArgsDict']] = None,
                            id: Optional[builtins.str] = None,
                            name: Optional[builtins.str] = None,
+                           redundancy_zone: Optional[builtins.str] = None,
                            opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetPartnerAttachmentResult:
     """
     Use this data source to access information about an existing resource.
@@ -132,6 +142,7 @@ def get_partner_attachment(bgp: Optional[Union['GetPartnerAttachmentBgpArgs', 'G
     __args__['bgp'] = bgp
     __args__['id'] = id
     __args__['name'] = name
+    __args__['redundancyZone'] = redundancy_zone
     opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke('digitalocean:index/getPartnerAttachment:getPartnerAttachment', __args__, opts=opts, typ=GetPartnerAttachmentResult).value
 
@@ -142,12 +153,14 @@ def get_partner_attachment(bgp: Optional[Union['GetPartnerAttachmentBgpArgs', 'G
         id=pulumi.get(__ret__, 'id'),
         naas_provider=pulumi.get(__ret__, 'naas_provider'),
         name=pulumi.get(__ret__, 'name'),
+        redundancy_zone=pulumi.get(__ret__, 'redundancy_zone'),
         region=pulumi.get(__ret__, 'region'),
         state=pulumi.get(__ret__, 'state'),
         vpc_ids=pulumi.get(__ret__, 'vpc_ids'))
 def get_partner_attachment_output(bgp: Optional[pulumi.Input[Optional[Union['GetPartnerAttachmentBgpArgs', 'GetPartnerAttachmentBgpArgsDict']]]] = None,
                                   id: Optional[pulumi.Input[Optional[builtins.str]]] = None,
                                   name: Optional[pulumi.Input[Optional[builtins.str]]] = None,
+                                  redundancy_zone: Optional[pulumi.Input[Optional[builtins.str]]] = None,
                                   opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetPartnerAttachmentResult]:
     """
     Use this data source to access information about an existing resource.
@@ -156,6 +169,7 @@ def get_partner_attachment_output(bgp: Optional[pulumi.Input[Optional[Union['Get
     __args__['bgp'] = bgp
     __args__['id'] = id
     __args__['name'] = name
+    __args__['redundancyZone'] = redundancy_zone
     opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
     __ret__ = pulumi.runtime.invoke_output('digitalocean:index/getPartnerAttachment:getPartnerAttachment', __args__, opts=opts, typ=GetPartnerAttachmentResult)
     return __ret__.apply(lambda __response__: GetPartnerAttachmentResult(
@@ -165,6 +179,7 @@ def get_partner_attachment_output(bgp: Optional[pulumi.Input[Optional[Union['Get
         id=pulumi.get(__response__, 'id'),
         naas_provider=pulumi.get(__response__, 'naas_provider'),
         name=pulumi.get(__response__, 'name'),
+        redundancy_zone=pulumi.get(__response__, 'redundancy_zone'),
         region=pulumi.get(__response__, 'region'),
         state=pulumi.get(__response__, 'state'),
         vpc_ids=pulumi.get(__response__, 'vpc_ids')))

pulumi_digitalocean-4.46.0a1749009476/pulumi_digitalocean/get_vpc_nat_gateway.py

@@ -0,0 +1,253 @@
+# 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
+import copy
+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
+
+__all__ = [
+    'GetVpcNatGatewayResult',
+    'AwaitableGetVpcNatGatewayResult',
+    'get_vpc_nat_gateway',
+    'get_vpc_nat_gateway_output',
+]
+
+@pulumi.output_type
+class GetVpcNatGatewayResult:
+    """
+    A collection of values returned by getVpcNatGateway.
+    """
+    def __init__(__self__, created_at=None, egresses=None, icmp_timeout_seconds=None, id=None, name=None, region=None, size=None, state=None, tcp_timeout_seconds=None, type=None, udp_timeout_seconds=None, updated_at=None, vpcs=None):
+        if created_at and not isinstance(created_at, str):
+            raise TypeError("Expected argument 'created_at' to be a str")
+        pulumi.set(__self__, "created_at", created_at)
+        if egresses and not isinstance(egresses, list):
+            raise TypeError("Expected argument 'egresses' to be a list")
+        pulumi.set(__self__, "egresses", egresses)
+        if icmp_timeout_seconds and not isinstance(icmp_timeout_seconds, int):
+            raise TypeError("Expected argument 'icmp_timeout_seconds' to be a int")
+        pulumi.set(__self__, "icmp_timeout_seconds", icmp_timeout_seconds)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if name and not isinstance(name, str):
+            raise TypeError("Expected argument 'name' to be a str")
+        pulumi.set(__self__, "name", name)
+        if region and not isinstance(region, str):
+            raise TypeError("Expected argument 'region' to be a str")
+        pulumi.set(__self__, "region", region)
+        if size and not isinstance(size, int):
+            raise TypeError("Expected argument 'size' to be a int")
+        pulumi.set(__self__, "size", size)
+        if state and not isinstance(state, str):
+            raise TypeError("Expected argument 'state' to be a str")
+        pulumi.set(__self__, "state", state)
+        if tcp_timeout_seconds and not isinstance(tcp_timeout_seconds, int):
+            raise TypeError("Expected argument 'tcp_timeout_seconds' to be a int")
+        pulumi.set(__self__, "tcp_timeout_seconds", tcp_timeout_seconds)
+        if type and not isinstance(type, str):
+            raise TypeError("Expected argument 'type' to be a str")
+        pulumi.set(__self__, "type", type)
+        if udp_timeout_seconds and not isinstance(udp_timeout_seconds, int):
+            raise TypeError("Expected argument 'udp_timeout_seconds' to be a int")
+        pulumi.set(__self__, "udp_timeout_seconds", udp_timeout_seconds)
+        if updated_at and not isinstance(updated_at, str):
+            raise TypeError("Expected argument 'updated_at' to be a str")
+        pulumi.set(__self__, "updated_at", updated_at)
+        if vpcs and not isinstance(vpcs, list):
+            raise TypeError("Expected argument 'vpcs' to be a list")
+        pulumi.set(__self__, "vpcs", vpcs)
+
+    @property
+    @pulumi.getter(name="createdAt")
+    def created_at(self) -> builtins.str:
+        return pulumi.get(self, "created_at")
+
+    @property
+    @pulumi.getter
+    def egresses(self) -> Sequence['outputs.GetVpcNatGatewayEgressResult']:
+        return pulumi.get(self, "egresses")
+
+    @property
+    @pulumi.getter(name="icmpTimeoutSeconds")
+    def icmp_timeout_seconds(self) -> builtins.int:
+        return pulumi.get(self, "icmp_timeout_seconds")
+
+    @property
+    @pulumi.getter
+    def id(self) -> Optional[builtins.str]:
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def name(self) -> Optional[builtins.str]:
+        return pulumi.get(self, "name")
+
+    @property
+    @pulumi.getter
+    def region(self) -> builtins.str:
+        return pulumi.get(self, "region")
+
+    @property
+    @pulumi.getter
+    def size(self) -> builtins.int:
+        return pulumi.get(self, "size")
+
+    @property
+    @pulumi.getter
+    def state(self) -> builtins.str:
+        return pulumi.get(self, "state")
+
+    @property
+    @pulumi.getter(name="tcpTimeoutSeconds")
+    def tcp_timeout_seconds(self) -> builtins.int:
+        return pulumi.get(self, "tcp_timeout_seconds")
+
+    @property
+    @pulumi.getter
+    def type(self) -> builtins.str:
+        return pulumi.get(self, "type")
+
+    @property
+    @pulumi.getter(name="udpTimeoutSeconds")
+    def udp_timeout_seconds(self) -> builtins.int:
+        return pulumi.get(self, "udp_timeout_seconds")
+
+    @property
+    @pulumi.getter(name="updatedAt")
+    def updated_at(self) -> builtins.str:
+        return pulumi.get(self, "updated_at")
+
+    @property
+    @pulumi.getter
+    def vpcs(self) -> Sequence['outputs.GetVpcNatGatewayVpcResult']:
+        return pulumi.get(self, "vpcs")
+
+
+class AwaitableGetVpcNatGatewayResult(GetVpcNatGatewayResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetVpcNatGatewayResult(
+            created_at=self.created_at,
+            egresses=self.egresses,
+            icmp_timeout_seconds=self.icmp_timeout_seconds,
+            id=self.id,
+            name=self.name,
+            region=self.region,
+            size=self.size,
+            state=self.state,
+            tcp_timeout_seconds=self.tcp_timeout_seconds,
+            type=self.type,
+            udp_timeout_seconds=self.udp_timeout_seconds,
+            updated_at=self.updated_at,
+            vpcs=self.vpcs)
+
+
+def get_vpc_nat_gateway(id: Optional[builtins.str] = None,
+                        name: Optional[builtins.str] = None,
+                        opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetVpcNatGatewayResult:
+    """
+    ## Example Usage
+
+    Get the VPC NAT Gateway by name:
+
+    ```python
+    import pulumi
+    import pulumi_digitalocean as digitalocean
+
+    my_imported_vpc_nat_gateway = digitalocean.get_vpc_nat_gateway(name=my_existing_vpc_nat_gateway["name"])
+    ```
+
+    Get the VPC NAT Gateway by ID:
+
+    ```python
+    import pulumi
+    import pulumi_digitalocean as digitalocean
+
+    my_imported_vpc_nat_gateway = digitalocean.get_vpc_nat_gateway(id=my_existing_vpc_nat_gateway["id"])
+    ```
+
+
+    :param builtins.str id: The ID of VPC NAT Gateway.
+    :param builtins.str name: The name of VPC NAT Gateway.
+    """
+    __args__ = dict()
+    __args__['id'] = id
+    __args__['name'] = name
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('digitalocean:index/getVpcNatGateway:getVpcNatGateway', __args__, opts=opts, typ=GetVpcNatGatewayResult).value
+
+    return AwaitableGetVpcNatGatewayResult(
+        created_at=pulumi.get(__ret__, 'created_at'),
+        egresses=pulumi.get(__ret__, 'egresses'),
+        icmp_timeout_seconds=pulumi.get(__ret__, 'icmp_timeout_seconds'),
+        id=pulumi.get(__ret__, 'id'),
+        name=pulumi.get(__ret__, 'name'),
+        region=pulumi.get(__ret__, 'region'),
+        size=pulumi.get(__ret__, 'size'),
+        state=pulumi.get(__ret__, 'state'),
+        tcp_timeout_seconds=pulumi.get(__ret__, 'tcp_timeout_seconds'),
+        type=pulumi.get(__ret__, 'type'),
+        udp_timeout_seconds=pulumi.get(__ret__, 'udp_timeout_seconds'),
+        updated_at=pulumi.get(__ret__, 'updated_at'),
+        vpcs=pulumi.get(__ret__, 'vpcs'))
+def get_vpc_nat_gateway_output(id: Optional[pulumi.Input[Optional[builtins.str]]] = None,
+                               name: Optional[pulumi.Input[Optional[builtins.str]]] = None,
+                               opts: Optional[Union[pulumi.InvokeOptions, pulumi.InvokeOutputOptions]] = None) -> pulumi.Output[GetVpcNatGatewayResult]:
+    """
+    ## Example Usage
+
+    Get the VPC NAT Gateway by name:
+
+    ```python
+    import pulumi
+    import pulumi_digitalocean as digitalocean
+
+    my_imported_vpc_nat_gateway = digitalocean.get_vpc_nat_gateway(name=my_existing_vpc_nat_gateway["name"])
+    ```
+
+    Get the VPC NAT Gateway by ID:
+
+    ```python
+    import pulumi
+    import pulumi_digitalocean as digitalocean
+
+    my_imported_vpc_nat_gateway = digitalocean.get_vpc_nat_gateway(id=my_existing_vpc_nat_gateway["id"])
+    ```
+
+
+    :param builtins.str id: The ID of VPC NAT Gateway.
+    :param builtins.str name: The name of VPC NAT Gateway.
+    """
+    __args__ = dict()
+    __args__['id'] = id
+    __args__['name'] = name
+    opts = pulumi.InvokeOutputOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke_output('digitalocean:index/getVpcNatGateway:getVpcNatGateway', __args__, opts=opts, typ=GetVpcNatGatewayResult)
+    return __ret__.apply(lambda __response__: GetVpcNatGatewayResult(
+        created_at=pulumi.get(__response__, 'created_at'),
+        egresses=pulumi.get(__response__, 'egresses'),
+        icmp_timeout_seconds=pulumi.get(__response__, 'icmp_timeout_seconds'),
+        id=pulumi.get(__response__, 'id'),
+        name=pulumi.get(__response__, 'name'),
+        region=pulumi.get(__response__, 'region'),
+        size=pulumi.get(__response__, 'size'),
+        state=pulumi.get(__response__, 'state'),
+        tcp_timeout_seconds=pulumi.get(__response__, 'tcp_timeout_seconds'),
+        type=pulumi.get(__response__, 'type'),
+        udp_timeout_seconds=pulumi.get(__response__, 'udp_timeout_seconds'),
+        updated_at=pulumi.get(__response__, 'updated_at'),
+        vpcs=pulumi.get(__response__, 'vpcs')))