pulumi-gcp 7.30.0__py3-none-any.whl → 7.30.0a1719470057__py3-none-any.whl

pulumi_gcp/datafusion/instance.py

@@ -4,14 +4,9 @@
 
 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
 from ._inputs import *
@@ -960,18 +955,18 @@ class Instance(pulumi.CustomResource):
     def __init__(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
-                 accelerators: Optional[pulumi.Input[Sequence[pulumi.Input[Union['InstanceAcceleratorArgs', 'InstanceAcceleratorArgsDict']]]]] = None,
-                 crypto_key_config: Optional[pulumi.Input[Union['InstanceCryptoKeyConfigArgs', 'InstanceCryptoKeyConfigArgsDict']]] = None,
+                 accelerators: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['InstanceAcceleratorArgs']]]]] = None,
+                 crypto_key_config: Optional[pulumi.Input[pulumi.InputType['InstanceCryptoKeyConfigArgs']]] = None,
                  dataproc_service_account: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  display_name: Optional[pulumi.Input[str]] = None,
                  enable_rbac: Optional[pulumi.Input[bool]] = None,
                  enable_stackdriver_logging: Optional[pulumi.Input[bool]] = None,
                  enable_stackdriver_monitoring: Optional[pulumi.Input[bool]] = None,
-                 event_publish_config: Optional[pulumi.Input[Union['InstanceEventPublishConfigArgs', 'InstanceEventPublishConfigArgsDict']]] = None,
+                 event_publish_config: Optional[pulumi.Input[pulumi.InputType['InstanceEventPublishConfigArgs']]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  name: Optional[pulumi.Input[str]] = None,
-                 network_config: Optional[pulumi.Input[Union['InstanceNetworkConfigArgs', 'InstanceNetworkConfigArgsDict']]] = None,
+                 network_config: Optional[pulumi.Input[pulumi.InputType['InstanceNetworkConfigArgs']]] = None,
                  options: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  private_instance: Optional[pulumi.Input[bool]] = None,
                  project: Optional[pulumi.Input[str]] = None,
@@ -1029,46 +1024,14 @@ class Instance(pulumi.CustomResource):
             labels={
                 "example_key": "example_value",
             },
-            network_config={
-                "network": "default",
-                "ipAllocation": pulumi.Output.all(private_ip_alloc.address, private_ip_alloc.prefix_length).apply(lambda address, prefix_length: f"{address}/{prefix_length}"),
-            },
-            accelerators=[{
-                "acceleratorType": "CDC",
-                "state": "ENABLED",
-            }])
-        ```
-        ### Data Fusion Instance Psc
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        psc = gcp.compute.Network("psc",
-            name="datafusion-psc-network",
-            auto_create_subnetworks=False)
-        psc_subnetwork = gcp.compute.Subnetwork("psc",
-            name="datafusion-psc-subnet",
-            region="us-central1",
-            network=psc.id,
-            ip_cidr_range="10.0.0.0/16")
-        psc_network_attachment = gcp.compute.NetworkAttachment("psc",
-            name="datafusion-psc-attachment",
-            region="us-central1",
-            connection_preference="ACCEPT_AUTOMATIC",
-            subnetworks=[psc_subnetwork.self_link])
-        psc_instance = gcp.datafusion.Instance("psc_instance",
-            name="psc-instance",
-            region="us-central1",
-            type="BASIC",
-            private_instance=True,
-            network_config={
-                "connectionType": "PRIVATE_SERVICE_CONNECT_INTERFACES",
-                "privateServiceConnectConfig": {
-                    "networkAttachment": psc_network_attachment.id,
-                    "unreachableCidrBlock": "192.168.0.0/25",
-                },
-            })
+            network_config=gcp.datafusion.InstanceNetworkConfigArgs(
+                network="default",
+                ip_allocation=pulumi.Output.all(private_ip_alloc.address, private_ip_alloc.prefix_length).apply(lambda address, prefix_length: f"{address}/{prefix_length}"),
+            ),
+            accelerators=[gcp.datafusion.InstanceAcceleratorArgs(
+                accelerator_type="CDC",
+                state="ENABLED",
+            )])
         ```
         ### Data Fusion Instance Cmek
 
@@ -1091,9 +1054,9 @@ class Instance(pulumi.CustomResource):
             name="my-instance",
             region="us-central1",
             type="BASIC",
-            crypto_key_config={
-                "keyReference": crypto_key.id,
-            },
+            crypto_key_config=gcp.datafusion.InstanceCryptoKeyConfigArgs(
+                key_reference=crypto_key.id,
+            ),
             opts = pulumi.ResourceOptions(depends_on=[crypto_key_member]))
         ```
         ### Data Fusion Instance Enterprise
@@ -1119,10 +1082,10 @@ class Instance(pulumi.CustomResource):
             name="my-instance",
             region="us-central1",
             type="BASIC",
-            event_publish_config={
-                "enabled": True,
-                "topic": event_topic.id,
-            })
+            event_publish_config=gcp.datafusion.InstanceEventPublishConfigArgs(
+                enabled=True,
+                topic=event_topic.id,
+            ))
         ```
         ### Data Fusion Instance Zone
 
@@ -1169,11 +1132,11 @@ class Instance(pulumi.CustomResource):
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
-        :param pulumi.Input[Sequence[pulumi.Input[Union['InstanceAcceleratorArgs', 'InstanceAcceleratorArgsDict']]]] accelerators: List of accelerators enabled for this CDF instance.
+        :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['InstanceAcceleratorArgs']]]] accelerators: List of accelerators enabled for this CDF instance.
                If accelerators are enabled it is possible a permadiff will be created with the Options field.
                Users will need to either manually update their state file to include these diffed options, or include the field in a lifecycle ignore changes block.
                Structure is documented below.
-        :param pulumi.Input[Union['InstanceCryptoKeyConfigArgs', 'InstanceCryptoKeyConfigArgsDict']] crypto_key_config: The crypto key configuration. This field is used by the Customer-Managed Encryption Keys (CMEK) feature.
+        :param pulumi.Input[pulumi.InputType['InstanceCryptoKeyConfigArgs']] crypto_key_config: The crypto key configuration. This field is used by the Customer-Managed Encryption Keys (CMEK) feature.
                Structure is documented below.
         :param pulumi.Input[str] dataproc_service_account: User-managed service account to set on Dataproc when Cloud Data Fusion creates Dataproc to run data processing pipelines.
         :param pulumi.Input[str] description: An optional description of the instance.
@@ -1181,7 +1144,7 @@ class Instance(pulumi.CustomResource):
         :param pulumi.Input[bool] enable_rbac: Option to enable granular role-based access control.
         :param pulumi.Input[bool] enable_stackdriver_logging: Option to enable Stackdriver Logging.
         :param pulumi.Input[bool] enable_stackdriver_monitoring: Option to enable Stackdriver Monitoring.
-        :param pulumi.Input[Union['InstanceEventPublishConfigArgs', 'InstanceEventPublishConfigArgsDict']] event_publish_config: Option to enable and pass metadata for event publishing.
+        :param pulumi.Input[pulumi.InputType['InstanceEventPublishConfigArgs']] event_publish_config: Option to enable and pass metadata for event publishing.
                Structure is documented below.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: The resource labels for instance to use to annotate any related underlying resources,
                such as Compute Engine VMs.
@@ -1189,7 +1152,7 @@ class Instance(pulumi.CustomResource):
                **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
                Please refer to the field `effective_labels` for all of the labels present on the resource.
         :param pulumi.Input[str] name: The ID of the instance or a fully qualified identifier for the instance.
-        :param pulumi.Input[Union['InstanceNetworkConfigArgs', 'InstanceNetworkConfigArgsDict']] network_config: Network configuration options. These are required when a private Data Fusion instance is to be created.
+        :param pulumi.Input[pulumi.InputType['InstanceNetworkConfigArgs']] network_config: Network configuration options. These are required when a private Data Fusion instance is to be created.
                Structure is documented below.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] options: Map of additional options used to configure the behavior of Data Fusion instance.
         :param pulumi.Input[bool] private_instance: Specifies whether the Data Fusion instance should be private. If set to
@@ -1270,46 +1233,14 @@ class Instance(pulumi.CustomResource):
             labels={
                 "example_key": "example_value",
             },
-            network_config={
-                "network": "default",
-                "ipAllocation": pulumi.Output.all(private_ip_alloc.address, private_ip_alloc.prefix_length).apply(lambda address, prefix_length: f"{address}/{prefix_length}"),
-            },
-            accelerators=[{
-                "acceleratorType": "CDC",
-                "state": "ENABLED",
-            }])
-        ```
-        ### Data Fusion Instance Psc
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        psc = gcp.compute.Network("psc",
-            name="datafusion-psc-network",
-            auto_create_subnetworks=False)
-        psc_subnetwork = gcp.compute.Subnetwork("psc",
-            name="datafusion-psc-subnet",
-            region="us-central1",
-            network=psc.id,
-            ip_cidr_range="10.0.0.0/16")
-        psc_network_attachment = gcp.compute.NetworkAttachment("psc",
-            name="datafusion-psc-attachment",
-            region="us-central1",
-            connection_preference="ACCEPT_AUTOMATIC",
-            subnetworks=[psc_subnetwork.self_link])
-        psc_instance = gcp.datafusion.Instance("psc_instance",
-            name="psc-instance",
-            region="us-central1",
-            type="BASIC",
-            private_instance=True,
-            network_config={
-                "connectionType": "PRIVATE_SERVICE_CONNECT_INTERFACES",
-                "privateServiceConnectConfig": {
-                    "networkAttachment": psc_network_attachment.id,
-                    "unreachableCidrBlock": "192.168.0.0/25",
-                },
-            })
+            network_config=gcp.datafusion.InstanceNetworkConfigArgs(
+                network="default",
+                ip_allocation=pulumi.Output.all(private_ip_alloc.address, private_ip_alloc.prefix_length).apply(lambda address, prefix_length: f"{address}/{prefix_length}"),
+            ),
+            accelerators=[gcp.datafusion.InstanceAcceleratorArgs(
+                accelerator_type="CDC",
+                state="ENABLED",
+            )])
         ```
         ### Data Fusion Instance Cmek
 
@@ -1332,9 +1263,9 @@ class Instance(pulumi.CustomResource):
             name="my-instance",
             region="us-central1",
             type="BASIC",
-            crypto_key_config={
-                "keyReference": crypto_key.id,
-            },
+            crypto_key_config=gcp.datafusion.InstanceCryptoKeyConfigArgs(
+                key_reference=crypto_key.id,
+            ),
             opts = pulumi.ResourceOptions(depends_on=[crypto_key_member]))
         ```
         ### Data Fusion Instance Enterprise
@@ -1360,10 +1291,10 @@ class Instance(pulumi.CustomResource):
             name="my-instance",
             region="us-central1",
             type="BASIC",
-            event_publish_config={
-                "enabled": True,
-                "topic": event_topic.id,
-            })
+            event_publish_config=gcp.datafusion.InstanceEventPublishConfigArgs(
+                enabled=True,
+                topic=event_topic.id,
+            ))
         ```
         ### Data Fusion Instance Zone
 
@@ -1423,18 +1354,18 @@ class Instance(pulumi.CustomResource):
     def _internal_init(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
-                 accelerators: Optional[pulumi.Input[Sequence[pulumi.Input[Union['InstanceAcceleratorArgs', 'InstanceAcceleratorArgsDict']]]]] = None,
-                 crypto_key_config: Optional[pulumi.Input[Union['InstanceCryptoKeyConfigArgs', 'InstanceCryptoKeyConfigArgsDict']]] = None,
+                 accelerators: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['InstanceAcceleratorArgs']]]]] = None,
+                 crypto_key_config: Optional[pulumi.Input[pulumi.InputType['InstanceCryptoKeyConfigArgs']]] = None,
                  dataproc_service_account: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  display_name: Optional[pulumi.Input[str]] = None,
                  enable_rbac: Optional[pulumi.Input[bool]] = None,
                  enable_stackdriver_logging: Optional[pulumi.Input[bool]] = None,
                  enable_stackdriver_monitoring: Optional[pulumi.Input[bool]] = None,
-                 event_publish_config: Optional[pulumi.Input[Union['InstanceEventPublishConfigArgs', 'InstanceEventPublishConfigArgsDict']]] = None,
+                 event_publish_config: Optional[pulumi.Input[pulumi.InputType['InstanceEventPublishConfigArgs']]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  name: Optional[pulumi.Input[str]] = None,
-                 network_config: Optional[pulumi.Input[Union['InstanceNetworkConfigArgs', 'InstanceNetworkConfigArgsDict']]] = None,
+                 network_config: Optional[pulumi.Input[pulumi.InputType['InstanceNetworkConfigArgs']]] = None,
                  options: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  private_instance: Optional[pulumi.Input[bool]] = None,
                  project: Optional[pulumi.Input[str]] = None,
@@ -1496,10 +1427,10 @@ class Instance(pulumi.CustomResource):
     def get(resource_name: str,
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
-            accelerators: Optional[pulumi.Input[Sequence[pulumi.Input[Union['InstanceAcceleratorArgs', 'InstanceAcceleratorArgsDict']]]]] = None,
+            accelerators: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['InstanceAcceleratorArgs']]]]] = None,
             api_endpoint: Optional[pulumi.Input[str]] = None,
             create_time: Optional[pulumi.Input[str]] = None,
-            crypto_key_config: Optional[pulumi.Input[Union['InstanceCryptoKeyConfigArgs', 'InstanceCryptoKeyConfigArgsDict']]] = None,
+            crypto_key_config: Optional[pulumi.Input[pulumi.InputType['InstanceCryptoKeyConfigArgs']]] = None,
             dataproc_service_account: Optional[pulumi.Input[str]] = None,
             description: Optional[pulumi.Input[str]] = None,
             display_name: Optional[pulumi.Input[str]] = None,
@@ -1507,11 +1438,11 @@ class Instance(pulumi.CustomResource):
             enable_rbac: Optional[pulumi.Input[bool]] = None,
             enable_stackdriver_logging: Optional[pulumi.Input[bool]] = None,
             enable_stackdriver_monitoring: Optional[pulumi.Input[bool]] = None,
-            event_publish_config: Optional[pulumi.Input[Union['InstanceEventPublishConfigArgs', 'InstanceEventPublishConfigArgsDict']]] = None,
+            event_publish_config: Optional[pulumi.Input[pulumi.InputType['InstanceEventPublishConfigArgs']]] = None,
             gcs_bucket: Optional[pulumi.Input[str]] = None,
             labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
             name: Optional[pulumi.Input[str]] = None,
-            network_config: Optional[pulumi.Input[Union['InstanceNetworkConfigArgs', 'InstanceNetworkConfigArgsDict']]] = None,
+            network_config: Optional[pulumi.Input[pulumi.InputType['InstanceNetworkConfigArgs']]] = None,
             options: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
             p4_service_account: Optional[pulumi.Input[str]] = None,
             private_instance: Optional[pulumi.Input[bool]] = None,
@@ -1534,13 +1465,13 @@ class Instance(pulumi.CustomResource):
         :param str resource_name: The unique name of the resulting resource.
         :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
         :param pulumi.ResourceOptions opts: Options for the resource.
-        :param pulumi.Input[Sequence[pulumi.Input[Union['InstanceAcceleratorArgs', 'InstanceAcceleratorArgsDict']]]] accelerators: List of accelerators enabled for this CDF instance.
+        :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['InstanceAcceleratorArgs']]]] accelerators: List of accelerators enabled for this CDF instance.
                If accelerators are enabled it is possible a permadiff will be created with the Options field.
                Users will need to either manually update their state file to include these diffed options, or include the field in a lifecycle ignore changes block.
                Structure is documented below.
         :param pulumi.Input[str] api_endpoint: Endpoint on which the REST APIs is accessible.
         :param pulumi.Input[str] create_time: The time the instance was created in RFC3339 UTC "Zulu" format, accurate to nanoseconds.
-        :param pulumi.Input[Union['InstanceCryptoKeyConfigArgs', 'InstanceCryptoKeyConfigArgsDict']] crypto_key_config: The crypto key configuration. This field is used by the Customer-Managed Encryption Keys (CMEK) feature.
+        :param pulumi.Input[pulumi.InputType['InstanceCryptoKeyConfigArgs']] crypto_key_config: The crypto key configuration. This field is used by the Customer-Managed Encryption Keys (CMEK) feature.
                Structure is documented below.
         :param pulumi.Input[str] dataproc_service_account: User-managed service account to set on Dataproc when Cloud Data Fusion creates Dataproc to run data processing pipelines.
         :param pulumi.Input[str] description: An optional description of the instance.
@@ -1549,7 +1480,7 @@ class Instance(pulumi.CustomResource):
         :param pulumi.Input[bool] enable_rbac: Option to enable granular role-based access control.
         :param pulumi.Input[bool] enable_stackdriver_logging: Option to enable Stackdriver Logging.
         :param pulumi.Input[bool] enable_stackdriver_monitoring: Option to enable Stackdriver Monitoring.
-        :param pulumi.Input[Union['InstanceEventPublishConfigArgs', 'InstanceEventPublishConfigArgsDict']] event_publish_config: Option to enable and pass metadata for event publishing.
+        :param pulumi.Input[pulumi.InputType['InstanceEventPublishConfigArgs']] event_publish_config: Option to enable and pass metadata for event publishing.
                Structure is documented below.
         :param pulumi.Input[str] gcs_bucket: Cloud Storage bucket generated by Data Fusion in the customer project.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: The resource labels for instance to use to annotate any related underlying resources,
@@ -1558,7 +1489,7 @@ class Instance(pulumi.CustomResource):
                **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
                Please refer to the field `effective_labels` for all of the labels present on the resource.
         :param pulumi.Input[str] name: The ID of the instance or a fully qualified identifier for the instance.
-        :param pulumi.Input[Union['InstanceNetworkConfigArgs', 'InstanceNetworkConfigArgsDict']] network_config: Network configuration options. These are required when a private Data Fusion instance is to be created.
+        :param pulumi.Input[pulumi.InputType['InstanceNetworkConfigArgs']] network_config: Network configuration options. These are required when a private Data Fusion instance is to be created.
                Structure is documented below.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] options: Map of additional options used to configure the behavior of Data Fusion instance.
         :param pulumi.Input[str] p4_service_account: P4 service account for the customer project.

pulumi_gcp/datafusion/outputs.py

@@ -4,23 +4,16 @@
 
 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__ = [
     'InstanceAccelerator',
     'InstanceCryptoKeyConfig',
     'InstanceEventPublishConfig',
     'InstanceNetworkConfig',
-    'InstanceNetworkConfigPrivateServiceConnectConfig',
 ]
 
 @pulumi.output_type
@@ -142,12 +135,8 @@ class InstanceNetworkConfig(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "connectionType":
-            suggest = "connection_type"
-        elif key == "ipAllocation":
+        if key == "ipAllocation":
             suggest = "ip_allocation"
-        elif key == "privateServiceConnectConfig":
-            suggest = "private_service_connect_config"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in InstanceNetworkConfig. Access the value via the '{suggest}' property getter instead.")
@@ -161,47 +150,21 @@ class InstanceNetworkConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 connection_type: Optional[str] = None,
-                 ip_allocation: Optional[str] = None,
-                 network: Optional[str] = None,
-                 private_service_connect_config: Optional['outputs.InstanceNetworkConfigPrivateServiceConnectConfig'] = None):
+                 ip_allocation: str,
+                 network: str):
         """
-        :param str connection_type: Optional. Type of connection for establishing private IP connectivity between the Data Fusion customer project VPC and
-               the corresponding tenant project from a predefined list of available connection modes.
-               If this field is unspecified for a private instance, VPC peering is used.
-               Possible values are: `VPC_PEERING`, `PRIVATE_SERVICE_CONNECT_INTERFACES`.
         :param str ip_allocation: The IP range in CIDR notation to use for the managed Data Fusion instance
                nodes. This range must not overlap with any other ranges used in the Data Fusion instance network.
         :param str network: Name of the network in the project with which the tenant project
                will be peered for executing pipelines. In case of shared VPC where the network resides in another host
                project the network should specified in the form of projects/{host-project-id}/global/networks/{network}
-        :param 'InstanceNetworkConfigPrivateServiceConnectConfigArgs' private_service_connect_config: Optional. Configuration for Private Service Connect.
-               This is required only when using connection type PRIVATE_SERVICE_CONNECT_INTERFACES.
-               Structure is documented below.
         """
-        if connection_type is not None:
-            pulumi.set(__self__, "connection_type", connection_type)
-        if ip_allocation is not None:
-            pulumi.set(__self__, "ip_allocation", ip_allocation)
-        if network is not None:
-            pulumi.set(__self__, "network", network)
-        if private_service_connect_config is not None:
-            pulumi.set(__self__, "private_service_connect_config", private_service_connect_config)
-
-    @property
-    @pulumi.getter(name="connectionType")
-    def connection_type(self) -> Optional[str]:
-        """
-        Optional. Type of connection for establishing private IP connectivity between the Data Fusion customer project VPC and
-        the corresponding tenant project from a predefined list of available connection modes.
-        If this field is unspecified for a private instance, VPC peering is used.
-        Possible values are: `VPC_PEERING`, `PRIVATE_SERVICE_CONNECT_INTERFACES`.
-        """
-        return pulumi.get(self, "connection_type")
+        pulumi.set(__self__, "ip_allocation", ip_allocation)
+        pulumi.set(__self__, "network", network)
 
     @property
     @pulumi.getter(name="ipAllocation")
-    def ip_allocation(self) -> Optional[str]:
+    def ip_allocation(self) -> str:
         """
         The IP range in CIDR notation to use for the managed Data Fusion instance
         nodes. This range must not overlap with any other ranges used in the Data Fusion instance network.
@@ -210,7 +173,7 @@ class InstanceNetworkConfig(dict):
 
     @property
     @pulumi.getter
-    def network(self) -> Optional[str]:
+    def network(self) -> str:
         """
         Name of the network in the project with which the tenant project
         will be peered for executing pipelines. In case of shared VPC where the network resides in another host
@@ -218,92 +181,4 @@ class InstanceNetworkConfig(dict):
         """
         return pulumi.get(self, "network")
 
-    @property
-    @pulumi.getter(name="privateServiceConnectConfig")
-    def private_service_connect_config(self) -> Optional['outputs.InstanceNetworkConfigPrivateServiceConnectConfig']:
-        """
-        Optional. Configuration for Private Service Connect.
-        This is required only when using connection type PRIVATE_SERVICE_CONNECT_INTERFACES.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "private_service_connect_config")
-
-
-@pulumi.output_type
-class InstanceNetworkConfigPrivateServiceConnectConfig(dict):
-    @staticmethod
-    def __key_warning(key: str):
-        suggest = None
-        if key == "effectiveUnreachableCidrBlock":
-            suggest = "effective_unreachable_cidr_block"
-        elif key == "networkAttachment":
-            suggest = "network_attachment"
-        elif key == "unreachableCidrBlock":
-            suggest = "unreachable_cidr_block"
-
-        if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in InstanceNetworkConfigPrivateServiceConnectConfig. Access the value via the '{suggest}' property getter instead.")
-
-    def __getitem__(self, key: str) -> Any:
-        InstanceNetworkConfigPrivateServiceConnectConfig.__key_warning(key)
-        return super().__getitem__(key)
-
-    def get(self, key: str, default = None) -> Any:
-        InstanceNetworkConfigPrivateServiceConnectConfig.__key_warning(key)
-        return super().get(key, default)
-
-    def __init__(__self__, *,
-                 effective_unreachable_cidr_block: Optional[str] = None,
-                 network_attachment: Optional[str] = None,
-                 unreachable_cidr_block: Optional[str] = None):
-        """
-        :param str effective_unreachable_cidr_block: (Output)
-               Output only. The CIDR block to which the CDF instance can't route traffic to in the consumer project VPC.
-               The size of this block is /25. The format of this field is governed by RFC 4632.
-        :param str network_attachment: Optional. The reference to the network attachment used to establish private connectivity.
-               It will be of the form projects/{project-id}/regions/{region}/networkAttachments/{network-attachment-id}.
-               This is required only when using connection type PRIVATE_SERVICE_CONNECT_INTERFACES.
-        :param str unreachable_cidr_block: Optional. Input only. The CIDR block to which the CDF instance can't route traffic to in the consumer project VPC.
-               The size of this block should be at least /25. This range should not overlap with the primary address range of any subnetwork used by the network attachment.
-               This range can be used for other purposes in the consumer VPC as long as there is no requirement for CDF to reach destinations using these addresses.
-               If this value is not provided, the server chooses a non RFC 1918 address range. The format of this field is governed by RFC 4632.
-        """
-        if effective_unreachable_cidr_block is not None:
-            pulumi.set(__self__, "effective_unreachable_cidr_block", effective_unreachable_cidr_block)
-        if network_attachment is not None:
-            pulumi.set(__self__, "network_attachment", network_attachment)
-        if unreachable_cidr_block is not None:
-            pulumi.set(__self__, "unreachable_cidr_block", unreachable_cidr_block)
-
-    @property
-    @pulumi.getter(name="effectiveUnreachableCidrBlock")
-    def effective_unreachable_cidr_block(self) -> Optional[str]:
-        """
-        (Output)
-        Output only. The CIDR block to which the CDF instance can't route traffic to in the consumer project VPC.
-        The size of this block is /25. The format of this field is governed by RFC 4632.
-        """
-        return pulumi.get(self, "effective_unreachable_cidr_block")
-
-    @property
-    @pulumi.getter(name="networkAttachment")
-    def network_attachment(self) -> Optional[str]:
-        """
-        Optional. The reference to the network attachment used to establish private connectivity.
-        It will be of the form projects/{project-id}/regions/{region}/networkAttachments/{network-attachment-id}.
-        This is required only when using connection type PRIVATE_SERVICE_CONNECT_INTERFACES.
-        """
-        return pulumi.get(self, "network_attachment")
-
-    @property
-    @pulumi.getter(name="unreachableCidrBlock")
-    def unreachable_cidr_block(self) -> Optional[str]:
-        """
-        Optional. Input only. The CIDR block to which the CDF instance can't route traffic to in the consumer project VPC.
-        The size of this block should be at least /25. This range should not overlap with the primary address range of any subnetwork used by the network attachment.
-        This range can be used for other purposes in the consumer VPC as long as there is no requirement for CDF to reach destinations using these addresses.
-        If this value is not provided, the server chooses a non RFC 1918 address range. The format of this field is governed by RFC 4632.
-        """
-        return pulumi.get(self, "unreachable_cidr_block")
-