pulumi-gcp 8.7.0a1730183903__py3-none-any.whl → 8.8.0__py3-none-any.whl

pulumi_gcp/memorystore/instance.py

@@ -30,6 +30,7 @@ class InstanceArgs:
                  engine_configs: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  engine_version: Optional[pulumi.Input[str]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 mode: Optional[pulumi.Input[str]] = None,
                  node_type: Optional[pulumi.Input[str]] = None,
                  persistence_config: Optional[pulumi.Input['InstancePersistenceConfigArgs']] = None,
                  project: Optional[pulumi.Input[str]] = None,
@@ -61,6 +62,11 @@ class InstanceArgs:
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] labels: Optional. Labels to represent user-provided metadata.
                **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
                Please refer to the field `effective_labels` for all of the labels present on the resource.
+        :param pulumi.Input[str] mode: Optional. Standalone or cluster.
+               Possible values:
+               CLUSTER
+               STANDALONE
+               Possible values are: `CLUSTER`, `STANDALONE`.
         :param pulumi.Input[str] node_type: Optional. Immutable. Machine type for individual nodes of the instance.
                Possible values:
                SHARED_CORE_NANO
@@ -93,6 +99,8 @@ class InstanceArgs:
             pulumi.set(__self__, "engine_version", engine_version)
         if labels is not None:
             pulumi.set(__self__, "labels", labels)
+        if mode is not None:
+            pulumi.set(__self__, "mode", mode)
         if node_type is not None:
             pulumi.set(__self__, "node_type", node_type)
         if persistence_config is not None:
@@ -228,6 +236,22 @@ class InstanceArgs:
     def labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "labels", value)
 
+    @property
+    @pulumi.getter
+    def mode(self) -> Optional[pulumi.Input[str]]:
+        """
+        Optional. Standalone or cluster.
+        Possible values:
+        CLUSTER
+        STANDALONE
+        Possible values are: `CLUSTER`, `STANDALONE`.
+        """
+        return pulumi.get(self, "mode")
+
+    @mode.setter
+    def mode(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "mode", value)
+
     @property
     @pulumi.getter(name="nodeType")
     def node_type(self) -> Optional[pulumi.Input[str]]:
@@ -321,11 +345,13 @@ class _InstanceState:
                  desired_psc_auto_connections: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceDesiredPscAutoConnectionArgs']]]] = None,
                  discovery_endpoints: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceDiscoveryEndpointArgs']]]] = None,
                  effective_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+                 endpoints: Optional[pulumi.Input[Sequence[pulumi.Input[Sequence[Any]]]]] = None,
                  engine_configs: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  engine_version: Optional[pulumi.Input[str]] = None,
                  instance_id: Optional[pulumi.Input[str]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  location: Optional[pulumi.Input[str]] = None,
+                 mode: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  node_configs: Optional[pulumi.Input[Sequence[pulumi.Input['InstanceNodeConfigArgs']]]] = None,
                  node_type: Optional[pulumi.Input[str]] = None,
@@ -353,6 +379,7 @@ class _InstanceState:
                discovery endpoint is supported.
                Structure is documented below.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] effective_labels: All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
+        :param pulumi.Input[Sequence[pulumi.Input[Sequence[Any]]]] endpoints: Endpoints for the instance.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] engine_configs: Optional. User-provided engine configurations for the instance.
         :param pulumi.Input[str] engine_version: Optional. Immutable. Engine version of the instance.
         :param pulumi.Input[str] instance_id: Required. The ID to use for the instance, which will become the final component of
@@ -370,6 +397,11 @@ class _InstanceState:
                **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
                Please refer to the field `effective_labels` for all of the labels present on the resource.
         :param pulumi.Input[str] location: Resource ID segment making up resource `name`. It identifies the resource within its parent collection as described in https://google.aip.dev/122. See documentation for resource type `memorystore.googleapis.com/CertificateAuthority`.
+        :param pulumi.Input[str] mode: Optional. Standalone or cluster.
+               Possible values:
+               CLUSTER
+               STANDALONE
+               Possible values are: `CLUSTER`, `STANDALONE`.
         :param pulumi.Input[str] name: Identifier. Unique name of the instance.
                Format: projects/{project}/locations/{location}/instances/{instance}
         :param pulumi.Input[Sequence[pulumi.Input['InstanceNodeConfigArgs']]] node_configs: Represents configuration for nodes of the instance.
@@ -419,6 +451,8 @@ class _InstanceState:
             pulumi.set(__self__, "discovery_endpoints", discovery_endpoints)
         if effective_labels is not None:
             pulumi.set(__self__, "effective_labels", effective_labels)
+        if endpoints is not None:
+            pulumi.set(__self__, "endpoints", endpoints)
         if engine_configs is not None:
             pulumi.set(__self__, "engine_configs", engine_configs)
         if engine_version is not None:
@@ -429,6 +463,8 @@ class _InstanceState:
             pulumi.set(__self__, "labels", labels)
         if location is not None:
             pulumi.set(__self__, "location", location)
+        if mode is not None:
+            pulumi.set(__self__, "mode", mode)
         if name is not None:
             pulumi.set(__self__, "name", name)
         if node_configs is not None:
@@ -536,6 +572,18 @@ class _InstanceState:
     def effective_labels(self, value: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]):
         pulumi.set(self, "effective_labels", value)
 
+    @property
+    @pulumi.getter
+    def endpoints(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[Sequence[Any]]]]]:
+        """
+        Endpoints for the instance.
+        """
+        return pulumi.get(self, "endpoints")
+
+    @endpoints.setter
+    def endpoints(self, value: Optional[pulumi.Input[Sequence[pulumi.Input[Sequence[Any]]]]]):
+        pulumi.set(self, "endpoints", value)
+
     @property
     @pulumi.getter(name="engineConfigs")
     def engine_configs(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
@@ -608,6 +656,22 @@ class _InstanceState:
     def location(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "location", value)
 
+    @property
+    @pulumi.getter
+    def mode(self) -> Optional[pulumi.Input[str]]:
+        """
+        Optional. Standalone or cluster.
+        Possible values:
+        CLUSTER
+        STANDALONE
+        Possible values are: `CLUSTER`, `STANDALONE`.
+        """
+        return pulumi.get(self, "mode")
+
+    @mode.setter
+    def mode(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "mode", value)
+
     @property
     @pulumi.getter
     def name(self) -> Optional[pulumi.Input[str]]:
@@ -823,6 +887,7 @@ class Instance(pulumi.CustomResource):
                  instance_id: Optional[pulumi.Input[str]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  location: Optional[pulumi.Input[str]] = None,
+                 mode: Optional[pulumi.Input[str]] = None,
                  node_type: Optional[pulumi.Input[str]] = None,
                  persistence_config: Optional[pulumi.Input[Union['InstancePersistenceConfigArgs', 'InstancePersistenceConfigArgsDict']]] = None,
                  project: Optional[pulumi.Input[str]] = None,
@@ -914,6 +979,7 @@ class Instance(pulumi.CustomResource):
             },
             engine_version="VALKEY_7_2",
             deletion_protection_enabled=False,
+            mode="CLUSTER",
             persistence_config={
                 "mode": "RDB",
                 "rdb_config": {
@@ -1016,6 +1082,11 @@ class Instance(pulumi.CustomResource):
                **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
                Please refer to the field `effective_labels` for all of the labels present on the resource.
         :param pulumi.Input[str] location: Resource ID segment making up resource `name`. It identifies the resource within its parent collection as described in https://google.aip.dev/122. See documentation for resource type `memorystore.googleapis.com/CertificateAuthority`.
+        :param pulumi.Input[str] mode: Optional. Standalone or cluster.
+               Possible values:
+               CLUSTER
+               STANDALONE
+               Possible values are: `CLUSTER`, `STANDALONE`.
         :param pulumi.Input[str] node_type: Optional. Immutable. Machine type for individual nodes of the instance.
                Possible values:
                SHARED_CORE_NANO
@@ -1124,6 +1195,7 @@ class Instance(pulumi.CustomResource):
             },
             engine_version="VALKEY_7_2",
             deletion_protection_enabled=False,
+            mode="CLUSTER",
             persistence_config={
                 "mode": "RDB",
                 "rdb_config": {
@@ -1225,6 +1297,7 @@ class Instance(pulumi.CustomResource):
                  instance_id: Optional[pulumi.Input[str]] = None,
                  labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  location: Optional[pulumi.Input[str]] = None,
+                 mode: Optional[pulumi.Input[str]] = None,
                  node_type: Optional[pulumi.Input[str]] = None,
                  persistence_config: Optional[pulumi.Input[Union['InstancePersistenceConfigArgs', 'InstancePersistenceConfigArgsDict']]] = None,
                  project: Optional[pulumi.Input[str]] = None,
@@ -1255,6 +1328,7 @@ class Instance(pulumi.CustomResource):
             if location is None and not opts.urn:
                 raise TypeError("Missing required property 'location'")
             __props__.__dict__["location"] = location
+            __props__.__dict__["mode"] = mode
             __props__.__dict__["node_type"] = node_type
             __props__.__dict__["persistence_config"] = persistence_config
             __props__.__dict__["project"] = project
@@ -1267,6 +1341,7 @@ class Instance(pulumi.CustomResource):
             __props__.__dict__["create_time"] = None
             __props__.__dict__["discovery_endpoints"] = None
             __props__.__dict__["effective_labels"] = None
+            __props__.__dict__["endpoints"] = None
             __props__.__dict__["name"] = None
             __props__.__dict__["node_configs"] = None
             __props__.__dict__["psc_auto_connections"] = None
@@ -1293,11 +1368,13 @@ class Instance(pulumi.CustomResource):
             desired_psc_auto_connections: Optional[pulumi.Input[Sequence[pulumi.Input[Union['InstanceDesiredPscAutoConnectionArgs', 'InstanceDesiredPscAutoConnectionArgsDict']]]]] = None,
             discovery_endpoints: Optional[pulumi.Input[Sequence[pulumi.Input[Union['InstanceDiscoveryEndpointArgs', 'InstanceDiscoveryEndpointArgsDict']]]]] = None,
             effective_labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
+            endpoints: Optional[pulumi.Input[Sequence[pulumi.Input[Sequence[Any]]]]] = None,
             engine_configs: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
             engine_version: Optional[pulumi.Input[str]] = None,
             instance_id: Optional[pulumi.Input[str]] = None,
             labels: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
             location: Optional[pulumi.Input[str]] = None,
+            mode: Optional[pulumi.Input[str]] = None,
             name: Optional[pulumi.Input[str]] = None,
             node_configs: Optional[pulumi.Input[Sequence[pulumi.Input[Union['InstanceNodeConfigArgs', 'InstanceNodeConfigArgsDict']]]]] = None,
             node_type: Optional[pulumi.Input[str]] = None,
@@ -1330,6 +1407,7 @@ class Instance(pulumi.CustomResource):
                discovery endpoint is supported.
                Structure is documented below.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] effective_labels: All of labels (key/value pairs) present on the resource in GCP, including the labels configured through Pulumi, other clients and services.
+        :param pulumi.Input[Sequence[pulumi.Input[Sequence[Any]]]] endpoints: Endpoints for the instance.
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] engine_configs: Optional. User-provided engine configurations for the instance.
         :param pulumi.Input[str] engine_version: Optional. Immutable. Engine version of the instance.
         :param pulumi.Input[str] instance_id: Required. The ID to use for the instance, which will become the final component of
@@ -1347,6 +1425,11 @@ class Instance(pulumi.CustomResource):
                **Note**: This field is non-authoritative, and will only manage the labels present in your configuration.
                Please refer to the field `effective_labels` for all of the labels present on the resource.
         :param pulumi.Input[str] location: Resource ID segment making up resource `name`. It identifies the resource within its parent collection as described in https://google.aip.dev/122. See documentation for resource type `memorystore.googleapis.com/CertificateAuthority`.
+        :param pulumi.Input[str] mode: Optional. Standalone or cluster.
+               Possible values:
+               CLUSTER
+               STANDALONE
+               Possible values are: `CLUSTER`, `STANDALONE`.
         :param pulumi.Input[str] name: Identifier. Unique name of the instance.
                Format: projects/{project}/locations/{location}/instances/{instance}
         :param pulumi.Input[Sequence[pulumi.Input[Union['InstanceNodeConfigArgs', 'InstanceNodeConfigArgsDict']]]] node_configs: Represents configuration for nodes of the instance.
@@ -1394,11 +1477,13 @@ class Instance(pulumi.CustomResource):
         __props__.__dict__["desired_psc_auto_connections"] = desired_psc_auto_connections
         __props__.__dict__["discovery_endpoints"] = discovery_endpoints
         __props__.__dict__["effective_labels"] = effective_labels
+        __props__.__dict__["endpoints"] = endpoints
         __props__.__dict__["engine_configs"] = engine_configs
         __props__.__dict__["engine_version"] = engine_version
         __props__.__dict__["instance_id"] = instance_id
         __props__.__dict__["labels"] = labels
         __props__.__dict__["location"] = location
+        __props__.__dict__["mode"] = mode
         __props__.__dict__["name"] = name
         __props__.__dict__["node_configs"] = node_configs
         __props__.__dict__["node_type"] = node_type
@@ -1468,6 +1553,14 @@ class Instance(pulumi.CustomResource):
         """
         return pulumi.get(self, "effective_labels")
 
+    @property
+    @pulumi.getter
+    def endpoints(self) -> pulumi.Output[Sequence[Sequence[Any]]]:
+        """
+        Endpoints for the instance.
+        """
+        return pulumi.get(self, "endpoints")
+
     @property
     @pulumi.getter(name="engineConfigs")
     def engine_configs(self) -> pulumi.Output[Optional[Mapping[str, str]]]:
@@ -1520,6 +1613,18 @@ class Instance(pulumi.CustomResource):
         """
         return pulumi.get(self, "location")
 
+    @property
+    @pulumi.getter
+    def mode(self) -> pulumi.Output[str]:
+        """
+        Optional. Standalone or cluster.
+        Possible values:
+        CLUSTER
+        STANDALONE
+        Possible values are: `CLUSTER`, `STANDALONE`.
+        """
+        return pulumi.get(self, "mode")
+
     @property
     @pulumi.getter
     def name(self) -> pulumi.Output[str]:

pulumi_gcp/memorystore/outputs.py

@@ -93,7 +93,7 @@ class InstanceDiscoveryEndpoint(dict):
                Output only. The consumer network where the IP address resides, in the form of
                projects/{project_id}/global/networks/{network_id}.
         :param int port: (Output)
-               Output only. The port number of the exposed endpoint.
+               Output only. Ports of the exposed endpoint.
         """
         if address is not None:
             pulumi.set(__self__, "address", address)
@@ -126,7 +126,7 @@ class InstanceDiscoveryEndpoint(dict):
     def port(self) -> Optional[int]:
         """
         (Output)
-        Output only. The port number of the exposed endpoint.
+        Output only. Ports of the exposed endpoint.
         """
         return pulumi.get(self, "port")
 
@@ -358,7 +358,9 @@ class InstancePscAutoConnection(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "forwardingRule":
+        if key == "connectionType":
+            suggest = "connection_type"
+        elif key == "forwardingRule":
             suggest = "forwarding_rule"
         elif key == "ipAddress":
             suggest = "ip_address"
@@ -366,6 +368,10 @@ class InstancePscAutoConnection(dict):
             suggest = "project_id"
         elif key == "pscConnectionId":
             suggest = "psc_connection_id"
+        elif key == "pscConnectionStatus":
+            suggest = "psc_connection_status"
+        elif key == "serviceAttachment":
+            suggest = "service_attachment"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in InstancePscAutoConnection. Access the value via the '{suggest}' property getter instead.")
@@ -379,12 +385,22 @@ class InstancePscAutoConnection(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 connection_type: Optional[str] = None,
                  forwarding_rule: Optional[str] = None,
                  ip_address: Optional[str] = None,
                  network: Optional[str] = None,
+                 port: Optional[int] = None,
                  project_id: Optional[str] = None,
-                 psc_connection_id: Optional[str] = None):
+                 psc_connection_id: Optional[str] = None,
+                 psc_connection_status: Optional[str] = None,
+                 service_attachment: Optional[str] = None):
         """
+        :param str connection_type: (Output)
+               Output Only. Type of a PSC Connection.
+               Possible values:
+               CONNECTION_TYPE_DISCOVERY
+               CONNECTION_TYPE_PRIMARY
+               CONNECTION_TYPE_READER
         :param str forwarding_rule: (Output)
                Output only. The URI of the consumer side forwarding rule.
                Format:
@@ -394,22 +410,52 @@ class InstancePscAutoConnection(dict):
         :param str network: (Output)
                Output only. The consumer network where the IP address resides, in the form of
                projects/{project_id}/global/networks/{network_id}.
+        :param int port: (Output)
+               Output only. Ports of the exposed endpoint.
         :param str project_id: (Output)
                Output only. The consumer project_id where the forwarding rule is created from.
         :param str psc_connection_id: (Output)
                Output only. The PSC connection id of the forwarding rule connected to the
                service attachment.
+        :param str psc_connection_status: (Output)
+               Output Only. The status of the PSC connection: whether a connection exists and ACTIVE or it no longer exists.
+               Possible values:
+               ACTIVE
+               NOT_FOUND
+        :param str service_attachment: (Output)
+               Output only. The service attachment which is the target of the PSC connection, in the form of projects/{project-id}/regions/{region}/serviceAttachments/{service-attachment-id}.
         """
+        if connection_type is not None:
+            pulumi.set(__self__, "connection_type", connection_type)
         if forwarding_rule is not None:
             pulumi.set(__self__, "forwarding_rule", forwarding_rule)
         if ip_address is not None:
             pulumi.set(__self__, "ip_address", ip_address)
         if network is not None:
             pulumi.set(__self__, "network", network)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
         if project_id is not None:
             pulumi.set(__self__, "project_id", project_id)
         if psc_connection_id is not None:
             pulumi.set(__self__, "psc_connection_id", psc_connection_id)
+        if psc_connection_status is not None:
+            pulumi.set(__self__, "psc_connection_status", psc_connection_status)
+        if service_attachment is not None:
+            pulumi.set(__self__, "service_attachment", service_attachment)
+
+    @property
+    @pulumi.getter(name="connectionType")
+    def connection_type(self) -> Optional[str]:
+        """
+        (Output)
+        Output Only. Type of a PSC Connection.
+        Possible values:
+        CONNECTION_TYPE_DISCOVERY
+        CONNECTION_TYPE_PRIMARY
+        CONNECTION_TYPE_READER
+        """
+        return pulumi.get(self, "connection_type")
 
     @property
     @pulumi.getter(name="forwardingRule")
@@ -441,6 +487,15 @@ class InstancePscAutoConnection(dict):
         """
         return pulumi.get(self, "network")
 
+    @property
+    @pulumi.getter
+    def port(self) -> Optional[int]:
+        """
+        (Output)
+        Output only. Ports of the exposed endpoint.
+        """
+        return pulumi.get(self, "port")
+
     @property
     @pulumi.getter(name="projectId")
     def project_id(self) -> Optional[str]:
@@ -460,6 +515,27 @@ class InstancePscAutoConnection(dict):
         """
         return pulumi.get(self, "psc_connection_id")
 
+    @property
+    @pulumi.getter(name="pscConnectionStatus")
+    def psc_connection_status(self) -> Optional[str]:
+        """
+        (Output)
+        Output Only. The status of the PSC connection: whether a connection exists and ACTIVE or it no longer exists.
+        Possible values:
+        ACTIVE
+        NOT_FOUND
+        """
+        return pulumi.get(self, "psc_connection_status")
+
+    @property
+    @pulumi.getter(name="serviceAttachment")
+    def service_attachment(self) -> Optional[str]:
+        """
+        (Output)
+        Output only. The service attachment which is the target of the PSC connection, in the form of projects/{project-id}/regions/{region}/serviceAttachments/{service-attachment-id}.
+        """
+        return pulumi.get(self, "service_attachment")
+
 
 @pulumi.output_type
 class InstanceStateInfo(dict):

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 *