pulumi-gcp 8.2.0a1726671837__py3-none-any.whl → 8.3.0__py3-none-any.whl

pulumi_gcp/__init__.py

@@ -114,6 +114,8 @@ if typing.TYPE_CHECKING:
     datastream = __datastream
     import pulumi_gcp.deploymentmanager as __deploymentmanager
     deploymentmanager = __deploymentmanager
+    import pulumi_gcp.developerconnect as __developerconnect
+    developerconnect = __developerconnect
     import pulumi_gcp.diagflow as __diagflow
     diagflow = __diagflow
     import pulumi_gcp.discoveryengine as __discoveryengine
@@ -166,6 +168,8 @@ if typing.TYPE_CHECKING:
     managedkafka = __managedkafka
     import pulumi_gcp.memcache as __memcache
     memcache = __memcache
+    import pulumi_gcp.memorystore as __memorystore
+    memorystore = __memorystore
     import pulumi_gcp.migrationcenter as __migrationcenter
     migrationcenter = __migrationcenter
     import pulumi_gcp.ml as __ml
@@ -303,6 +307,7 @@ else:
     dataproc = _utilities.lazy_import('pulumi_gcp.dataproc')
     datastream = _utilities.lazy_import('pulumi_gcp.datastream')
     deploymentmanager = _utilities.lazy_import('pulumi_gcp.deploymentmanager')
+    developerconnect = _utilities.lazy_import('pulumi_gcp.developerconnect')
     diagflow = _utilities.lazy_import('pulumi_gcp.diagflow')
     discoveryengine = _utilities.lazy_import('pulumi_gcp.discoveryengine')
     dns = _utilities.lazy_import('pulumi_gcp.dns')
@@ -329,6 +334,7 @@ else:
     looker = _utilities.lazy_import('pulumi_gcp.looker')
     managedkafka = _utilities.lazy_import('pulumi_gcp.managedkafka')
     memcache = _utilities.lazy_import('pulumi_gcp.memcache')
+    memorystore = _utilities.lazy_import('pulumi_gcp.memorystore')
     migrationcenter = _utilities.lazy_import('pulumi_gcp.migrationcenter')
     ml = _utilities.lazy_import('pulumi_gcp.ml')
     monitoring = _utilities.lazy_import('pulumi_gcp.monitoring')
@@ -2327,6 +2333,14 @@ _utilities.register(
    "gcp:compute/firewallPolicyRule:FirewallPolicyRule": "FirewallPolicyRule"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "compute/firewallPolicyWithRules",
+  "fqn": "pulumi_gcp.compute",
+  "classes": {
+   "gcp:compute/firewallPolicyWithRules:FirewallPolicyWithRules": "FirewallPolicyWithRules"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "compute/forwardingRule",
@@ -2663,6 +2677,14 @@ _utilities.register(
    "gcp:compute/networkFirewallPolicyRule:NetworkFirewallPolicyRule": "NetworkFirewallPolicyRule"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "compute/networkFirewallPolicyWithRules",
+  "fqn": "pulumi_gcp.compute",
+  "classes": {
+   "gcp:compute/networkFirewallPolicyWithRules:NetworkFirewallPolicyWithRules": "NetworkFirewallPolicyWithRules"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "compute/networkPeering",
@@ -3407,6 +3429,14 @@ _utilities.register(
    "gcp:databasemigrationservice/connectionProfile:ConnectionProfile": "ConnectionProfile"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "databasemigrationservice/migrationJob",
+  "fqn": "pulumi_gcp.databasemigrationservice",
+  "classes": {
+   "gcp:databasemigrationservice/migrationJob:MigrationJob": "MigrationJob"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "databasemigrationservice/privateConnection",
@@ -4135,6 +4165,22 @@ _utilities.register(
    "gcp:deploymentmanager/deployment:Deployment": "Deployment"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "developerconnect/connection",
+  "fqn": "pulumi_gcp.developerconnect",
+  "classes": {
+   "gcp:developerconnect/connection:Connection": "Connection"
+  }
+ },
+ {
+  "pkg": "gcp",
+  "mod": "developerconnect/gitRepositoryLink",
+  "fqn": "pulumi_gcp.developerconnect",
+  "classes": {
+   "gcp:developerconnect/gitRepositoryLink:GitRepositoryLink": "GitRepositoryLink"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "diagflow/agent",
@@ -4279,6 +4325,14 @@ _utilities.register(
    "gcp:discoveryengine/searchEngine:SearchEngine": "SearchEngine"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "discoveryengine/targetSite",
+  "fqn": "pulumi_gcp.discoveryengine",
+  "classes": {
+   "gcp:discoveryengine/targetSite:TargetSite": "TargetSite"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "dns/dnsManagedZoneIamBinding",
@@ -5191,6 +5245,14 @@ _utilities.register(
    "gcp:healthcare/hl7StoreIamPolicy:Hl7StoreIamPolicy": "Hl7StoreIamPolicy"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "healthcare/workspace",
+  "fqn": "pulumi_gcp.healthcare",
+  "classes": {
+   "gcp:healthcare/workspace:Workspace": "Workspace"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "iam/accessBoundaryPolicy",
@@ -5919,6 +5981,14 @@ _utilities.register(
    "gcp:memcache/instance:Instance": "Instance"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "memorystore/instance",
+  "fqn": "pulumi_gcp.memorystore",
+  "classes": {
+   "gcp:memorystore/instance:Instance": "Instance"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "migrationcenter/group",
@@ -6895,6 +6965,46 @@ _utilities.register(
    "gcp:runtimeconfig/variable:Variable": "Variable"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "secretmanager/regionalSecret",
+  "fqn": "pulumi_gcp.secretmanager",
+  "classes": {
+   "gcp:secretmanager/regionalSecret:RegionalSecret": "RegionalSecret"
+  }
+ },
+ {
+  "pkg": "gcp",
+  "mod": "secretmanager/regionalSecretIamBinding",
+  "fqn": "pulumi_gcp.secretmanager",
+  "classes": {
+   "gcp:secretmanager/regionalSecretIamBinding:RegionalSecretIamBinding": "RegionalSecretIamBinding"
+  }
+ },
+ {
+  "pkg": "gcp",
+  "mod": "secretmanager/regionalSecretIamMember",
+  "fqn": "pulumi_gcp.secretmanager",
+  "classes": {
+   "gcp:secretmanager/regionalSecretIamMember:RegionalSecretIamMember": "RegionalSecretIamMember"
+  }
+ },
+ {
+  "pkg": "gcp",
+  "mod": "secretmanager/regionalSecretIamPolicy",
+  "fqn": "pulumi_gcp.secretmanager",
+  "classes": {
+   "gcp:secretmanager/regionalSecretIamPolicy:RegionalSecretIamPolicy": "RegionalSecretIamPolicy"
+  }
+ },
+ {
+  "pkg": "gcp",
+  "mod": "secretmanager/regionalSecretVersion",
+  "fqn": "pulumi_gcp.secretmanager",
+  "classes": {
+   "gcp:secretmanager/regionalSecretVersion:RegionalSecretVersion": "RegionalSecretVersion"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "secretmanager/secret",
@@ -7023,6 +7133,14 @@ _utilities.register(
    "gcp:securitycenter/folderNotificationConfig:FolderNotificationConfig": "FolderNotificationConfig"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "securitycenter/folderSccBigQueryExport",
+  "fqn": "pulumi_gcp.securitycenter",
+  "classes": {
+   "gcp:securitycenter/folderSccBigQueryExport:FolderSccBigQueryExport": "FolderSccBigQueryExport"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "securitycenter/instanceIamBinding",
@@ -7103,6 +7221,14 @@ _utilities.register(
    "gcp:securitycenter/organizationCustomModule:OrganizationCustomModule": "OrganizationCustomModule"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "securitycenter/organizationSccBigQueryExport",
+  "fqn": "pulumi_gcp.securitycenter",
+  "classes": {
+   "gcp:securitycenter/organizationSccBigQueryExport:OrganizationSccBigQueryExport": "OrganizationSccBigQueryExport"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "securitycenter/projectCustomModule",
@@ -7119,6 +7245,14 @@ _utilities.register(
    "gcp:securitycenter/projectNotificationConfig:ProjectNotificationConfig": "ProjectNotificationConfig"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "securitycenter/projectSccBigQueryExport",
+  "fqn": "pulumi_gcp.securitycenter",
+  "classes": {
+   "gcp:securitycenter/projectSccBigQueryExport:ProjectSccBigQueryExport": "ProjectSccBigQueryExport"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "securitycenter/source",
@@ -7191,6 +7325,14 @@ _utilities.register(
    "gcp:securitycenter/v2OrganizationNotificationConfig:V2OrganizationNotificationConfig": "V2OrganizationNotificationConfig"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "securitycenter/v2OrganizationSccBigQueryExport",
+  "fqn": "pulumi_gcp.securitycenter",
+  "classes": {
+   "gcp:securitycenter/v2OrganizationSccBigQueryExport:V2OrganizationSccBigQueryExport": "V2OrganizationSccBigQueryExport"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "securitycenter/v2OrganizationSccBigQueryExports",
@@ -7415,6 +7557,14 @@ _utilities.register(
    "gcp:serviceusage/consumerQuotaOverride:ConsumerQuotaOverride": "ConsumerQuotaOverride"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "siteverification/webResource",
+  "fqn": "pulumi_gcp.siteverification",
+  "classes": {
+   "gcp:siteverification/webResource:WebResource": "WebResource"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "sourcerepo/repository",
@@ -7447,6 +7597,14 @@ _utilities.register(
    "gcp:sourcerepo/repositoryIamPolicy:RepositoryIamPolicy": "RepositoryIamPolicy"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "spanner/backupSchedule",
+  "fqn": "pulumi_gcp.spanner",
+  "classes": {
+   "gcp:spanner/backupSchedule:BackupSchedule": "BackupSchedule"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "spanner/database",

pulumi_gcp/alloydb/_inputs.py

@@ -1810,6 +1810,10 @@ if not MYPY:
         true.
         Structure is documented below.
         """
+        enable_outbound_public_ip: NotRequired[pulumi.Input[bool]]
+        """
+        Enabling outbound public ip for the instance.
+        """
         enable_public_ip: NotRequired[pulumi.Input[bool]]
         """
         Enabling public ip for the instance. If a user wishes to disable this,
@@ -1823,18 +1827,22 @@ elif False:
 class InstanceNetworkConfigArgs:
     def __init__(__self__, *,
                  authorized_external_networks: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceNetworkConfigAuthorizedExternalNetworkArgs']]]] = None,
+                 enable_outbound_public_ip: Optional[pulumi.Input[bool]] = None,
                  enable_public_ip: Optional[pulumi.Input[bool]] = None):
         """
         :param pulumi.Input[Sequence[pulumi.Input['InstanceNetworkConfigAuthorizedExternalNetworkArgs']]] authorized_external_networks: A list of external networks authorized to access this instance. This
                field is only allowed to be set when `enable_public_ip` is set to
                true.
                Structure is documented below.
+        :param pulumi.Input[bool] enable_outbound_public_ip: Enabling outbound public ip for the instance.
         :param pulumi.Input[bool] enable_public_ip: Enabling public ip for the instance. If a user wishes to disable this,
                please also clear the list of the authorized external networks set on
                the same instance.
         """
         if authorized_external_networks is not None:
             pulumi.set(__self__, "authorized_external_networks", authorized_external_networks)
+        if enable_outbound_public_ip is not None:
+            pulumi.set(__self__, "enable_outbound_public_ip", enable_outbound_public_ip)
         if enable_public_ip is not None:
             pulumi.set(__self__, "enable_public_ip", enable_public_ip)
 
@@ -1853,6 +1861,18 @@ class InstanceNetworkConfigArgs:
     def authorized_external_networks(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceNetworkConfigAuthorizedExternalNetworkArgs']]]]):
         pulumi.set(self, "authorized_external_networks", value)
 
+    @property
+    @pulumi.getter(name="enableOutboundPublicIp")
+    def enable_outbound_public_ip(self) -> Optional[pulumi.Input[bool]]:
+        """
+        Enabling outbound public ip for the instance.
+        """
+        return pulumi.get(self, "enable_outbound_public_ip")
+
+    @enable_outbound_public_ip.setter
+    def enable_outbound_public_ip(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "enable_outbound_public_ip", value)
+
     @property
     @pulumi.getter(name="enablePublicIp")
     def enable_public_ip(self) -> Optional[pulumi.Input[bool]]:

pulumi_gcp/alloydb/instance.py

@@ -338,6 +338,7 @@ class _InstanceState:
                  name: Optional[pulumi.Input[str]] = None,
                  network_config: Optional[pulumi.Input['InstanceNetworkConfigArgs']] = None,
                  observability_config: Optional[pulumi.Input['InstanceObservabilityConfigArgs']] = None,
+                 outbound_public_ip_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  psc_instance_config: Optional[pulumi.Input['InstancePscInstanceConfigArgs']] = None,
                  public_ip_address: Optional[pulumi.Input[str]] = None,
                  pulumi_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -383,6 +384,9 @@ class _InstanceState:
                Structure is documented below.
         :param pulumi.Input['InstanceObservabilityConfigArgs'] observability_config: Configuration for enhanced query insights.
                Structure is documented below.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] outbound_public_ip_addresses: The outbound public IP addresses for the instance. This is available ONLY when
+               networkConfig.enableOutboundPublicIp is set to true. These IP addresses are used
+               for outbound connections.
         :param pulumi.Input['InstancePscInstanceConfigArgs'] psc_instance_config: Configuration for Private Service Connect (PSC) for the instance.
                Structure is documented below.
         :param pulumi.Input[str] public_ip_address: The public IP addresses for the Instance. This is available ONLY when
@@ -435,6 +439,8 @@ class _InstanceState:
             pulumi.set(__self__, "network_config", network_config)
         if observability_config is not None:
             pulumi.set(__self__, "observability_config", observability_config)
+        if outbound_public_ip_addresses is not None:
+            pulumi.set(__self__, "outbound_public_ip_addresses", outbound_public_ip_addresses)
         if psc_instance_config is not None:
             pulumi.set(__self__, "psc_instance_config", psc_instance_config)
         if public_ip_address is not None:
@@ -682,6 +688,20 @@ class _InstanceState:
     def observability_config(self, value: Optional[pulumi.Input['InstanceObservabilityConfigArgs']]):
         pulumi.set(self, "observability_config", value)
 
+    @property
+    @pulumi.getter(name="outboundPublicIpAddresses")
+    def outbound_public_ip_addresses(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        The outbound public IP addresses for the instance. This is available ONLY when
+        networkConfig.enableOutboundPublicIp is set to true. These IP addresses are used
+        for outbound connections.
+        """
+        return pulumi.get(self, "outbound_public_ip_addresses")
+
+    @outbound_public_ip_addresses.setter
+    def outbound_public_ip_addresses(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "outbound_public_ip_addresses", value)
+
     @property
     @pulumi.getter(name="pscInstanceConfig")
     def psc_instance_config(self) -> Optional[pulumi.Input['InstancePscInstanceConfigArgs']]:
@@ -1171,6 +1191,7 @@ class Instance(pulumi.CustomResource):
             __props__.__dict__["effective_labels"] = None
             __props__.__dict__["ip_address"] = None
             __props__.__dict__["name"] = None
+            __props__.__dict__["outbound_public_ip_addresses"] = None
             __props__.__dict__["public_ip_address"] = None
             __props__.__dict__["pulumi_labels"] = None
             __props__.__dict__["reconciling"] = None
@@ -1207,6 +1228,7 @@ class Instance(pulumi.CustomResource):
             name: Optional[pulumi.Input[str]] = None,
             network_config: Optional[pulumi.Input[Union['InstanceNetworkConfigArgs', 'InstanceNetworkConfigArgsDict']]] = None,
             observability_config: Optional[pulumi.Input[Union['InstanceObservabilityConfigArgs', 'InstanceObservabilityConfigArgsDict']]] = None,
+            outbound_public_ip_addresses: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             psc_instance_config: Optional[pulumi.Input[Union['InstancePscInstanceConfigArgs', 'InstancePscInstanceConfigArgsDict']]] = None,
             public_ip_address: Optional[pulumi.Input[str]] = None,
             pulumi_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
@@ -1257,6 +1279,9 @@ class Instance(pulumi.CustomResource):
                Structure is documented below.
         :param pulumi.Input[Union['InstanceObservabilityConfigArgs', 'InstanceObservabilityConfigArgsDict']] observability_config: Configuration for enhanced query insights.
                Structure is documented below.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] outbound_public_ip_addresses: The outbound public IP addresses for the instance. This is available ONLY when
+               networkConfig.enableOutboundPublicIp is set to true. These IP addresses are used
+               for outbound connections.
         :param pulumi.Input[Union['InstancePscInstanceConfigArgs', 'InstancePscInstanceConfigArgsDict']] psc_instance_config: Configuration for Private Service Connect (PSC) for the instance.
                Structure is documented below.
         :param pulumi.Input[str] public_ip_address: The public IP addresses for the Instance. This is available ONLY when
@@ -1295,6 +1320,7 @@ class Instance(pulumi.CustomResource):
         __props__.__dict__["name"] = name
         __props__.__dict__["network_config"] = network_config
         __props__.__dict__["observability_config"] = observability_config
+        __props__.__dict__["outbound_public_ip_addresses"] = outbound_public_ip_addresses
         __props__.__dict__["psc_instance_config"] = psc_instance_config
         __props__.__dict__["public_ip_address"] = public_ip_address
         __props__.__dict__["pulumi_labels"] = pulumi_labels
@@ -1462,6 +1488,16 @@ class Instance(pulumi.CustomResource):
         """
         return pulumi.get(self, "observability_config")
 
+    @property
+    @pulumi.getter(name="outboundPublicIpAddresses")
+    def outbound_public_ip_addresses(self) -> pulumi.Output[Sequence[str]]:
+        """
+        The outbound public IP addresses for the instance. This is available ONLY when
+        networkConfig.enableOutboundPublicIp is set to true. These IP addresses are used
+        for outbound connections.
+        """
+        return pulumi.get(self, "outbound_public_ip_addresses")
+
     @property
     @pulumi.getter(name="pscInstanceConfig")
     def psc_instance_config(self) -> pulumi.Output['outputs.InstancePscInstanceConfig']:

pulumi_gcp/alloydb/outputs.py

@@ -1566,6 +1566,8 @@ class InstanceNetworkConfig(dict):
         suggest = None
         if key == "authorizedExternalNetworks":
             suggest = "authorized_external_networks"
+        elif key == "enableOutboundPublicIp":
+            suggest = "enable_outbound_public_ip"
         elif key == "enablePublicIp":
             suggest = "enable_public_ip"
 
@@ -1582,18 +1584,22 @@ class InstanceNetworkConfig(dict):
 
     def __init__(__self__, *,
                  authorized_external_networks: Optional[Sequence['outputs.InstanceNetworkConfigAuthorizedExternalNetwork']] = None,
+                 enable_outbound_public_ip: Optional[bool] = None,
                  enable_public_ip: Optional[bool] = None):
         """
         :param Sequence['InstanceNetworkConfigAuthorizedExternalNetworkArgs'] authorized_external_networks: A list of external networks authorized to access this instance. This
                field is only allowed to be set when `enable_public_ip` is set to
                true.
                Structure is documented below.
+        :param bool enable_outbound_public_ip: Enabling outbound public ip for the instance.
         :param bool enable_public_ip: Enabling public ip for the instance. If a user wishes to disable this,
                please also clear the list of the authorized external networks set on
                the same instance.
         """
         if authorized_external_networks is not None:
             pulumi.set(__self__, "authorized_external_networks", authorized_external_networks)
+        if enable_outbound_public_ip is not None:
+            pulumi.set(__self__, "enable_outbound_public_ip", enable_outbound_public_ip)
         if enable_public_ip is not None:
             pulumi.set(__self__, "enable_public_ip", enable_public_ip)
 
@@ -1608,6 +1614,14 @@ class InstanceNetworkConfig(dict):
         """
         return pulumi.get(self, "authorized_external_networks")
 
+    @property
+    @pulumi.getter(name="enableOutboundPublicIp")
+    def enable_outbound_public_ip(self) -> Optional[bool]:
+        """
+        Enabling outbound public ip for the instance.
+        """
+        return pulumi.get(self, "enable_outbound_public_ip")
+
     @property
     @pulumi.getter(name="enablePublicIp")
     def enable_public_ip(self) -> Optional[bool]:

pulumi_gcp/bigquery/__init__.py

@@ -23,6 +23,7 @@ from .get_dataset import *
 from .get_dataset_iam_policy import *
 from .get_default_service_account import *
 from .get_table_iam_policy import *
+from .get_tables import *
 from .iam_binding import *
 from .iam_member import *
 from .iam_policy import *

pulumi_gcp/bigquery/get_tables.py

@@ -0,0 +1,143 @@
+# coding=utf-8
+# *** WARNING: this file was generated by the Pulumi Terraform Bridge (tfgen) Tool. ***
+# *** Do not edit by hand unless you're certain you know what you are doing! ***
+
+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__ = [
+    'GetTablesResult',
+    'AwaitableGetTablesResult',
+    'get_tables',
+    'get_tables_output',
+]
+
+@pulumi.output_type
+class GetTablesResult:
+    """
+    A collection of values returned by getTables.
+    """
+    def __init__(__self__, dataset_id=None, id=None, project=None, tables=None):
+        if dataset_id and not isinstance(dataset_id, str):
+            raise TypeError("Expected argument 'dataset_id' to be a str")
+        pulumi.set(__self__, "dataset_id", dataset_id)
+        if id and not isinstance(id, str):
+            raise TypeError("Expected argument 'id' to be a str")
+        pulumi.set(__self__, "id", id)
+        if project and not isinstance(project, str):
+            raise TypeError("Expected argument 'project' to be a str")
+        pulumi.set(__self__, "project", project)
+        if tables and not isinstance(tables, list):
+            raise TypeError("Expected argument 'tables' to be a list")
+        pulumi.set(__self__, "tables", tables)
+
+    @property
+    @pulumi.getter(name="datasetId")
+    def dataset_id(self) -> str:
+        return pulumi.get(self, "dataset_id")
+
+    @property
+    @pulumi.getter
+    def id(self) -> str:
+        """
+        The provider-assigned unique ID for this managed resource.
+        """
+        return pulumi.get(self, "id")
+
+    @property
+    @pulumi.getter
+    def project(self) -> Optional[str]:
+        return pulumi.get(self, "project")
+
+    @property
+    @pulumi.getter
+    def tables(self) -> Sequence['outputs.GetTablesTableResult']:
+        """
+        A list of all retrieved BigQuery tables. Structure is defined below.
+        """
+        return pulumi.get(self, "tables")
+
+
+class AwaitableGetTablesResult(GetTablesResult):
+    # pylint: disable=using-constant-test
+    def __await__(self):
+        if False:
+            yield self
+        return GetTablesResult(
+            dataset_id=self.dataset_id,
+            id=self.id,
+            project=self.project,
+            tables=self.tables)
+
+
+def get_tables(dataset_id: Optional[str] = None,
+               project: Optional[str] = None,
+               opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetTablesResult:
+    """
+    Get a list of tables in a BigQuery dataset. For more information see
+    the [official documentation](https://cloud.google.com/bigquery/docs)
+    and [API](https://cloud.google.com/bigquery/docs/reference/rest/v2/tables).
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    tables = gcp.bigquery.get_tables(dataset_id="my-bq-dataset",
+        project="my-project")
+    ```
+
+
+    :param str dataset_id: The dataset ID.
+    :param str project: The ID of the project in which the resource belongs.
+           If it is not provided, the provider project is used.
+    """
+    __args__ = dict()
+    __args__['datasetId'] = dataset_id
+    __args__['project'] = project
+    opts = pulumi.InvokeOptions.merge(_utilities.get_invoke_opts_defaults(), opts)
+    __ret__ = pulumi.runtime.invoke('gcp:bigquery/getTables:getTables', __args__, opts=opts, typ=GetTablesResult).value
+
+    return AwaitableGetTablesResult(
+        dataset_id=pulumi.get(__ret__, 'dataset_id'),
+        id=pulumi.get(__ret__, 'id'),
+        project=pulumi.get(__ret__, 'project'),
+        tables=pulumi.get(__ret__, 'tables'))
+
+
+@_utilities.lift_output_func(get_tables)
+def get_tables_output(dataset_id: Optional[pulumi.Input[str]] = None,
+                      project: Optional[pulumi.Input[Optional[str]]] = None,
+                      opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetTablesResult]:
+    """
+    Get a list of tables in a BigQuery dataset. For more information see
+    the [official documentation](https://cloud.google.com/bigquery/docs)
+    and [API](https://cloud.google.com/bigquery/docs/reference/rest/v2/tables).
+
+    ## Example Usage
+
+    ```python
+    import pulumi
+    import pulumi_gcp as gcp
+
+    tables = gcp.bigquery.get_tables(dataset_id="my-bq-dataset",
+        project="my-project")
+    ```
+
+
+    :param str dataset_id: The dataset ID.
+    :param str project: The ID of the project in which the resource belongs.
+           If it is not provided, the provider project is used.
+    """
+    ...

pulumi_gcp/bigquery/outputs.py

@@ -103,6 +103,7 @@ __all__ = [
     'GetDatasetAccessViewResult',
     'GetDatasetDefaultEncryptionConfigurationResult',
     'GetDatasetExternalDatasetReferenceResult',
+    'GetTablesTableResult',
 ]
 
 @pulumi.output_type
@@ -6335,3 +6336,32 @@ class GetDatasetExternalDatasetReferenceResult(dict):
         return pulumi.get(self, "external_source")
 
 
+@pulumi.output_type
+class GetTablesTableResult(dict):
+    def __init__(__self__, *,
+                 labels: Mapping[str, str],
+                 table_id: str):
+        """
+        :param Mapping[str, str] labels: User-provided table labels, in key/value pairs.
+        :param str table_id: The name of the table.
+        """
+        pulumi.set(__self__, "labels", labels)
+        pulumi.set(__self__, "table_id", table_id)
+
+    @property
+    @pulumi.getter
+    def labels(self) -> Mapping[str, str]:
+        """
+        User-provided table labels, in key/value pairs.
+        """
+        return pulumi.get(self, "labels")
+
+    @property
+    @pulumi.getter(name="tableId")
+    def table_id(self) -> str:
+        """
+        The name of the table.
+        """
+        return pulumi.get(self, "table_id")
+
+

pulumi_gcp/compute/__init__.py

@@ -30,6 +30,7 @@ from .firewall import *
 from .firewall_policy import *
 from .firewall_policy_association import *
 from .firewall_policy_rule import *
+from .firewall_policy_with_rules import *
 from .forwarding_rule import *
 from .get_address import *
 from .get_addresses import *
@@ -127,6 +128,7 @@ from .network_endpoint_list import *
 from .network_firewall_policy import *
 from .network_firewall_policy_association import *
 from .network_firewall_policy_rule import *
+from .network_firewall_policy_with_rules import *
 from .network_peering import *
 from .network_peering_routes_config import *
 from .node_group import *