pulumi-gcp 6.68.0a1698127103__py3-none-any.whl → 6.68.0a1698199636__py3-none-any.whl

pulumi_gcp/compute/target_ssl_proxy.py

@@ -66,7 +66,7 @@ class TargetSSLProxyArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             backend_service: pulumi.Input[str],
+             backend_service: Optional[pulumi.Input[str]] = None,
              certificate_map: Optional[pulumi.Input[str]] = None,
              description: Optional[pulumi.Input[str]] = None,
              name: Optional[pulumi.Input[str]] = None,
@@ -74,7 +74,21 @@ class TargetSSLProxyArgs:
              proxy_header: Optional[pulumi.Input[str]] = None,
              ssl_certificates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
              ssl_policy: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if backend_service is None and 'backendService' in kwargs:
+            backend_service = kwargs['backendService']
+        if backend_service is None:
+            raise TypeError("Missing 'backend_service' argument")
+        if certificate_map is None and 'certificateMap' in kwargs:
+            certificate_map = kwargs['certificateMap']
+        if proxy_header is None and 'proxyHeader' in kwargs:
+            proxy_header = kwargs['proxyHeader']
+        if ssl_certificates is None and 'sslCertificates' in kwargs:
+            ssl_certificates = kwargs['sslCertificates']
+        if ssl_policy is None and 'sslPolicy' in kwargs:
+            ssl_policy = kwargs['sslPolicy']
+
         _setter("backend_service", backend_service)
         if certificate_map is not None:
             _setter("certificate_map", certificate_map)
@@ -282,7 +296,25 @@ class _TargetSSLProxyState:
              self_link: Optional[pulumi.Input[str]] = None,
              ssl_certificates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
              ssl_policy: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if backend_service is None and 'backendService' in kwargs:
+            backend_service = kwargs['backendService']
+        if certificate_map is None and 'certificateMap' in kwargs:
+            certificate_map = kwargs['certificateMap']
+        if creation_timestamp is None and 'creationTimestamp' in kwargs:
+            creation_timestamp = kwargs['creationTimestamp']
+        if proxy_header is None and 'proxyHeader' in kwargs:
+            proxy_header = kwargs['proxyHeader']
+        if proxy_id is None and 'proxyId' in kwargs:
+            proxy_id = kwargs['proxyId']
+        if self_link is None and 'selfLink' in kwargs:
+            self_link = kwargs['selfLink']
+        if ssl_certificates is None and 'sslCertificates' in kwargs:
+            ssl_certificates = kwargs['sslCertificates']
+        if ssl_policy is None and 'sslPolicy' in kwargs:
+            ssl_policy = kwargs['sslPolicy']
+
         if backend_service is not None:
             _setter("backend_service", backend_service)
         if certificate_map is not None:

pulumi_gcp/compute/target_tcp_proxy.py

@@ -55,13 +55,23 @@ class TargetTCPProxyArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             backend_service: pulumi.Input[str],
+             backend_service: Optional[pulumi.Input[str]] = None,
              description: Optional[pulumi.Input[str]] = None,
              name: Optional[pulumi.Input[str]] = None,
              project: Optional[pulumi.Input[str]] = None,
              proxy_bind: Optional[pulumi.Input[bool]] = None,
              proxy_header: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if backend_service is None and 'backendService' in kwargs:
+            backend_service = kwargs['backendService']
+        if backend_service is None:
+            raise TypeError("Missing 'backend_service' argument")
+        if proxy_bind is None and 'proxyBind' in kwargs:
+            proxy_bind = kwargs['proxyBind']
+        if proxy_header is None and 'proxyHeader' in kwargs:
+            proxy_header = kwargs['proxyHeader']
+
         _setter("backend_service", backend_service)
         if description is not None:
             _setter("description", description)
@@ -223,7 +233,21 @@ class _TargetTCPProxyState:
              proxy_header: Optional[pulumi.Input[str]] = None,
              proxy_id: Optional[pulumi.Input[int]] = None,
              self_link: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if backend_service is None and 'backendService' in kwargs:
+            backend_service = kwargs['backendService']
+        if creation_timestamp is None and 'creationTimestamp' in kwargs:
+            creation_timestamp = kwargs['creationTimestamp']
+        if proxy_bind is None and 'proxyBind' in kwargs:
+            proxy_bind = kwargs['proxyBind']
+        if proxy_header is None and 'proxyHeader' in kwargs:
+            proxy_header = kwargs['proxyHeader']
+        if proxy_id is None and 'proxyId' in kwargs:
+            proxy_id = kwargs['proxyId']
+        if self_link is None and 'selfLink' in kwargs:
+            self_link = kwargs['selfLink']
+
         if backend_service is not None:
             _setter("backend_service", backend_service)
         if creation_timestamp is not None:

pulumi_gcp/compute/url_map.py

@@ -91,7 +91,21 @@ class URLMapArgs:
              path_matchers: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapPathMatcherArgs']]]] = None,
              project: Optional[pulumi.Input[str]] = None,
              tests: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapTestArgs']]]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if default_route_action is None and 'defaultRouteAction' in kwargs:
+            default_route_action = kwargs['defaultRouteAction']
+        if default_service is None and 'defaultService' in kwargs:
+            default_service = kwargs['defaultService']
+        if default_url_redirect is None and 'defaultUrlRedirect' in kwargs:
+            default_url_redirect = kwargs['defaultUrlRedirect']
+        if header_action is None and 'headerAction' in kwargs:
+            header_action = kwargs['headerAction']
+        if host_rules is None and 'hostRules' in kwargs:
+            host_rules = kwargs['hostRules']
+        if path_matchers is None and 'pathMatchers' in kwargs:
+            path_matchers = kwargs['pathMatchers']
+
         if default_route_action is not None:
             _setter("default_route_action", default_route_action)
         if default_service is not None:
@@ -355,7 +369,27 @@ class _URLMapState:
              project: Optional[pulumi.Input[str]] = None,
              self_link: Optional[pulumi.Input[str]] = None,
              tests: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapTestArgs']]]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if creation_timestamp is None and 'creationTimestamp' in kwargs:
+            creation_timestamp = kwargs['creationTimestamp']
+        if default_route_action is None and 'defaultRouteAction' in kwargs:
+            default_route_action = kwargs['defaultRouteAction']
+        if default_service is None and 'defaultService' in kwargs:
+            default_service = kwargs['defaultService']
+        if default_url_redirect is None and 'defaultUrlRedirect' in kwargs:
+            default_url_redirect = kwargs['defaultUrlRedirect']
+        if header_action is None and 'headerAction' in kwargs:
+            header_action = kwargs['headerAction']
+        if host_rules is None and 'hostRules' in kwargs:
+            host_rules = kwargs['hostRules']
+        if map_id is None and 'mapId' in kwargs:
+            map_id = kwargs['mapId']
+        if path_matchers is None and 'pathMatchers' in kwargs:
+            path_matchers = kwargs['pathMatchers']
+        if self_link is None and 'selfLink' in kwargs:
+            self_link = kwargs['selfLink']
+
         if creation_timestamp is not None:
             _setter("creation_timestamp", creation_timestamp)
         if default_route_action is not None:
@@ -732,25 +766,13 @@ class URLMap(pulumi.CustomResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = URLMapArgs.__new__(URLMapArgs)
 
-            if default_route_action is not None and not isinstance(default_route_action, URLMapDefaultRouteActionArgs):
-                default_route_action = default_route_action or {}
-                def _setter(key, value):
-                    default_route_action[key] = value
-                URLMapDefaultRouteActionArgs._configure(_setter, **default_route_action)
+            default_route_action = _utilities.configure(default_route_action, URLMapDefaultRouteActionArgs, True)
             __props__.__dict__["default_route_action"] = default_route_action
             __props__.__dict__["default_service"] = default_service
-            if default_url_redirect is not None and not isinstance(default_url_redirect, URLMapDefaultUrlRedirectArgs):
-                default_url_redirect = default_url_redirect or {}
-                def _setter(key, value):
-                    default_url_redirect[key] = value
-                URLMapDefaultUrlRedirectArgs._configure(_setter, **default_url_redirect)
+            default_url_redirect = _utilities.configure(default_url_redirect, URLMapDefaultUrlRedirectArgs, True)
             __props__.__dict__["default_url_redirect"] = default_url_redirect
             __props__.__dict__["description"] = description
-            if header_action is not None and not isinstance(header_action, URLMapHeaderActionArgs):
-                header_action = header_action or {}
-                def _setter(key, value):
-                    header_action[key] = value
-                URLMapHeaderActionArgs._configure(_setter, **header_action)
+            header_action = _utilities.configure(header_action, URLMapHeaderActionArgs, True)
             __props__.__dict__["header_action"] = header_action
             __props__.__dict__["host_rules"] = host_rules
             __props__.__dict__["name"] = name

pulumi_gcp/compute/vpn_gateway.py

@@ -48,12 +48,16 @@ class VPNGatewayArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             network: pulumi.Input[str],
+             network: Optional[pulumi.Input[str]] = None,
              description: Optional[pulumi.Input[str]] = None,
              name: Optional[pulumi.Input[str]] = None,
              project: Optional[pulumi.Input[str]] = None,
              region: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if network is None:
+            raise TypeError("Missing 'network' argument")
+
         _setter("network", network)
         if description is not None:
             _setter("description", description)
@@ -189,7 +193,15 @@ class _VPNGatewayState:
              project: Optional[pulumi.Input[str]] = None,
              region: Optional[pulumi.Input[str]] = None,
              self_link: Optional[pulumi.Input[str]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if creation_timestamp is None and 'creationTimestamp' in kwargs:
+            creation_timestamp = kwargs['creationTimestamp']
+        if gateway_id is None and 'gatewayId' in kwargs:
+            gateway_id = kwargs['gatewayId']
+        if self_link is None and 'selfLink' in kwargs:
+            self_link = kwargs['selfLink']
+
         if creation_timestamp is not None:
             _setter("creation_timestamp", creation_timestamp)
         if description is not None:
@@ -337,44 +349,6 @@ class VPNGateway(pulumi.CustomResource):
         see the [Classic VPN partial deprecation page](https://cloud.google.com/network-connectivity/docs/vpn/deprecations/classic-vpn-deprecation).
 
         ## Example Usage
-        ### Target Vpn Gateway Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        network1 = gcp.compute.Network("network1")
-        target_gateway = gcp.compute.VPNGateway("targetGateway", network=network1.id)
-        vpn_static_ip = gcp.compute.Address("vpnStaticIp")
-        fr_esp = gcp.compute.ForwardingRule("frEsp",
-            ip_protocol="ESP",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id)
-        fr_udp500 = gcp.compute.ForwardingRule("frUdp500",
-            ip_protocol="UDP",
-            port_range="500",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id)
-        fr_udp4500 = gcp.compute.ForwardingRule("frUdp4500",
-            ip_protocol="UDP",
-            port_range="4500",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id)
-        tunnel1 = gcp.compute.VPNTunnel("tunnel1",
-            peer_ip="15.0.0.120",
-            shared_secret="a secret message",
-            target_vpn_gateway=target_gateway.id,
-            opts=pulumi.ResourceOptions(depends_on=[
-                    fr_esp,
-                    fr_udp500,
-                    fr_udp4500,
-                ]))
-        route1 = gcp.compute.Route("route1",
-            network=network1.name,
-            dest_range="15.0.0.0/24",
-            priority=1000,
-            next_hop_vpn_tunnel=tunnel1.id)
-        ```
 
         ## Import
 
@@ -432,44 +406,6 @@ class VPNGateway(pulumi.CustomResource):
         see the [Classic VPN partial deprecation page](https://cloud.google.com/network-connectivity/docs/vpn/deprecations/classic-vpn-deprecation).
 
         ## Example Usage
-        ### Target Vpn Gateway Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        network1 = gcp.compute.Network("network1")
-        target_gateway = gcp.compute.VPNGateway("targetGateway", network=network1.id)
-        vpn_static_ip = gcp.compute.Address("vpnStaticIp")
-        fr_esp = gcp.compute.ForwardingRule("frEsp",
-            ip_protocol="ESP",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id)
-        fr_udp500 = gcp.compute.ForwardingRule("frUdp500",
-            ip_protocol="UDP",
-            port_range="500",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id)
-        fr_udp4500 = gcp.compute.ForwardingRule("frUdp4500",
-            ip_protocol="UDP",
-            port_range="4500",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id)
-        tunnel1 = gcp.compute.VPNTunnel("tunnel1",
-            peer_ip="15.0.0.120",
-            shared_secret="a secret message",
-            target_vpn_gateway=target_gateway.id,
-            opts=pulumi.ResourceOptions(depends_on=[
-                    fr_esp,
-                    fr_udp500,
-                    fr_udp4500,
-                ]))
-        route1 = gcp.compute.Route("route1",
-            network=network1.name,
-            dest_range="15.0.0.0/24",
-            priority=1000,
-            next_hop_vpn_tunnel=tunnel1.id)
-        ```
 
         ## Import
 

pulumi_gcp/compute/vpn_tunnel.py

@@ -100,7 +100,7 @@ class VPNTunnelArgs:
     @staticmethod
     def _configure(
              _setter: Callable[[Any, Any], None],
-             shared_secret: pulumi.Input[str],
+             shared_secret: Optional[pulumi.Input[str]] = None,
              description: Optional[pulumi.Input[str]] = None,
              ike_version: Optional[pulumi.Input[int]] = None,
              labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -117,7 +117,33 @@ class VPNTunnelArgs:
              target_vpn_gateway: Optional[pulumi.Input[str]] = None,
              vpn_gateway: Optional[pulumi.Input[str]] = None,
              vpn_gateway_interface: Optional[pulumi.Input[int]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if shared_secret is None and 'sharedSecret' in kwargs:
+            shared_secret = kwargs['sharedSecret']
+        if shared_secret is None:
+            raise TypeError("Missing 'shared_secret' argument")
+        if ike_version is None and 'ikeVersion' in kwargs:
+            ike_version = kwargs['ikeVersion']
+        if local_traffic_selectors is None and 'localTrafficSelectors' in kwargs:
+            local_traffic_selectors = kwargs['localTrafficSelectors']
+        if peer_external_gateway is None and 'peerExternalGateway' in kwargs:
+            peer_external_gateway = kwargs['peerExternalGateway']
+        if peer_external_gateway_interface is None and 'peerExternalGatewayInterface' in kwargs:
+            peer_external_gateway_interface = kwargs['peerExternalGatewayInterface']
+        if peer_gcp_gateway is None and 'peerGcpGateway' in kwargs:
+            peer_gcp_gateway = kwargs['peerGcpGateway']
+        if peer_ip is None and 'peerIp' in kwargs:
+            peer_ip = kwargs['peerIp']
+        if remote_traffic_selectors is None and 'remoteTrafficSelectors' in kwargs:
+            remote_traffic_selectors = kwargs['remoteTrafficSelectors']
+        if target_vpn_gateway is None and 'targetVpnGateway' in kwargs:
+            target_vpn_gateway = kwargs['targetVpnGateway']
+        if vpn_gateway is None and 'vpnGateway' in kwargs:
+            vpn_gateway = kwargs['vpnGateway']
+        if vpn_gateway_interface is None and 'vpnGatewayInterface' in kwargs:
+            vpn_gateway_interface = kwargs['vpnGatewayInterface']
+
         _setter("shared_secret", shared_secret)
         if description is not None:
             _setter("description", description)
@@ -513,7 +539,43 @@ class _VPNTunnelState:
              tunnel_id: Optional[pulumi.Input[str]] = None,
              vpn_gateway: Optional[pulumi.Input[str]] = None,
              vpn_gateway_interface: Optional[pulumi.Input[int]] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if creation_timestamp is None and 'creationTimestamp' in kwargs:
+            creation_timestamp = kwargs['creationTimestamp']
+        if detailed_status is None and 'detailedStatus' in kwargs:
+            detailed_status = kwargs['detailedStatus']
+        if ike_version is None and 'ikeVersion' in kwargs:
+            ike_version = kwargs['ikeVersion']
+        if label_fingerprint is None and 'labelFingerprint' in kwargs:
+            label_fingerprint = kwargs['labelFingerprint']
+        if local_traffic_selectors is None and 'localTrafficSelectors' in kwargs:
+            local_traffic_selectors = kwargs['localTrafficSelectors']
+        if peer_external_gateway is None and 'peerExternalGateway' in kwargs:
+            peer_external_gateway = kwargs['peerExternalGateway']
+        if peer_external_gateway_interface is None and 'peerExternalGatewayInterface' in kwargs:
+            peer_external_gateway_interface = kwargs['peerExternalGatewayInterface']
+        if peer_gcp_gateway is None and 'peerGcpGateway' in kwargs:
+            peer_gcp_gateway = kwargs['peerGcpGateway']
+        if peer_ip is None and 'peerIp' in kwargs:
+            peer_ip = kwargs['peerIp']
+        if remote_traffic_selectors is None and 'remoteTrafficSelectors' in kwargs:
+            remote_traffic_selectors = kwargs['remoteTrafficSelectors']
+        if self_link is None and 'selfLink' in kwargs:
+            self_link = kwargs['selfLink']
+        if shared_secret is None and 'sharedSecret' in kwargs:
+            shared_secret = kwargs['sharedSecret']
+        if shared_secret_hash is None and 'sharedSecretHash' in kwargs:
+            shared_secret_hash = kwargs['sharedSecretHash']
+        if target_vpn_gateway is None and 'targetVpnGateway' in kwargs:
+            target_vpn_gateway = kwargs['targetVpnGateway']
+        if tunnel_id is None and 'tunnelId' in kwargs:
+            tunnel_id = kwargs['tunnelId']
+        if vpn_gateway is None and 'vpnGateway' in kwargs:
+            vpn_gateway = kwargs['vpnGateway']
+        if vpn_gateway_interface is None and 'vpnGatewayInterface' in kwargs:
+            vpn_gateway_interface = kwargs['vpnGatewayInterface']
+
         if creation_timestamp is not None:
             _setter("creation_timestamp", creation_timestamp)
         if description is not None:
@@ -901,91 +963,6 @@ class VPNTunnel(pulumi.CustomResource):
         state as plain-text.
 
         ## Example Usage
-        ### Vpn Tunnel Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        network1 = gcp.compute.Network("network1")
-        target_gateway = gcp.compute.VPNGateway("targetGateway", network=network1.id)
-        vpn_static_ip = gcp.compute.Address("vpnStaticIp")
-        fr_esp = gcp.compute.ForwardingRule("frEsp",
-            ip_protocol="ESP",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id)
-        fr_udp500 = gcp.compute.ForwardingRule("frUdp500",
-            ip_protocol="UDP",
-            port_range="500",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id)
-        fr_udp4500 = gcp.compute.ForwardingRule("frUdp4500",
-            ip_protocol="UDP",
-            port_range="4500",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id)
-        tunnel1 = gcp.compute.VPNTunnel("tunnel1",
-            peer_ip="15.0.0.120",
-            shared_secret="a secret message",
-            target_vpn_gateway=target_gateway.id,
-            opts=pulumi.ResourceOptions(depends_on=[
-                    fr_esp,
-                    fr_udp500,
-                    fr_udp4500,
-                ]))
-        route1 = gcp.compute.Route("route1",
-            network=network1.name,
-            dest_range="15.0.0.0/24",
-            priority=1000,
-            next_hop_vpn_tunnel=tunnel1.id)
-        ```
-        ### Vpn Tunnel Beta
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        network1 = gcp.compute.Network("network1", opts=pulumi.ResourceOptions(provider=google_beta))
-        target_gateway = gcp.compute.VPNGateway("targetGateway", network=network1.id,
-        opts=pulumi.ResourceOptions(provider=google_beta))
-        vpn_static_ip = gcp.compute.Address("vpnStaticIp", opts=pulumi.ResourceOptions(provider=google_beta))
-        fr_esp = gcp.compute.ForwardingRule("frEsp",
-            ip_protocol="ESP",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id,
-            opts=pulumi.ResourceOptions(provider=google_beta))
-        fr_udp500 = gcp.compute.ForwardingRule("frUdp500",
-            ip_protocol="UDP",
-            port_range="500",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id,
-            opts=pulumi.ResourceOptions(provider=google_beta))
-        fr_udp4500 = gcp.compute.ForwardingRule("frUdp4500",
-            ip_protocol="UDP",
-            port_range="4500",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id,
-            opts=pulumi.ResourceOptions(provider=google_beta))
-        tunnel1 = gcp.compute.VPNTunnel("tunnel1",
-            peer_ip="15.0.0.120",
-            shared_secret="a secret message",
-            target_vpn_gateway=target_gateway.id,
-            labels={
-                "foo": "bar",
-            },
-            opts=pulumi.ResourceOptions(provider=google_beta,
-                depends_on=[
-                    fr_esp,
-                    fr_udp500,
-                    fr_udp4500,
-                ]))
-        route1 = gcp.compute.Route("route1",
-            network=network1.name,
-            dest_range="15.0.0.0/24",
-            priority=1000,
-            next_hop_vpn_tunnel=tunnel1.id,
-            opts=pulumi.ResourceOptions(provider=google_beta))
-        ```
 
         ## Import
 
@@ -1073,91 +1050,6 @@ class VPNTunnel(pulumi.CustomResource):
         state as plain-text.
 
         ## Example Usage
-        ### Vpn Tunnel Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        network1 = gcp.compute.Network("network1")
-        target_gateway = gcp.compute.VPNGateway("targetGateway", network=network1.id)
-        vpn_static_ip = gcp.compute.Address("vpnStaticIp")
-        fr_esp = gcp.compute.ForwardingRule("frEsp",
-            ip_protocol="ESP",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id)
-        fr_udp500 = gcp.compute.ForwardingRule("frUdp500",
-            ip_protocol="UDP",
-            port_range="500",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id)
-        fr_udp4500 = gcp.compute.ForwardingRule("frUdp4500",
-            ip_protocol="UDP",
-            port_range="4500",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id)
-        tunnel1 = gcp.compute.VPNTunnel("tunnel1",
-            peer_ip="15.0.0.120",
-            shared_secret="a secret message",
-            target_vpn_gateway=target_gateway.id,
-            opts=pulumi.ResourceOptions(depends_on=[
-                    fr_esp,
-                    fr_udp500,
-                    fr_udp4500,
-                ]))
-        route1 = gcp.compute.Route("route1",
-            network=network1.name,
-            dest_range="15.0.0.0/24",
-            priority=1000,
-            next_hop_vpn_tunnel=tunnel1.id)
-        ```
-        ### Vpn Tunnel Beta
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        network1 = gcp.compute.Network("network1", opts=pulumi.ResourceOptions(provider=google_beta))
-        target_gateway = gcp.compute.VPNGateway("targetGateway", network=network1.id,
-        opts=pulumi.ResourceOptions(provider=google_beta))
-        vpn_static_ip = gcp.compute.Address("vpnStaticIp", opts=pulumi.ResourceOptions(provider=google_beta))
-        fr_esp = gcp.compute.ForwardingRule("frEsp",
-            ip_protocol="ESP",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id,
-            opts=pulumi.ResourceOptions(provider=google_beta))
-        fr_udp500 = gcp.compute.ForwardingRule("frUdp500",
-            ip_protocol="UDP",
-            port_range="500",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id,
-            opts=pulumi.ResourceOptions(provider=google_beta))
-        fr_udp4500 = gcp.compute.ForwardingRule("frUdp4500",
-            ip_protocol="UDP",
-            port_range="4500",
-            ip_address=vpn_static_ip.address,
-            target=target_gateway.id,
-            opts=pulumi.ResourceOptions(provider=google_beta))
-        tunnel1 = gcp.compute.VPNTunnel("tunnel1",
-            peer_ip="15.0.0.120",
-            shared_secret="a secret message",
-            target_vpn_gateway=target_gateway.id,
-            labels={
-                "foo": "bar",
-            },
-            opts=pulumi.ResourceOptions(provider=google_beta,
-                depends_on=[
-                    fr_esp,
-                    fr_udp500,
-                    fr_udp4500,
-                ]))
-        route1 = gcp.compute.Route("route1",
-            network=network1.name,
-            dest_range="15.0.0.0/24",
-            priority=1000,
-            next_hop_vpn_tunnel=tunnel1.id,
-            opts=pulumi.ResourceOptions(provider=google_beta))
-        ```
 
         ## Import
 

pulumi_gcp/config/outputs.py

@@ -28,7 +28,13 @@ class Batching(dict):
              _setter: Callable[[Any, Any], None],
              enable_batching: Optional[bool] = None,
              send_after: Optional[str] = None,
-             opts: Optional[pulumi.ResourceOptions]=None):
+             opts: Optional[pulumi.ResourceOptions] = None,
+             **kwargs):
+        if enable_batching is None and 'enableBatching' in kwargs:
+            enable_batching = kwargs['enableBatching']
+        if send_after is None and 'sendAfter' in kwargs:
+            send_after = kwargs['sendAfter']
+
         if enable_batching is not None:
             _setter("enable_batching", enable_batching)
         if send_after is not None: