pulumi-gcp 8.7.0a1730183903__py3-none-any.whl → 8.7.0a1730196225__py3-none-any.whl

pulumi_gcp/looker/instance.py

@@ -24,6 +24,7 @@ class InstanceArgs:
                  admin_settings: Optional[pulumi.Input['InstanceAdminSettingsArgs']] = None,
                  consumer_network: Optional[pulumi.Input[str]] = None,
                  custom_domain: Optional[pulumi.Input['InstanceCustomDomainArgs']] = None,
+                 deletion_policy: Optional[pulumi.Input[str]] = None,
                  deny_maintenance_period: Optional[pulumi.Input['InstanceDenyMaintenancePeriodArgs']] = None,
                  encryption_config: Optional[pulumi.Input['InstanceEncryptionConfigArgs']] = None,
                  fips_enabled: Optional[pulumi.Input[bool]] = None,
@@ -48,6 +49,10 @@ class InstanceArgs:
                project that is hosting the Looker Instance.
         :param pulumi.Input['InstanceCustomDomainArgs'] custom_domain: Custom domain settings for a Looker instance.
                Structure is documented below.
+        :param pulumi.Input[str] deletion_policy: Policy to determine if the cluster should be deleted forcefully.
+               If setting deletion_policy = "FORCE", the Looker instance will be deleted regardless
+               of its nested resources. If set to "DEFAULT", Looker instances that still have
+               nested resources will return an error. Possible values: DEFAULT, FORCE
         :param pulumi.Input['InstanceDenyMaintenancePeriodArgs'] deny_maintenance_period: Maintenance denial period for this instance.
                You must allow at least 14 days of maintenance availability
                between any two deny maintenance periods.
@@ -99,6 +104,8 @@ class InstanceArgs:
             pulumi.set(__self__, "consumer_network", consumer_network)
         if custom_domain is not None:
             pulumi.set(__self__, "custom_domain", custom_domain)
+        if deletion_policy is not None:
+            pulumi.set(__self__, "deletion_policy", deletion_policy)
         if deny_maintenance_period is not None:
             pulumi.set(__self__, "deny_maintenance_period", deny_maintenance_period)
         if encryption_config is not None:
@@ -170,6 +177,21 @@ class InstanceArgs:
     def custom_domain(self, value: Optional[pulumi.Input['InstanceCustomDomainArgs']]):
         pulumi.set(self, "custom_domain", value)
 
+    @property
+    @pulumi.getter(name="deletionPolicy")
+    def deletion_policy(self) -> Optional[pulumi.Input[str]]:
+        """
+        Policy to determine if the cluster should be deleted forcefully.
+        If setting deletion_policy = "FORCE", the Looker instance will be deleted regardless
+        of its nested resources. If set to "DEFAULT", Looker instances that still have
+        nested resources will return an error. Possible values: DEFAULT, FORCE
+        """
+        return pulumi.get(self, "deletion_policy")
+
+    @deletion_policy.setter
+    def deletion_policy(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "deletion_policy", value)
+
     @property
     @pulumi.getter(name="denyMaintenancePeriod")
     def deny_maintenance_period(self) -> Optional[pulumi.Input['InstanceDenyMaintenancePeriodArgs']]:
@@ -387,6 +409,7 @@ class _InstanceState:
                  consumer_network: Optional[pulumi.Input[str]] = None,
                  create_time: Optional[pulumi.Input[str]] = None,
                  custom_domain: Optional[pulumi.Input['InstanceCustomDomainArgs']] = None,
+                 deletion_policy: Optional[pulumi.Input[str]] = None,
                  deny_maintenance_period: Optional[pulumi.Input['InstanceDenyMaintenancePeriodArgs']] = None,
                  egress_public_ip: Optional[pulumi.Input[str]] = None,
                  encryption_config: Optional[pulumi.Input['InstanceEncryptionConfigArgs']] = None,
@@ -419,6 +442,10 @@ class _InstanceState:
                accurate to nanoseconds.
         :param pulumi.Input['InstanceCustomDomainArgs'] custom_domain: Custom domain settings for a Looker instance.
                Structure is documented below.
+        :param pulumi.Input[str] deletion_policy: Policy to determine if the cluster should be deleted forcefully.
+               If setting deletion_policy = "FORCE", the Looker instance will be deleted regardless
+               of its nested resources. If set to "DEFAULT", Looker instances that still have
+               nested resources will return an error. Possible values: DEFAULT, FORCE
         :param pulumi.Input['InstanceDenyMaintenancePeriodArgs'] deny_maintenance_period: Maintenance denial period for this instance.
                You must allow at least 14 days of maintenance availability
                between any two deny maintenance periods.
@@ -479,6 +506,8 @@ class _InstanceState:
             pulumi.set(__self__, "create_time", create_time)
         if custom_domain is not None:
             pulumi.set(__self__, "custom_domain", custom_domain)
+        if deletion_policy is not None:
+            pulumi.set(__self__, "deletion_policy", deletion_policy)
         if deny_maintenance_period is not None:
             pulumi.set(__self__, "deny_maintenance_period", deny_maintenance_period)
         if egress_public_ip is not None:
@@ -575,6 +604,21 @@ class _InstanceState:
     def custom_domain(self, value: Optional[pulumi.Input['InstanceCustomDomainArgs']]):
         pulumi.set(self, "custom_domain", value)
 
+    @property
+    @pulumi.getter(name="deletionPolicy")
+    def deletion_policy(self) -> Optional[pulumi.Input[str]]:
+        """
+        Policy to determine if the cluster should be deleted forcefully.
+        If setting deletion_policy = "FORCE", the Looker instance will be deleted regardless
+        of its nested resources. If set to "DEFAULT", Looker instances that still have
+        nested resources will return an error. Possible values: DEFAULT, FORCE
+        """
+        return pulumi.get(self, "deletion_policy")
+
+    @deletion_policy.setter
+    def deletion_policy(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "deletion_policy", value)
+
     @property
     @pulumi.getter(name="denyMaintenancePeriod")
     def deny_maintenance_period(self) -> Optional[pulumi.Input['InstanceDenyMaintenancePeriodArgs']]:
@@ -866,6 +910,7 @@ class Instance(pulumi.CustomResource):
                  admin_settings: Optional[pulumi.Input[Union['InstanceAdminSettingsArgs', 'InstanceAdminSettingsArgsDict']]] = None,
                  consumer_network: Optional[pulumi.Input[str]] = None,
                  custom_domain: Optional[pulumi.Input[Union['InstanceCustomDomainArgs', 'InstanceCustomDomainArgsDict']]] = None,
+                 deletion_policy: Optional[pulumi.Input[str]] = None,
                  deny_maintenance_period: Optional[pulumi.Input[Union['InstanceDenyMaintenancePeriodArgs', 'InstanceDenyMaintenancePeriodArgsDict']]] = None,
                  encryption_config: Optional[pulumi.Input[Union['InstanceEncryptionConfigArgs', 'InstanceEncryptionConfigArgsDict']]] = None,
                  fips_enabled: Optional[pulumi.Input[bool]] = None,
@@ -907,7 +952,8 @@ class Instance(pulumi.CustomResource):
             oauth_config={
                 "client_id": "my-client-id",
                 "client_secret": "my-client-secret",
-            })
+            },
+            deletion_policy="DEFAULT")
         ```
         ### Looker Instance Full
 
@@ -1080,6 +1126,22 @@ class Instance(pulumi.CustomResource):
                 "allowed_vpcs": ["projects/test-project/global/networks/test"],
             })
         ```
+        ### Looker Instance Force Delete
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        looker_instance = gcp.looker.Instance("looker-instance",
+            name="my-instance",
+            platform_edition="LOOKER_CORE_STANDARD_ANNUAL",
+            region="us-central1",
+            oauth_config={
+                "client_id": "my-client-id",
+                "client_secret": "my-client-secret",
+            },
+            deletion_policy="FORCE")
+        ```
 
         ## Import
 
@@ -1120,6 +1182,10 @@ class Instance(pulumi.CustomResource):
                project that is hosting the Looker Instance.
         :param pulumi.Input[Union['InstanceCustomDomainArgs', 'InstanceCustomDomainArgsDict']] custom_domain: Custom domain settings for a Looker instance.
                Structure is documented below.
+        :param pulumi.Input[str] deletion_policy: Policy to determine if the cluster should be deleted forcefully.
+               If setting deletion_policy = "FORCE", the Looker instance will be deleted regardless
+               of its nested resources. If set to "DEFAULT", Looker instances that still have
+               nested resources will return an error. Possible values: DEFAULT, FORCE
         :param pulumi.Input[Union['InstanceDenyMaintenancePeriodArgs', 'InstanceDenyMaintenancePeriodArgsDict']] deny_maintenance_period: Maintenance denial period for this instance.
                You must allow at least 14 days of maintenance availability
                between any two deny maintenance periods.
@@ -1196,7 +1262,8 @@ class Instance(pulumi.CustomResource):
             oauth_config={
                 "client_id": "my-client-id",
                 "client_secret": "my-client-secret",
-            })
+            },
+            deletion_policy="DEFAULT")
         ```
         ### Looker Instance Full
 
@@ -1369,6 +1436,22 @@ class Instance(pulumi.CustomResource):
                 "allowed_vpcs": ["projects/test-project/global/networks/test"],
             })
         ```
+        ### Looker Instance Force Delete
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        looker_instance = gcp.looker.Instance("looker-instance",
+            name="my-instance",
+            platform_edition="LOOKER_CORE_STANDARD_ANNUAL",
+            region="us-central1",
+            oauth_config={
+                "client_id": "my-client-id",
+                "client_secret": "my-client-secret",
+            },
+            deletion_policy="FORCE")
+        ```
 
         ## Import
 
@@ -1418,6 +1501,7 @@ class Instance(pulumi.CustomResource):
                  admin_settings: Optional[pulumi.Input[Union['InstanceAdminSettingsArgs', 'InstanceAdminSettingsArgsDict']]] = None,
                  consumer_network: Optional[pulumi.Input[str]] = None,
                  custom_domain: Optional[pulumi.Input[Union['InstanceCustomDomainArgs', 'InstanceCustomDomainArgsDict']]] = None,
+                 deletion_policy: Optional[pulumi.Input[str]] = None,
                  deny_maintenance_period: Optional[pulumi.Input[Union['InstanceDenyMaintenancePeriodArgs', 'InstanceDenyMaintenancePeriodArgsDict']]] = None,
                  encryption_config: Optional[pulumi.Input[Union['InstanceEncryptionConfigArgs', 'InstanceEncryptionConfigArgsDict']]] = None,
                  fips_enabled: Optional[pulumi.Input[bool]] = None,
@@ -1445,6 +1529,7 @@ class Instance(pulumi.CustomResource):
             __props__.__dict__["admin_settings"] = admin_settings
             __props__.__dict__["consumer_network"] = consumer_network
             __props__.__dict__["custom_domain"] = custom_domain
+            __props__.__dict__["deletion_policy"] = deletion_policy
             __props__.__dict__["deny_maintenance_period"] = deny_maintenance_period
             __props__.__dict__["encryption_config"] = encryption_config
             __props__.__dict__["fips_enabled"] = fips_enabled
@@ -1481,6 +1566,7 @@ class Instance(pulumi.CustomResource):
             consumer_network: Optional[pulumi.Input[str]] = None,
             create_time: Optional[pulumi.Input[str]] = None,
             custom_domain: Optional[pulumi.Input[Union['InstanceCustomDomainArgs', 'InstanceCustomDomainArgsDict']]] = None,
+            deletion_policy: Optional[pulumi.Input[str]] = None,
             deny_maintenance_period: Optional[pulumi.Input[Union['InstanceDenyMaintenancePeriodArgs', 'InstanceDenyMaintenancePeriodArgsDict']]] = None,
             egress_public_ip: Optional[pulumi.Input[str]] = None,
             encryption_config: Optional[pulumi.Input[Union['InstanceEncryptionConfigArgs', 'InstanceEncryptionConfigArgsDict']]] = None,
@@ -1518,6 +1604,10 @@ class Instance(pulumi.CustomResource):
                accurate to nanoseconds.
         :param pulumi.Input[Union['InstanceCustomDomainArgs', 'InstanceCustomDomainArgsDict']] custom_domain: Custom domain settings for a Looker instance.
                Structure is documented below.
+        :param pulumi.Input[str] deletion_policy: Policy to determine if the cluster should be deleted forcefully.
+               If setting deletion_policy = "FORCE", the Looker instance will be deleted regardless
+               of its nested resources. If set to "DEFAULT", Looker instances that still have
+               nested resources will return an error. Possible values: DEFAULT, FORCE
         :param pulumi.Input[Union['InstanceDenyMaintenancePeriodArgs', 'InstanceDenyMaintenancePeriodArgsDict']] deny_maintenance_period: Maintenance denial period for this instance.
                You must allow at least 14 days of maintenance availability
                between any two deny maintenance periods.
@@ -1578,6 +1668,7 @@ class Instance(pulumi.CustomResource):
         __props__.__dict__["consumer_network"] = consumer_network
         __props__.__dict__["create_time"] = create_time
         __props__.__dict__["custom_domain"] = custom_domain
+        __props__.__dict__["deletion_policy"] = deletion_policy
         __props__.__dict__["deny_maintenance_period"] = deny_maintenance_period
         __props__.__dict__["egress_public_ip"] = egress_public_ip
         __props__.__dict__["encryption_config"] = encryption_config
@@ -1638,6 +1729,17 @@ class Instance(pulumi.CustomResource):
         """
         return pulumi.get(self, "custom_domain")
 
+    @property
+    @pulumi.getter(name="deletionPolicy")
+    def deletion_policy(self) -> pulumi.Output[Optional[str]]:
+        """
+        Policy to determine if the cluster should be deleted forcefully.
+        If setting deletion_policy = "FORCE", the Looker instance will be deleted regardless
+        of its nested resources. If set to "DEFAULT", Looker instances that still have
+        nested resources will return an error. Possible values: DEFAULT, FORCE
+        """
+        return pulumi.get(self, "deletion_policy")
+
     @property
     @pulumi.getter(name="denyMaintenancePeriod")
     def deny_maintenance_period(self) -> pulumi.Output[Optional['outputs.InstanceDenyMaintenancePeriod']]:

pulumi_gcp/monitoring/_inputs.py

@@ -147,6 +147,11 @@ if not MYPY:
         are notified when this alert fires, on a per-channel basis.
         Structure is documented below.
         """
+        notification_prompts: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        Control when notifications will be sent out.
+        Each value may be one of: `NOTIFICATION_PROMPT_UNSPECIFIED`, `OPENED`, `CLOSED`.
+        """
         notification_rate_limit: NotRequired[pulumi.Input['AlertPolicyAlertStrategyNotificationRateLimitArgsDict']]
         """
         Required for alert policies with a LogMatch condition.
@@ -161,12 +166,15 @@ class AlertPolicyAlertStrategyArgs:
     def __init__(__self__, *,
                  auto_close: Optional[pulumi.Input[str]] = None,
                  notification_channel_strategies: Optional[pulumi.Input[Sequence[pulumi.Input['AlertPolicyAlertStrategyNotificationChannelStrategyArgs']]]] = None,
+                 notification_prompts: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  notification_rate_limit: Optional[pulumi.Input['AlertPolicyAlertStrategyNotificationRateLimitArgs']] = None):
         """
         :param pulumi.Input[str] auto_close: If an alert policy that was active has no data for this long, any open incidents will close.
         :param pulumi.Input[Sequence[pulumi.Input['AlertPolicyAlertStrategyNotificationChannelStrategyArgs']]] notification_channel_strategies: Control over how the notification channels in `notification_channels`
                are notified when this alert fires, on a per-channel basis.
                Structure is documented below.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] notification_prompts: Control when notifications will be sent out.
+               Each value may be one of: `NOTIFICATION_PROMPT_UNSPECIFIED`, `OPENED`, `CLOSED`.
         :param pulumi.Input['AlertPolicyAlertStrategyNotificationRateLimitArgs'] notification_rate_limit: Required for alert policies with a LogMatch condition.
                This limit is not implemented for alert policies that are not log-based.
                Structure is documented below.
@@ -175,6 +183,8 @@ class AlertPolicyAlertStrategyArgs:
             pulumi.set(__self__, "auto_close", auto_close)
         if notification_channel_strategies is not None:
             pulumi.set(__self__, "notification_channel_strategies", notification_channel_strategies)
+        if notification_prompts is not None:
+            pulumi.set(__self__, "notification_prompts", notification_prompts)
         if notification_rate_limit is not None:
             pulumi.set(__self__, "notification_rate_limit", notification_rate_limit)
 
@@ -204,6 +214,19 @@ class AlertPolicyAlertStrategyArgs:
     def notification_channel_strategies(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AlertPolicyAlertStrategyNotificationChannelStrategyArgs']]]]):
         pulumi.set(self, "notification_channel_strategies", value)
 
+    @property
+    @pulumi.getter(name="notificationPrompts")
+    def notification_prompts(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        Control when notifications will be sent out.
+        Each value may be one of: `NOTIFICATION_PROMPT_UNSPECIFIED`, `OPENED`, `CLOSED`.
+        """
+        return pulumi.get(self, "notification_prompts")
+
+    @notification_prompts.setter
+    def notification_prompts(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "notification_prompts", value)
+
     @property
     @pulumi.getter(name="notificationRateLimit")
     def notification_rate_limit(self) -> Optional[pulumi.Input['AlertPolicyAlertStrategyNotificationRateLimitArgs']]:

pulumi_gcp/monitoring/get_secret_version.py

@@ -28,7 +28,7 @@ class GetSecretVersionResult:
     """
     A collection of values returned by getSecretVersion.
     """
-    def __init__(__self__, create_time=None, destroy_time=None, enabled=None, id=None, name=None, project=None, secret=None, secret_data=None, version=None):
+    def __init__(__self__, create_time=None, destroy_time=None, enabled=None, id=None, is_secret_data_base64=None, name=None, project=None, secret=None, secret_data=None, version=None):
         if create_time and not isinstance(create_time, str):
             raise TypeError("Expected argument 'create_time' to be a str")
         pulumi.set(__self__, "create_time", create_time)
@@ -41,6 +41,9 @@ class GetSecretVersionResult:
         if id and not isinstance(id, str):
             raise TypeError("Expected argument 'id' to be a str")
         pulumi.set(__self__, "id", id)
+        if is_secret_data_base64 and not isinstance(is_secret_data_base64, bool):
+            raise TypeError("Expected argument 'is_secret_data_base64' to be a bool")
+        pulumi.set(__self__, "is_secret_data_base64", is_secret_data_base64)
         if name and not isinstance(name, str):
             raise TypeError("Expected argument 'name' to be a str")
         pulumi.set(__self__, "name", name)
@@ -89,6 +92,11 @@ class GetSecretVersionResult:
         """
         return pulumi.get(self, "id")
 
+    @property
+    @pulumi.getter(name="isSecretDataBase64")
+    def is_secret_data_base64(self) -> Optional[bool]:
+        return pulumi.get(self, "is_secret_data_base64")
+
     @property
     @pulumi.getter
     def name(self) -> str:
@@ -132,6 +140,7 @@ class AwaitableGetSecretVersionResult(GetSecretVersionResult):
             destroy_time=self.destroy_time,
             enabled=self.enabled,
             id=self.id,
+            is_secret_data_base64=self.is_secret_data_base64,
             name=self.name,
             project=self.project,
             secret=self.secret,
@@ -139,7 +148,8 @@ class AwaitableGetSecretVersionResult(GetSecretVersionResult):
             version=self.version)
 
 
-def get_secret_version(project: Optional[str] = None,
+def get_secret_version(is_secret_data_base64: Optional[bool] = None,
+                       project: Optional[str] = None,
                        secret: Optional[str] = None,
                        version: Optional[str] = None,
                        opts: Optional[pulumi.InvokeOptions] = None) -> AwaitableGetSecretVersionResult:
@@ -156,6 +166,8 @@ def get_secret_version(project: Optional[str] = None,
     ```
 
 
+    :param bool is_secret_data_base64: If set to 'true', the secret data is
+           expected to be base64-encoded string.
     :param str project: The project to get the secret version for. If it
            is not provided, the provider project is used.
     :param str secret: The secret to get the secret version for.
@@ -164,6 +176,7 @@ def get_secret_version(project: Optional[str] = None,
     """
     pulumi.log.warn("""get_secret_version is deprecated: gcp.monitoring.getSecretVersion has been deprecated in favor of gcp.secretmanager.getSecretVersion""")
     __args__ = dict()
+    __args__['isSecretDataBase64'] = is_secret_data_base64
     __args__['project'] = project
     __args__['secret'] = secret
     __args__['version'] = version
@@ -175,12 +188,14 @@ def get_secret_version(project: Optional[str] = None,
         destroy_time=pulumi.get(__ret__, 'destroy_time'),
         enabled=pulumi.get(__ret__, 'enabled'),
         id=pulumi.get(__ret__, 'id'),
+        is_secret_data_base64=pulumi.get(__ret__, 'is_secret_data_base64'),
         name=pulumi.get(__ret__, 'name'),
         project=pulumi.get(__ret__, 'project'),
         secret=pulumi.get(__ret__, 'secret'),
         secret_data=pulumi.get(__ret__, 'secret_data'),
         version=pulumi.get(__ret__, 'version'))
-def get_secret_version_output(project: Optional[pulumi.Input[Optional[str]]] = None,
+def get_secret_version_output(is_secret_data_base64: Optional[pulumi.Input[Optional[bool]]] = None,
+                              project: Optional[pulumi.Input[Optional[str]]] = None,
                               secret: Optional[pulumi.Input[str]] = None,
                               version: Optional[pulumi.Input[Optional[str]]] = None,
                               opts: Optional[pulumi.InvokeOptions] = None) -> pulumi.Output[GetSecretVersionResult]:
@@ -197,6 +212,8 @@ def get_secret_version_output(project: Optional[pulumi.Input[Optional[str]]] = N
     ```
 
 
+    :param bool is_secret_data_base64: If set to 'true', the secret data is
+           expected to be base64-encoded string.
     :param str project: The project to get the secret version for. If it
            is not provided, the provider project is used.
     :param str secret: The secret to get the secret version for.
@@ -205,6 +222,7 @@ def get_secret_version_output(project: Optional[pulumi.Input[Optional[str]]] = N
     """
     pulumi.log.warn("""get_secret_version is deprecated: gcp.monitoring.getSecretVersion has been deprecated in favor of gcp.secretmanager.getSecretVersion""")
     __args__ = dict()
+    __args__['isSecretDataBase64'] = is_secret_data_base64
     __args__['project'] = project
     __args__['secret'] = secret
     __args__['version'] = version
@@ -215,6 +233,7 @@ def get_secret_version_output(project: Optional[pulumi.Input[Optional[str]]] = N
         destroy_time=pulumi.get(__response__, 'destroy_time'),
         enabled=pulumi.get(__response__, 'enabled'),
         id=pulumi.get(__response__, 'id'),
+        is_secret_data_base64=pulumi.get(__response__, 'is_secret_data_base64'),
         name=pulumi.get(__response__, 'name'),
         project=pulumi.get(__response__, 'project'),
         secret=pulumi.get(__response__, 'secret'),

pulumi_gcp/monitoring/outputs.py

@@ -91,6 +91,8 @@ class AlertPolicyAlertStrategy(dict):
             suggest = "auto_close"
         elif key == "notificationChannelStrategies":
             suggest = "notification_channel_strategies"
+        elif key == "notificationPrompts":
+            suggest = "notification_prompts"
         elif key == "notificationRateLimit":
             suggest = "notification_rate_limit"
 
@@ -108,12 +110,15 @@ class AlertPolicyAlertStrategy(dict):
     def __init__(__self__, *,
                  auto_close: Optional[str] = None,
                  notification_channel_strategies: Optional[Sequence['outputs.AlertPolicyAlertStrategyNotificationChannelStrategy']] = None,
+                 notification_prompts: Optional[Sequence[str]] = None,
                  notification_rate_limit: Optional['outputs.AlertPolicyAlertStrategyNotificationRateLimit'] = None):
         """
         :param str auto_close: If an alert policy that was active has no data for this long, any open incidents will close.
         :param Sequence['AlertPolicyAlertStrategyNotificationChannelStrategyArgs'] notification_channel_strategies: Control over how the notification channels in `notification_channels`
                are notified when this alert fires, on a per-channel basis.
                Structure is documented below.
+        :param Sequence[str] notification_prompts: Control when notifications will be sent out.
+               Each value may be one of: `NOTIFICATION_PROMPT_UNSPECIFIED`, `OPENED`, `CLOSED`.
         :param 'AlertPolicyAlertStrategyNotificationRateLimitArgs' notification_rate_limit: Required for alert policies with a LogMatch condition.
                This limit is not implemented for alert policies that are not log-based.
                Structure is documented below.
@@ -122,6 +127,8 @@ class AlertPolicyAlertStrategy(dict):
             pulumi.set(__self__, "auto_close", auto_close)
         if notification_channel_strategies is not None:
             pulumi.set(__self__, "notification_channel_strategies", notification_channel_strategies)
+        if notification_prompts is not None:
+            pulumi.set(__self__, "notification_prompts", notification_prompts)
         if notification_rate_limit is not None:
             pulumi.set(__self__, "notification_rate_limit", notification_rate_limit)
 
@@ -143,6 +150,15 @@ class AlertPolicyAlertStrategy(dict):
         """
         return pulumi.get(self, "notification_channel_strategies")
 
+    @property
+    @pulumi.getter(name="notificationPrompts")
+    def notification_prompts(self) -> Optional[Sequence[str]]:
+        """
+        Control when notifications will be sent out.
+        Each value may be one of: `NOTIFICATION_PROMPT_UNSPECIFIED`, `OPENED`, `CLOSED`.
+        """
+        return pulumi.get(self, "notification_prompts")
+
     @property
     @pulumi.getter(name="notificationRateLimit")
     def notification_rate_limit(self) -> Optional['outputs.AlertPolicyAlertStrategyNotificationRateLimit']:

pulumi_gcp/networkconnectivity/__init__.py

@@ -5,6 +5,7 @@
 from .. import _utilities
 import typing
 # Export this package's modules as members:
+from .group import *
 from .hub import *
 from .internal_range import *
 from .policy_based_route import *

pulumi_gcp/networkconnectivity/_inputs.py

@@ -15,6 +15,8 @@ else:
 from .. import _utilities
 
 __all__ = [
+    'GroupAutoAcceptArgs',
+    'GroupAutoAcceptArgsDict',
     'HubRoutingVpcArgs',
     'HubRoutingVpcArgsDict',
     'InternalRangeMigrationArgs',
@@ -37,6 +39,8 @@ __all__ = [
     'ServiceConnectionPolicyPscConnectionErrorInfoArgsDict',
     'SpokeLinkedInterconnectAttachmentsArgs',
     'SpokeLinkedInterconnectAttachmentsArgsDict',
+    'SpokeLinkedProducerVpcNetworkArgs',
+    'SpokeLinkedProducerVpcNetworkArgsDict',
     'SpokeLinkedRouterApplianceInstancesArgs',
     'SpokeLinkedRouterApplianceInstancesArgsDict',
     'SpokeLinkedRouterApplianceInstancesInstanceArgs',
@@ -49,6 +53,37 @@ __all__ = [
 
 MYPY = False
 
+if not MYPY:
+    class GroupAutoAcceptArgsDict(TypedDict):
+        auto_accept_projects: pulumi.Input[Sequence[pulumi.Input[str]]]
+        """
+        A list of project ids or project numbers for which you want to enable auto-accept. The auto-accept setting is applied to spokes being created or updated in these projects.
+        """
+elif False:
+    GroupAutoAcceptArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class GroupAutoAcceptArgs:
+    def __init__(__self__, *,
+                 auto_accept_projects: pulumi.Input[Sequence[pulumi.Input[str]]]):
+        """
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] auto_accept_projects: A list of project ids or project numbers for which you want to enable auto-accept. The auto-accept setting is applied to spokes being created or updated in these projects.
+        """
+        pulumi.set(__self__, "auto_accept_projects", auto_accept_projects)
+
+    @property
+    @pulumi.getter(name="autoAcceptProjects")
+    def auto_accept_projects(self) -> pulumi.Input[Sequence[pulumi.Input[str]]]:
+        """
+        A list of project ids or project numbers for which you want to enable auto-accept. The auto-accept setting is applied to spokes being created or updated in these projects.
+        """
+        return pulumi.get(self, "auto_accept_projects")
+
+    @auto_accept_projects.setter
+    def auto_accept_projects(self, value: pulumi.Input[Sequence[pulumi.Input[str]]]):
+        pulumi.set(self, "auto_accept_projects", value)
+
+
 if not MYPY:
     class HubRoutingVpcArgsDict(TypedDict):
         uri: NotRequired[pulumi.Input[str]]
@@ -870,6 +905,119 @@ class SpokeLinkedInterconnectAttachmentsArgs:
         pulumi.set(self, "include_import_ranges", value)
 
 
+if not MYPY:
+    class SpokeLinkedProducerVpcNetworkArgsDict(TypedDict):
+        network: pulumi.Input[str]
+        """
+        The URI of the Service Consumer VPC that the Producer VPC is peered with.
+        """
+        peering: pulumi.Input[str]
+        """
+        The name of the VPC peering between the Service Consumer VPC and the Producer VPC (defined in the Tenant project) which is added to the NCC hub. This peering must be in ACTIVE state.
+        """
+        exclude_export_ranges: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        IP ranges encompassing the subnets to be excluded from peering.
+        """
+        include_export_ranges: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        IP ranges allowed to be included from peering.
+        """
+        producer_network: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        The URI of the Producer VPC.
+        """
+elif False:
+    SpokeLinkedProducerVpcNetworkArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SpokeLinkedProducerVpcNetworkArgs:
+    def __init__(__self__, *,
+                 network: pulumi.Input[str],
+                 peering: pulumi.Input[str],
+                 exclude_export_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 include_export_ranges: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
+                 producer_network: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] network: The URI of the Service Consumer VPC that the Producer VPC is peered with.
+        :param pulumi.Input[str] peering: The name of the VPC peering between the Service Consumer VPC and the Producer VPC (defined in the Tenant project) which is added to the NCC hub. This peering must be in ACTIVE state.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] exclude_export_ranges: IP ranges encompassing the subnets to be excluded from peering.
+        :param pulumi.Input[Sequence[pulumi.Input[str]]] include_export_ranges: IP ranges allowed to be included from peering.
+        :param pulumi.Input[str] producer_network: (Output)
+               The URI of the Producer VPC.
+        """
+        pulumi.set(__self__, "network", network)
+        pulumi.set(__self__, "peering", peering)
+        if exclude_export_ranges is not None:
+            pulumi.set(__self__, "exclude_export_ranges", exclude_export_ranges)
+        if include_export_ranges is not None:
+            pulumi.set(__self__, "include_export_ranges", include_export_ranges)
+        if producer_network is not None:
+            pulumi.set(__self__, "producer_network", producer_network)
+
+    @property
+    @pulumi.getter
+    def network(self) -> pulumi.Input[str]:
+        """
+        The URI of the Service Consumer VPC that the Producer VPC is peered with.
+        """
+        return pulumi.get(self, "network")
+
+    @network.setter
+    def network(self, value: pulumi.Input[str]):
+        pulumi.set(self, "network", value)
+
+    @property
+    @pulumi.getter
+    def peering(self) -> pulumi.Input[str]:
+        """
+        The name of the VPC peering between the Service Consumer VPC and the Producer VPC (defined in the Tenant project) which is added to the NCC hub. This peering must be in ACTIVE state.
+        """
+        return pulumi.get(self, "peering")
+
+    @peering.setter
+    def peering(self, value: pulumi.Input[str]):
+        pulumi.set(self, "peering", value)
+
+    @property
+    @pulumi.getter(name="excludeExportRanges")
+    def exclude_export_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        IP ranges encompassing the subnets to be excluded from peering.
+        """
+        return pulumi.get(self, "exclude_export_ranges")
+
+    @exclude_export_ranges.setter
+    def exclude_export_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "exclude_export_ranges", value)
+
+    @property
+    @pulumi.getter(name="includeExportRanges")
+    def include_export_ranges(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
+        """
+        IP ranges allowed to be included from peering.
+        """
+        return pulumi.get(self, "include_export_ranges")
+
+    @include_export_ranges.setter
+    def include_export_ranges(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]):
+        pulumi.set(self, "include_export_ranges", value)
+
+    @property
+    @pulumi.getter(name="producerNetwork")
+    def producer_network(self) -> Optional[pulumi.Input[str]]:
+        """
+        (Output)
+        The URI of the Producer VPC.
+        """
+        return pulumi.get(self, "producer_network")
+
+    @producer_network.setter
+    def producer_network(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "producer_network", value)
+
+
 if not MYPY:
     class SpokeLinkedRouterApplianceInstancesArgsDict(TypedDict):
         instances: pulumi.Input[Sequence[pulumi.Input['SpokeLinkedRouterApplianceInstancesInstanceArgsDict']]]