pulumi-gcp 8.22.0a1741790977__py3-none-any.whl → 8.23.0__py3-none-any.whl

pulumi_gcp/__init__.py

@@ -4946,6 +4946,14 @@ _utilities.register(
    "gcp:eventarc/channel:Channel": "Channel"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "eventarc/googleApiSource",
+  "fqn": "pulumi_gcp.eventarc",
+  "classes": {
+   "gcp:eventarc/googleApiSource:GoogleApiSource": "GoogleApiSource"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "eventarc/googleChannelConfig",
@@ -4962,6 +4970,14 @@ _utilities.register(
    "gcp:eventarc/messageBus:MessageBus": "MessageBus"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "eventarc/pipeline",
+  "fqn": "pulumi_gcp.eventarc",
+  "classes": {
+   "gcp:eventarc/pipeline:Pipeline": "Pipeline"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "eventarc/trigger",
@@ -5058,6 +5074,14 @@ _utilities.register(
    "gcp:firebase/appCheckServiceConfig:AppCheckServiceConfig": "AppCheckServiceConfig"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "firebase/appHostingBackend",
+  "fqn": "pulumi_gcp.firebase",
+  "classes": {
+   "gcp:firebase/appHostingBackend:AppHostingBackend": "AppHostingBackend"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "firebase/appleApp",
@@ -5818,6 +5842,22 @@ _utilities.register(
    "gcp:iam/foldersPolicyBinding:FoldersPolicyBinding": "FoldersPolicyBinding"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "iam/oauthClient",
+  "fqn": "pulumi_gcp.iam",
+  "classes": {
+   "gcp:iam/oauthClient:OauthClient": "OauthClient"
+  }
+ },
+ {
+  "pkg": "gcp",
+  "mod": "iam/oauthClientCredential",
+  "fqn": "pulumi_gcp.iam",
+  "classes": {
+   "gcp:iam/oauthClientCredential:OauthClientCredential": "OauthClientCredential"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "iam/organizationsPolicyBinding",
@@ -6554,6 +6594,22 @@ _utilities.register(
    "gcp:managedkafka/cluster:Cluster": "Cluster"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "managedkafka/connectCluster",
+  "fqn": "pulumi_gcp.managedkafka",
+  "classes": {
+   "gcp:managedkafka/connectCluster:ConnectCluster": "ConnectCluster"
+  }
+ },
+ {
+  "pkg": "gcp",
+  "mod": "managedkafka/connector",
+  "fqn": "pulumi_gcp.managedkafka",
+  "classes": {
+   "gcp:managedkafka/connector:Connector": "Connector"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "managedkafka/topic",
@@ -6882,6 +6938,14 @@ _utilities.register(
    "gcp:networksecurity/authzPolicy:AuthzPolicy": "AuthzPolicy"
   }
  },
+ {
+  "pkg": "gcp",
+  "mod": "networksecurity/backendAuthenticationConfig",
+  "fqn": "pulumi_gcp.networksecurity",
+  "classes": {
+   "gcp:networksecurity/backendAuthenticationConfig:BackendAuthenticationConfig": "BackendAuthenticationConfig"
+  }
+ },
  {
   "pkg": "gcp",
   "mod": "networksecurity/clientTlsPolicy",

pulumi_gcp/alloydb/_inputs.py

@@ -83,6 +83,8 @@ __all__ = [
     'InstanceObservabilityConfigArgsDict',
     'InstancePscInstanceConfigArgs',
     'InstancePscInstanceConfigArgsDict',
+    'InstancePscInstanceConfigPscInterfaceConfigArgs',
+    'InstancePscInstanceConfigPscInterfaceConfigArgsDict',
     'InstanceQueryInsightsConfigArgs',
     'InstanceQueryInsightsConfigArgsDict',
     'InstanceReadPoolConfigArgs',
@@ -1446,18 +1448,30 @@ if not MYPY:
         """
         Create an instance that allows connections from Private Service Connect endpoints to the instance.
         """
+        service_owned_project_number: NotRequired[pulumi.Input[int]]
+        """
+        (Output)
+        The project number that needs to be allowlisted on the network attachment to enable outbound connectivity, if the network attachment is configured to ACCEPT_MANUAL connections.
+        In case the network attachment is configured to ACCEPT_AUTOMATIC, this project number does not need to be allowlisted explicitly.
+        """
 elif False:
     ClusterPscConfigArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class ClusterPscConfigArgs:
     def __init__(__self__, *,
-                 psc_enabled: Optional[pulumi.Input[bool]] = None):
+                 psc_enabled: Optional[pulumi.Input[bool]] = None,
+                 service_owned_project_number: Optional[pulumi.Input[int]] = None):
         """
         :param pulumi.Input[bool] psc_enabled: Create an instance that allows connections from Private Service Connect endpoints to the instance.
+        :param pulumi.Input[int] service_owned_project_number: (Output)
+               The project number that needs to be allowlisted on the network attachment to enable outbound connectivity, if the network attachment is configured to ACCEPT_MANUAL connections.
+               In case the network attachment is configured to ACCEPT_AUTOMATIC, this project number does not need to be allowlisted explicitly.
         """
         if psc_enabled is not None:
             pulumi.set(__self__, "psc_enabled", psc_enabled)
+        if service_owned_project_number is not None:
+            pulumi.set(__self__, "service_owned_project_number", service_owned_project_number)
 
     @property
     @pulumi.getter(name="pscEnabled")
@@ -1471,6 +1485,20 @@ class ClusterPscConfigArgs:
     def psc_enabled(self, value: Optional[pulumi.Input[bool]]):
         pulumi.set(self, "psc_enabled", value)
 
+    @property
+    @pulumi.getter(name="serviceOwnedProjectNumber")
+    def service_owned_project_number(self) -> Optional[pulumi.Input[int]]:
+        """
+        (Output)
+        The project number that needs to be allowlisted on the network attachment to enable outbound connectivity, if the network attachment is configured to ACCEPT_MANUAL connections.
+        In case the network attachment is configured to ACCEPT_AUTOMATIC, this project number does not need to be allowlisted explicitly.
+        """
+        return pulumi.get(self, "service_owned_project_number")
+
+    @service_owned_project_number.setter
+    def service_owned_project_number(self, value: Optional[pulumi.Input[int]]):
+        pulumi.set(self, "service_owned_project_number", value)
+
 
 if not MYPY:
     class ClusterRestoreBackupSourceArgsDict(TypedDict):
@@ -2105,6 +2133,12 @@ if not MYPY:
         The DNS name of the instance for PSC connectivity.
         Name convention: <uid>.<uid>.<region>.alloydb-psc.goog
         """
+        psc_interface_configs: NotRequired[pulumi.Input[Sequence[pulumi.Input['InstancePscInstanceConfigPscInterfaceConfigArgsDict']]]]
+        """
+        Configurations for setting up PSC interfaces attached to the instance
+        which are used for outbound connectivity. Currently, AlloyDB supports only 0 or 1 PSC interface.
+        Structure is documented below.
+        """
         service_attachment_link: NotRequired[pulumi.Input[str]]
         """
         (Output)
@@ -2120,6 +2154,7 @@ class InstancePscInstanceConfigArgs:
     def __init__(__self__, *,
                  allowed_consumer_projects: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  psc_dns_name: Optional[pulumi.Input[str]] = None,
+                 psc_interface_configs: Optional[pulumi.Input[Sequence[pulumi.Input['InstancePscInstanceConfigPscInterfaceConfigArgs']]]] = None,
                  service_attachment_link: Optional[pulumi.Input[str]] = None):
         """
         :param pulumi.Input[Sequence[pulumi.Input[str]]] allowed_consumer_projects: List of consumer projects that are allowed to create PSC endpoints to service-attachments to this instance.
@@ -2127,6 +2162,9 @@ class InstancePscInstanceConfigArgs:
         :param pulumi.Input[str] psc_dns_name: (Output)
                The DNS name of the instance for PSC connectivity.
                Name convention: <uid>.<uid>.<region>.alloydb-psc.goog
+        :param pulumi.Input[Sequence[pulumi.Input['InstancePscInstanceConfigPscInterfaceConfigArgs']]] psc_interface_configs: Configurations for setting up PSC interfaces attached to the instance
+               which are used for outbound connectivity. Currently, AlloyDB supports only 0 or 1 PSC interface.
+               Structure is documented below.
         :param pulumi.Input[str] service_attachment_link: (Output)
                The service attachment created when Private Service Connect (PSC) is enabled for the instance.
                The name of the resource will be in the format of
@@ -2136,6 +2174,8 @@ class InstancePscInstanceConfigArgs:
             pulumi.set(__self__, "allowed_consumer_projects", allowed_consumer_projects)
         if psc_dns_name is not None:
             pulumi.set(__self__, "psc_dns_name", psc_dns_name)
+        if psc_interface_configs is not None:
+            pulumi.set(__self__, "psc_interface_configs", psc_interface_configs)
         if service_attachment_link is not None:
             pulumi.set(__self__, "service_attachment_link", service_attachment_link)
 
@@ -2166,6 +2206,20 @@ class InstancePscInstanceConfigArgs:
     def psc_dns_name(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "psc_dns_name", value)
 
+    @property
+    @pulumi.getter(name="pscInterfaceConfigs")
+    def psc_interface_configs(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['InstancePscInstanceConfigPscInterfaceConfigArgs']]]]:
+        """
+        Configurations for setting up PSC interfaces attached to the instance
+        which are used for outbound connectivity. Currently, AlloyDB supports only 0 or 1 PSC interface.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "psc_interface_configs")
+
+    @psc_interface_configs.setter
+    def psc_interface_configs(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['InstancePscInstanceConfigPscInterfaceConfigArgs']]]]):
+        pulumi.set(self, "psc_interface_configs", value)
+
     @property
     @pulumi.getter(name="serviceAttachmentLink")
     def service_attachment_link(self) -> Optional[pulumi.Input[str]]:
@@ -2182,6 +2236,44 @@ class InstancePscInstanceConfigArgs:
         pulumi.set(self, "service_attachment_link", value)
 
 
+if not MYPY:
+    class InstancePscInstanceConfigPscInterfaceConfigArgsDict(TypedDict):
+        network_attachment_resource: NotRequired[pulumi.Input[str]]
+        """
+        The network attachment resource created in the consumer project to which the PSC interface will be linked.
+        This is of the format: "projects/${CONSUMER_PROJECT}/regions/${REGION}/networkAttachments/${NETWORK_ATTACHMENT_NAME}".
+        The network attachment must be in the same region as the instance.
+        """
+elif False:
+    InstancePscInstanceConfigPscInterfaceConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class InstancePscInstanceConfigPscInterfaceConfigArgs:
+    def __init__(__self__, *,
+                 network_attachment_resource: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] network_attachment_resource: The network attachment resource created in the consumer project to which the PSC interface will be linked.
+               This is of the format: "projects/${CONSUMER_PROJECT}/regions/${REGION}/networkAttachments/${NETWORK_ATTACHMENT_NAME}".
+               The network attachment must be in the same region as the instance.
+        """
+        if network_attachment_resource is not None:
+            pulumi.set(__self__, "network_attachment_resource", network_attachment_resource)
+
+    @property
+    @pulumi.getter(name="networkAttachmentResource")
+    def network_attachment_resource(self) -> Optional[pulumi.Input[str]]:
+        """
+        The network attachment resource created in the consumer project to which the PSC interface will be linked.
+        This is of the format: "projects/${CONSUMER_PROJECT}/regions/${REGION}/networkAttachments/${NETWORK_ATTACHMENT_NAME}".
+        The network attachment must be in the same region as the instance.
+        """
+        return pulumi.get(self, "network_attachment_resource")
+
+    @network_attachment_resource.setter
+    def network_attachment_resource(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "network_attachment_resource", value)
+
+
 if not MYPY:
     class InstanceQueryInsightsConfigArgsDict(TypedDict):
         query_plans_per_minute: NotRequired[pulumi.Input[int]]

pulumi_gcp/alloydb/outputs.py

@@ -50,6 +50,7 @@ __all__ = [
     'InstanceNetworkConfigAuthorizedExternalNetwork',
     'InstanceObservabilityConfig',
     'InstancePscInstanceConfig',
+    'InstancePscInstanceConfigPscInterfaceConfig',
     'InstanceQueryInsightsConfig',
     'InstanceReadPoolConfig',
     'GetClusterAutomatedBackupPolicyResult',
@@ -83,6 +84,7 @@ __all__ = [
     'GetInstanceNetworkConfigAuthorizedExternalNetworkResult',
     'GetInstanceObservabilityConfigResult',
     'GetInstancePscInstanceConfigResult',
+    'GetInstancePscInstanceConfigPscInterfaceConfigResult',
     'GetInstanceQueryInsightsConfigResult',
     'GetInstanceReadPoolConfigResult',
     'GetLocationsLocationResult',
@@ -1241,6 +1243,8 @@ class ClusterPscConfig(dict):
         suggest = None
         if key == "pscEnabled":
             suggest = "psc_enabled"
+        elif key == "serviceOwnedProjectNumber":
+            suggest = "service_owned_project_number"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in ClusterPscConfig. Access the value via the '{suggest}' property getter instead.")
@@ -1254,12 +1258,18 @@ class ClusterPscConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 psc_enabled: Optional[bool] = None):
+                 psc_enabled: Optional[bool] = None,
+                 service_owned_project_number: Optional[int] = None):
         """
         :param bool psc_enabled: Create an instance that allows connections from Private Service Connect endpoints to the instance.
+        :param int service_owned_project_number: (Output)
+               The project number that needs to be allowlisted on the network attachment to enable outbound connectivity, if the network attachment is configured to ACCEPT_MANUAL connections.
+               In case the network attachment is configured to ACCEPT_AUTOMATIC, this project number does not need to be allowlisted explicitly.
         """
         if psc_enabled is not None:
             pulumi.set(__self__, "psc_enabled", psc_enabled)
+        if service_owned_project_number is not None:
+            pulumi.set(__self__, "service_owned_project_number", service_owned_project_number)
 
     @property
     @pulumi.getter(name="pscEnabled")
@@ -1269,6 +1279,16 @@ class ClusterPscConfig(dict):
         """
         return pulumi.get(self, "psc_enabled")
 
+    @property
+    @pulumi.getter(name="serviceOwnedProjectNumber")
+    def service_owned_project_number(self) -> Optional[int]:
+        """
+        (Output)
+        The project number that needs to be allowlisted on the network attachment to enable outbound connectivity, if the network attachment is configured to ACCEPT_MANUAL connections.
+        In case the network attachment is configured to ACCEPT_AUTOMATIC, this project number does not need to be allowlisted explicitly.
+        """
+        return pulumi.get(self, "service_owned_project_number")
+
 
 @pulumi.output_type
 class ClusterRestoreBackupSource(dict):
@@ -1843,6 +1863,8 @@ class InstancePscInstanceConfig(dict):
             suggest = "allowed_consumer_projects"
         elif key == "pscDnsName":
             suggest = "psc_dns_name"
+        elif key == "pscInterfaceConfigs":
+            suggest = "psc_interface_configs"
         elif key == "serviceAttachmentLink":
             suggest = "service_attachment_link"
 
@@ -1860,6 +1882,7 @@ class InstancePscInstanceConfig(dict):
     def __init__(__self__, *,
                  allowed_consumer_projects: Optional[Sequence[str]] = None,
                  psc_dns_name: Optional[str] = None,
+                 psc_interface_configs: Optional[Sequence['outputs.InstancePscInstanceConfigPscInterfaceConfig']] = None,
                  service_attachment_link: Optional[str] = None):
         """
         :param Sequence[str] allowed_consumer_projects: List of consumer projects that are allowed to create PSC endpoints to service-attachments to this instance.
@@ -1867,6 +1890,9 @@ class InstancePscInstanceConfig(dict):
         :param str psc_dns_name: (Output)
                The DNS name of the instance for PSC connectivity.
                Name convention: <uid>.<uid>.<region>.alloydb-psc.goog
+        :param Sequence['InstancePscInstanceConfigPscInterfaceConfigArgs'] psc_interface_configs: Configurations for setting up PSC interfaces attached to the instance
+               which are used for outbound connectivity. Currently, AlloyDB supports only 0 or 1 PSC interface.
+               Structure is documented below.
         :param str service_attachment_link: (Output)
                The service attachment created when Private Service Connect (PSC) is enabled for the instance.
                The name of the resource will be in the format of
@@ -1876,6 +1902,8 @@ class InstancePscInstanceConfig(dict):
             pulumi.set(__self__, "allowed_consumer_projects", allowed_consumer_projects)
         if psc_dns_name is not None:
             pulumi.set(__self__, "psc_dns_name", psc_dns_name)
+        if psc_interface_configs is not None:
+            pulumi.set(__self__, "psc_interface_configs", psc_interface_configs)
         if service_attachment_link is not None:
             pulumi.set(__self__, "service_attachment_link", service_attachment_link)
 
@@ -1898,6 +1926,16 @@ class InstancePscInstanceConfig(dict):
         """
         return pulumi.get(self, "psc_dns_name")
 
+    @property
+    @pulumi.getter(name="pscInterfaceConfigs")
+    def psc_interface_configs(self) -> Optional[Sequence['outputs.InstancePscInstanceConfigPscInterfaceConfig']]:
+        """
+        Configurations for setting up PSC interfaces attached to the instance
+        which are used for outbound connectivity. Currently, AlloyDB supports only 0 or 1 PSC interface.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "psc_interface_configs")
+
     @property
     @pulumi.getter(name="serviceAttachmentLink")
     def service_attachment_link(self) -> Optional[str]:
@@ -1910,6 +1948,46 @@ class InstancePscInstanceConfig(dict):
         return pulumi.get(self, "service_attachment_link")
 
 
+@pulumi.output_type
+class InstancePscInstanceConfigPscInterfaceConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "networkAttachmentResource":
+            suggest = "network_attachment_resource"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in InstancePscInstanceConfigPscInterfaceConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        InstancePscInstanceConfigPscInterfaceConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        InstancePscInstanceConfigPscInterfaceConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 network_attachment_resource: Optional[str] = None):
+        """
+        :param str network_attachment_resource: The network attachment resource created in the consumer project to which the PSC interface will be linked.
+               This is of the format: "projects/${CONSUMER_PROJECT}/regions/${REGION}/networkAttachments/${NETWORK_ATTACHMENT_NAME}".
+               The network attachment must be in the same region as the instance.
+        """
+        if network_attachment_resource is not None:
+            pulumi.set(__self__, "network_attachment_resource", network_attachment_resource)
+
+    @property
+    @pulumi.getter(name="networkAttachmentResource")
+    def network_attachment_resource(self) -> Optional[str]:
+        """
+        The network attachment resource created in the consumer project to which the PSC interface will be linked.
+        This is of the format: "projects/${CONSUMER_PROJECT}/regions/${REGION}/networkAttachments/${NETWORK_ATTACHMENT_NAME}".
+        The network attachment must be in the same region as the instance.
+        """
+        return pulumi.get(self, "network_attachment_resource")
+
+
 @pulumi.output_type
 class InstanceQueryInsightsConfig(dict):
     @staticmethod
@@ -2675,11 +2753,15 @@ class GetClusterNetworkConfigResult(dict):
 @pulumi.output_type
 class GetClusterPscConfigResult(dict):
     def __init__(__self__, *,
-                 psc_enabled: bool):
+                 psc_enabled: bool,
+                 service_owned_project_number: int):
         """
         :param bool psc_enabled: Create an instance that allows connections from Private Service Connect endpoints to the instance.
+        :param int service_owned_project_number: The project number that needs to be allowlisted on the network attachment to enable outbound connectivity, if the network attachment is configured to ACCEPT_MANUAL connections.
+               In case the network attachment is configured to ACCEPT_AUTOMATIC, this project number does not need to be allowlisted explicitly.
         """
         pulumi.set(__self__, "psc_enabled", psc_enabled)
+        pulumi.set(__self__, "service_owned_project_number", service_owned_project_number)
 
     @property
     @pulumi.getter(name="pscEnabled")
@@ -2689,6 +2771,15 @@ class GetClusterPscConfigResult(dict):
         """
         return pulumi.get(self, "psc_enabled")
 
+    @property
+    @pulumi.getter(name="serviceOwnedProjectNumber")
+    def service_owned_project_number(self) -> int:
+        """
+        The project number that needs to be allowlisted on the network attachment to enable outbound connectivity, if the network attachment is configured to ACCEPT_MANUAL connections.
+        In case the network attachment is configured to ACCEPT_AUTOMATIC, this project number does not need to be allowlisted explicitly.
+        """
+        return pulumi.get(self, "service_owned_project_number")
+
 
 @pulumi.output_type
 class GetClusterRestoreBackupSourceResult(dict):
@@ -3039,18 +3130,22 @@ class GetInstancePscInstanceConfigResult(dict):
     def __init__(__self__, *,
                  allowed_consumer_projects: Sequence[str],
                  psc_dns_name: str,
+                 psc_interface_configs: Sequence['outputs.GetInstancePscInstanceConfigPscInterfaceConfigResult'],
                  service_attachment_link: str):
         """
         :param Sequence[str] allowed_consumer_projects: List of consumer projects that are allowed to create PSC endpoints to service-attachments to this instance.
                These should be specified as project numbers only.
         :param str psc_dns_name: The DNS name of the instance for PSC connectivity.
                Name convention: <uid>.<uid>.<region>.alloydb-psc.goog
+        :param Sequence['GetInstancePscInstanceConfigPscInterfaceConfigArgs'] psc_interface_configs: Configurations for setting up PSC interfaces attached to the instance
+               which are used for outbound connectivity. Currently, AlloyDB supports only 0 or 1 PSC interface.
         :param str service_attachment_link: The service attachment created when Private Service Connect (PSC) is enabled for the instance.
                The name of the resource will be in the format of
                'projects/<alloydb-tenant-project-number>/regions/<region-name>/serviceAttachments/<service-attachment-name>'
         """
         pulumi.set(__self__, "allowed_consumer_projects", allowed_consumer_projects)
         pulumi.set(__self__, "psc_dns_name", psc_dns_name)
+        pulumi.set(__self__, "psc_interface_configs", psc_interface_configs)
         pulumi.set(__self__, "service_attachment_link", service_attachment_link)
 
     @property
@@ -3071,6 +3166,15 @@ class GetInstancePscInstanceConfigResult(dict):
         """
         return pulumi.get(self, "psc_dns_name")
 
+    @property
+    @pulumi.getter(name="pscInterfaceConfigs")
+    def psc_interface_configs(self) -> Sequence['outputs.GetInstancePscInstanceConfigPscInterfaceConfigResult']:
+        """
+        Configurations for setting up PSC interfaces attached to the instance
+        which are used for outbound connectivity. Currently, AlloyDB supports only 0 or 1 PSC interface.
+        """
+        return pulumi.get(self, "psc_interface_configs")
+
     @property
     @pulumi.getter(name="serviceAttachmentLink")
     def service_attachment_link(self) -> str:
@@ -3082,6 +3186,28 @@ class GetInstancePscInstanceConfigResult(dict):
         return pulumi.get(self, "service_attachment_link")
 
 
+@pulumi.output_type
+class GetInstancePscInstanceConfigPscInterfaceConfigResult(dict):
+    def __init__(__self__, *,
+                 network_attachment_resource: str):
+        """
+        :param str network_attachment_resource: The network attachment resource created in the consumer project to which the PSC interface will be linked.
+               This is of the format: "projects/${CONSUMER_PROJECT}/regions/${REGION}/networkAttachments/${NETWORK_ATTACHMENT_NAME}".
+               The network attachment must be in the same region as the instance.
+        """
+        pulumi.set(__self__, "network_attachment_resource", network_attachment_resource)
+
+    @property
+    @pulumi.getter(name="networkAttachmentResource")
+    def network_attachment_resource(self) -> str:
+        """
+        The network attachment resource created in the consumer project to which the PSC interface will be linked.
+        This is of the format: "projects/${CONSUMER_PROJECT}/regions/${REGION}/networkAttachments/${NETWORK_ATTACHMENT_NAME}".
+        The network attachment must be in the same region as the instance.
+        """
+        return pulumi.get(self, "network_attachment_resource")
+
+
 @pulumi.output_type
 class GetInstanceQueryInsightsConfigResult(dict):
     def __init__(__self__, *,

pulumi_gcp/applicationintegration/client.py

@@ -251,15 +251,12 @@ class Client(pulumi.CustomResource):
         import pulumi_gcp as gcp
         import pulumi_std as std
 
-        test_project = gcp.organizations.get_project()
-        keyring = gcp.kms.KeyRing("keyring",
-            name="my-keyring",
+        default = gcp.organizations.get_project()
+        keyring = gcp.kms.get_kms_key_ring(name="my-keyring",
             location="us-east1")
-        cryptokey = gcp.kms.CryptoKey("cryptokey",
-            name="crypto-key-example",
-            key_ring=keyring.id,
-            rotation_period="7776000s")
-        test_key = gcp.kms.CryptoKeyVersion("test_key", crypto_key=cryptokey.id)
+        cryptokey = gcp.kms.get_kms_crypto_key(name="my-crypto-key",
+            key_ring=keyring.id)
+        test_key = gcp.kms.get_kms_crypto_key_version(crypto_key=cryptokey.id)
         service_account = gcp.serviceaccount.Account("service_account",
             account_id="service-acc",
             display_name="Service Account")
@@ -269,10 +266,10 @@ class Client(pulumi.CustomResource):
             run_as_service_account=service_account.email,
             cloud_kms_config={
                 "kms_location": "us-east1",
-                "kms_ring": std.basename_output(input=keyring.id).apply(lambda invoke: invoke.result),
-                "key": std.basename_output(input=cryptokey.id).apply(lambda invoke: invoke.result),
-                "key_version": std.basename_output(input=test_key.id).apply(lambda invoke: invoke.result),
-                "kms_project_id": test_project.project_id,
+                "kms_ring": std.basename(input=keyring.id).result,
+                "key": std.basename(input=cryptokey.id).result,
+                "key_version": std.basename(input=test_key.id).result,
+                "kms_project_id": default.project_id,
             })
         ```
 
@@ -346,15 +343,12 @@ class Client(pulumi.CustomResource):
         import pulumi_gcp as gcp
         import pulumi_std as std
 
-        test_project = gcp.organizations.get_project()
-        keyring = gcp.kms.KeyRing("keyring",
-            name="my-keyring",
+        default = gcp.organizations.get_project()
+        keyring = gcp.kms.get_kms_key_ring(name="my-keyring",
             location="us-east1")
-        cryptokey = gcp.kms.CryptoKey("cryptokey",
-            name="crypto-key-example",
-            key_ring=keyring.id,
-            rotation_period="7776000s")
-        test_key = gcp.kms.CryptoKeyVersion("test_key", crypto_key=cryptokey.id)
+        cryptokey = gcp.kms.get_kms_crypto_key(name="my-crypto-key",
+            key_ring=keyring.id)
+        test_key = gcp.kms.get_kms_crypto_key_version(crypto_key=cryptokey.id)
         service_account = gcp.serviceaccount.Account("service_account",
             account_id="service-acc",
             display_name="Service Account")
@@ -364,10 +358,10 @@ class Client(pulumi.CustomResource):
             run_as_service_account=service_account.email,
             cloud_kms_config={
                 "kms_location": "us-east1",
-                "kms_ring": std.basename_output(input=keyring.id).apply(lambda invoke: invoke.result),
-                "key": std.basename_output(input=cryptokey.id).apply(lambda invoke: invoke.result),
-                "key_version": std.basename_output(input=test_key.id).apply(lambda invoke: invoke.result),
-                "kms_project_id": test_project.project_id,
+                "kms_ring": std.basename(input=keyring.id).result,
+                "key": std.basename(input=cryptokey.id).result,
+                "key_version": std.basename(input=test_key.id).result,
+                "kms_project_id": default.project_id,
             })
         ```
 

pulumi_gcp/backupdisasterrecovery/_inputs.py

@@ -273,7 +273,7 @@ if not MYPY:
         days_of_weeks: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
         """
         Specifies days of week like MONDAY or TUESDAY, on which jobs will run. This is required for `recurrence_type`, `WEEKLY` and is not applicable otherwise.
-        Each value may be one of: `DAY_OF_WEEK_UNSPECIFIED`, `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`.
+        Each value may be one of: `DAY_OF_WEEK_UNSPECIFIED`, `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, `SUNDAY`.
         """
         hourly_frequency: NotRequired[pulumi.Input[int]]
         """
@@ -313,7 +313,7 @@ class BackupPlanBackupRuleStandardScheduleArgs:
                Structure is documented below.
         :param pulumi.Input[Sequence[pulumi.Input[int]]] days_of_months: Specifies days of months like 1, 5, or 14 on which jobs will run.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] days_of_weeks: Specifies days of week like MONDAY or TUESDAY, on which jobs will run. This is required for `recurrence_type`, `WEEKLY` and is not applicable otherwise.
-               Each value may be one of: `DAY_OF_WEEK_UNSPECIFIED`, `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`.
+               Each value may be one of: `DAY_OF_WEEK_UNSPECIFIED`, `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, `SUNDAY`.
         :param pulumi.Input[int] hourly_frequency: Specifies frequency for hourly backups. An hourly frequency of 2 means jobs will run every 2 hours from start time till end time defined.
                This is required for `recurrence_type`, `HOURLY` and is not applicable otherwise.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] months: Specifies values of months
@@ -392,7 +392,7 @@ class BackupPlanBackupRuleStandardScheduleArgs:
     def days_of_weeks(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
         """
         Specifies days of week like MONDAY or TUESDAY, on which jobs will run. This is required for `recurrence_type`, `WEEKLY` and is not applicable otherwise.
-        Each value may be one of: `DAY_OF_WEEK_UNSPECIFIED`, `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`.
+        Each value may be one of: `DAY_OF_WEEK_UNSPECIFIED`, `MONDAY`, `TUESDAY`, `WEDNESDAY`, `THURSDAY`, `FRIDAY`, `SATURDAY`, `SUNDAY`.
         """
         return pulumi.get(self, "days_of_weeks")