pulumi-gcp 7.29.0a1719417555__py3-none-any.whl → 7.30.0__py3-none-any.whl

pulumi_gcp/monitoring/_inputs.py

@@ -4,71 +4,158 @@
 
 import copy
 import warnings
+import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
+if sys.version_info >= (3, 11):
+    from typing import NotRequired, TypedDict, TypeAlias
+else:
+    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 
 __all__ = [
     'AlertPolicyAlertStrategyArgs',
+    'AlertPolicyAlertStrategyArgsDict',
     'AlertPolicyAlertStrategyNotificationChannelStrategyArgs',
+    'AlertPolicyAlertStrategyNotificationChannelStrategyArgsDict',
     'AlertPolicyAlertStrategyNotificationRateLimitArgs',
+    'AlertPolicyAlertStrategyNotificationRateLimitArgsDict',
     'AlertPolicyConditionArgs',
+    'AlertPolicyConditionArgsDict',
     'AlertPolicyConditionConditionAbsentArgs',
+    'AlertPolicyConditionConditionAbsentArgsDict',
     'AlertPolicyConditionConditionAbsentAggregationArgs',
+    'AlertPolicyConditionConditionAbsentAggregationArgsDict',
     'AlertPolicyConditionConditionAbsentTriggerArgs',
+    'AlertPolicyConditionConditionAbsentTriggerArgsDict',
     'AlertPolicyConditionConditionMatchedLogArgs',
+    'AlertPolicyConditionConditionMatchedLogArgsDict',
     'AlertPolicyConditionConditionMonitoringQueryLanguageArgs',
+    'AlertPolicyConditionConditionMonitoringQueryLanguageArgsDict',
     'AlertPolicyConditionConditionMonitoringQueryLanguageTriggerArgs',
+    'AlertPolicyConditionConditionMonitoringQueryLanguageTriggerArgsDict',
     'AlertPolicyConditionConditionPrometheusQueryLanguageArgs',
+    'AlertPolicyConditionConditionPrometheusQueryLanguageArgsDict',
     'AlertPolicyConditionConditionThresholdArgs',
+    'AlertPolicyConditionConditionThresholdArgsDict',
     'AlertPolicyConditionConditionThresholdAggregationArgs',
+    'AlertPolicyConditionConditionThresholdAggregationArgsDict',
     'AlertPolicyConditionConditionThresholdDenominatorAggregationArgs',
+    'AlertPolicyConditionConditionThresholdDenominatorAggregationArgsDict',
     'AlertPolicyConditionConditionThresholdForecastOptionsArgs',
+    'AlertPolicyConditionConditionThresholdForecastOptionsArgsDict',
     'AlertPolicyConditionConditionThresholdTriggerArgs',
+    'AlertPolicyConditionConditionThresholdTriggerArgsDict',
     'AlertPolicyCreationRecordArgs',
+    'AlertPolicyCreationRecordArgsDict',
     'AlertPolicyDocumentationArgs',
+    'AlertPolicyDocumentationArgsDict',
+    'AlertPolicyDocumentationLinkArgs',
+    'AlertPolicyDocumentationLinkArgsDict',
     'CustomServiceTelemetryArgs',
+    'CustomServiceTelemetryArgsDict',
     'GenericServiceBasicServiceArgs',
+    'GenericServiceBasicServiceArgsDict',
     'GenericServiceTelemetryArgs',
+    'GenericServiceTelemetryArgsDict',
     'MetricDescriptorLabelArgs',
+    'MetricDescriptorLabelArgsDict',
     'MetricDescriptorMetadataArgs',
+    'MetricDescriptorMetadataArgsDict',
     'NotificationChannelSensitiveLabelsArgs',
+    'NotificationChannelSensitiveLabelsArgsDict',
     'SloBasicSliArgs',
+    'SloBasicSliArgsDict',
     'SloBasicSliAvailabilityArgs',
+    'SloBasicSliAvailabilityArgsDict',
     'SloBasicSliLatencyArgs',
+    'SloBasicSliLatencyArgsDict',
     'SloRequestBasedSliArgs',
+    'SloRequestBasedSliArgsDict',
     'SloRequestBasedSliDistributionCutArgs',
+    'SloRequestBasedSliDistributionCutArgsDict',
     'SloRequestBasedSliDistributionCutRangeArgs',
+    'SloRequestBasedSliDistributionCutRangeArgsDict',
     'SloRequestBasedSliGoodTotalRatioArgs',
+    'SloRequestBasedSliGoodTotalRatioArgsDict',
     'SloWindowsBasedSliArgs',
+    'SloWindowsBasedSliArgsDict',
     'SloWindowsBasedSliGoodTotalRatioThresholdArgs',
+    'SloWindowsBasedSliGoodTotalRatioThresholdArgsDict',
     'SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceArgs',
+    'SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceArgsDict',
     'SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceAvailabilityArgs',
+    'SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceAvailabilityArgsDict',
     'SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceLatencyArgs',
+    'SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceLatencyArgsDict',
     'SloWindowsBasedSliGoodTotalRatioThresholdPerformanceArgs',
+    'SloWindowsBasedSliGoodTotalRatioThresholdPerformanceArgsDict',
     'SloWindowsBasedSliGoodTotalRatioThresholdPerformanceDistributionCutArgs',
+    'SloWindowsBasedSliGoodTotalRatioThresholdPerformanceDistributionCutArgsDict',
     'SloWindowsBasedSliGoodTotalRatioThresholdPerformanceDistributionCutRangeArgs',
+    'SloWindowsBasedSliGoodTotalRatioThresholdPerformanceDistributionCutRangeArgsDict',
     'SloWindowsBasedSliGoodTotalRatioThresholdPerformanceGoodTotalRatioArgs',
+    'SloWindowsBasedSliGoodTotalRatioThresholdPerformanceGoodTotalRatioArgsDict',
     'SloWindowsBasedSliMetricMeanInRangeArgs',
+    'SloWindowsBasedSliMetricMeanInRangeArgsDict',
     'SloWindowsBasedSliMetricMeanInRangeRangeArgs',
+    'SloWindowsBasedSliMetricMeanInRangeRangeArgsDict',
     'SloWindowsBasedSliMetricSumInRangeArgs',
+    'SloWindowsBasedSliMetricSumInRangeArgsDict',
     'SloWindowsBasedSliMetricSumInRangeRangeArgs',
+    'SloWindowsBasedSliMetricSumInRangeRangeArgsDict',
     'UptimeCheckConfigContentMatcherArgs',
+    'UptimeCheckConfigContentMatcherArgsDict',
     'UptimeCheckConfigContentMatcherJsonPathMatcherArgs',
+    'UptimeCheckConfigContentMatcherJsonPathMatcherArgsDict',
     'UptimeCheckConfigHttpCheckArgs',
+    'UptimeCheckConfigHttpCheckArgsDict',
     'UptimeCheckConfigHttpCheckAcceptedResponseStatusCodeArgs',
+    'UptimeCheckConfigHttpCheckAcceptedResponseStatusCodeArgsDict',
     'UptimeCheckConfigHttpCheckAuthInfoArgs',
+    'UptimeCheckConfigHttpCheckAuthInfoArgsDict',
     'UptimeCheckConfigHttpCheckPingConfigArgs',
+    'UptimeCheckConfigHttpCheckPingConfigArgsDict',
     'UptimeCheckConfigHttpCheckServiceAgentAuthenticationArgs',
+    'UptimeCheckConfigHttpCheckServiceAgentAuthenticationArgsDict',
     'UptimeCheckConfigMonitoredResourceArgs',
+    'UptimeCheckConfigMonitoredResourceArgsDict',
     'UptimeCheckConfigResourceGroupArgs',
+    'UptimeCheckConfigResourceGroupArgsDict',
     'UptimeCheckConfigSyntheticMonitorArgs',
+    'UptimeCheckConfigSyntheticMonitorArgsDict',
     'UptimeCheckConfigSyntheticMonitorCloudFunctionV2Args',
+    'UptimeCheckConfigSyntheticMonitorCloudFunctionV2ArgsDict',
     'UptimeCheckConfigTcpCheckArgs',
+    'UptimeCheckConfigTcpCheckArgsDict',
     'UptimeCheckConfigTcpCheckPingConfigArgs',
+    'UptimeCheckConfigTcpCheckPingConfigArgsDict',
 ]
 
+MYPY = False
+
+if not MYPY:
+    class AlertPolicyAlertStrategyArgsDict(TypedDict):
+        auto_close: NotRequired[pulumi.Input[str]]
+        """
+        If an alert policy that was active has no data for this long, any open incidents will close.
+        """
+        notification_channel_strategies: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlertPolicyAlertStrategyNotificationChannelStrategyArgsDict']]]]
+        """
+        Control over how the notification channels in `notification_channels`
+        are notified when this alert fires, on a per-channel basis.
+        Structure is documented below.
+        """
+        notification_rate_limit: NotRequired[pulumi.Input['AlertPolicyAlertStrategyNotificationRateLimitArgsDict']]
+        """
+        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.
+        """
+elif False:
+    AlertPolicyAlertStrategyArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertPolicyAlertStrategyArgs:
     def __init__(__self__, *,
@@ -132,6 +219,22 @@ class AlertPolicyAlertStrategyArgs:
         pulumi.set(self, "notification_rate_limit", value)
 
 
+if not MYPY:
+    class AlertPolicyAlertStrategyNotificationChannelStrategyArgsDict(TypedDict):
+        notification_channel_names: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The notification channels that these settings apply to. Each of these
+        correspond to the name field in one of the NotificationChannel objects
+        referenced in the notification_channels field of this AlertPolicy. The format is
+        `projects/[PROJECT_ID_OR_NUMBER]/notificationChannels/[CHANNEL_ID]`
+        """
+        renotify_interval: NotRequired[pulumi.Input[str]]
+        """
+        The frequency at which to send reminder notifications for open incidents.
+        """
+elif False:
+    AlertPolicyAlertStrategyNotificationChannelStrategyArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertPolicyAlertStrategyNotificationChannelStrategyArgs:
     def __init__(__self__, *,
@@ -177,6 +280,16 @@ class AlertPolicyAlertStrategyNotificationChannelStrategyArgs:
         pulumi.set(self, "renotify_interval", value)
 
 
+if not MYPY:
+    class AlertPolicyAlertStrategyNotificationRateLimitArgsDict(TypedDict):
+        period: NotRequired[pulumi.Input[str]]
+        """
+        Not more than one notification per period.
+        A duration in seconds with up to nine fractional digits, terminated by 's'. Example "60.5s".
+        """
+elif False:
+    AlertPolicyAlertStrategyNotificationRateLimitArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertPolicyAlertStrategyNotificationRateLimitArgs:
     def __init__(__self__, *,
@@ -202,6 +315,60 @@ class AlertPolicyAlertStrategyNotificationRateLimitArgs:
         pulumi.set(self, "period", value)
 
 
+if not MYPY:
+    class AlertPolicyConditionArgsDict(TypedDict):
+        display_name: pulumi.Input[str]
+        """
+        A short name or phrase used to identify the
+        condition in dashboards, notifications, and
+        incidents. To avoid confusion, don't use the same
+        display name for multiple conditions in the same
+        policy.
+        """
+        condition_absent: NotRequired[pulumi.Input['AlertPolicyConditionConditionAbsentArgsDict']]
+        """
+        A condition that checks that a time series
+        continues to receive new data points.
+        Structure is documented below.
+        """
+        condition_matched_log: NotRequired[pulumi.Input['AlertPolicyConditionConditionMatchedLogArgsDict']]
+        """
+        A condition that checks for log messages matching given constraints.
+        If set, no other conditions can be present.
+        Structure is documented below.
+        """
+        condition_monitoring_query_language: NotRequired[pulumi.Input['AlertPolicyConditionConditionMonitoringQueryLanguageArgsDict']]
+        """
+        A Monitoring Query Language query that outputs a boolean stream
+        Structure is documented below.
+        """
+        condition_prometheus_query_language: NotRequired[pulumi.Input['AlertPolicyConditionConditionPrometheusQueryLanguageArgsDict']]
+        """
+        A condition type that allows alert policies to be defined using
+        Prometheus Query Language (PromQL).
+        The PrometheusQueryLanguageCondition message contains information
+        from a Prometheus alerting rule and its associated rule group.
+        Structure is documented below.
+        """
+        condition_threshold: NotRequired[pulumi.Input['AlertPolicyConditionConditionThresholdArgsDict']]
+        """
+        A condition that compares a time series against a
+        threshold.
+        Structure is documented below.
+        """
+        name: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        The unique resource name for this condition.
+        Its syntax is:
+        projects/[PROJECT_ID]/alertPolicies/[POLICY_ID]/conditions/[CONDITION_ID]
+        [CONDITION_ID] is assigned by Stackdriver Monitoring when
+        the condition is created as part of a new or updated alerting
+        policy.
+        """
+elif False:
+    AlertPolicyConditionArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertPolicyConditionArgs:
     def __init__(__self__, *,
@@ -362,6 +529,57 @@ class AlertPolicyConditionArgs:
         pulumi.set(self, "name", value)
 
 
+if not MYPY:
+    class AlertPolicyConditionConditionAbsentArgsDict(TypedDict):
+        duration: pulumi.Input[str]
+        """
+        The amount of time that a time series must
+        fail to report new data to be considered
+        failing. Currently, only values that are a
+        multiple of a minute--e.g. 60s, 120s, or 300s
+        --are supported.
+        """
+        aggregations: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlertPolicyConditionConditionAbsentAggregationArgsDict']]]]
+        """
+        Specifies the alignment of data points in
+        individual time series as well as how to
+        combine the retrieved time series together
+        (such as when aggregating multiple streams
+        on each resource to a single stream for each
+        resource or when aggregating streams across
+        all members of a group of resources).
+        Multiple aggregations are applied in the
+        order specified.
+        Structure is documented below.
+        """
+        filter: NotRequired[pulumi.Input[str]]
+        """
+        A filter that identifies which time series
+        should be compared with the threshold.The
+        filter is similar to the one that is
+        specified in the
+        MetricService.ListTimeSeries request (that
+        call is useful to verify the time series
+        that will be retrieved / processed) and must
+        specify the metric type and optionally may
+        contain restrictions on resource type,
+        resource labels, and metric labels. This
+        field may not exceed 2048 Unicode characters
+        in length.
+        """
+        trigger: NotRequired[pulumi.Input['AlertPolicyConditionConditionAbsentTriggerArgsDict']]
+        """
+        The number/percent of time series for which
+        the comparison must hold in order for the
+        condition to trigger. If unspecified, then
+        the condition will trigger if the comparison
+        is true for any of the time series that have
+        been identified by filter and aggregations.
+        Structure is documented below.
+        """
+elif False:
+    AlertPolicyConditionConditionAbsentArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertPolicyConditionConditionAbsentArgs:
     def __init__(__self__, *,
@@ -492,6 +710,98 @@ class AlertPolicyConditionConditionAbsentArgs:
         pulumi.set(self, "trigger", value)
 
 
+if not MYPY:
+    class AlertPolicyConditionConditionAbsentAggregationArgsDict(TypedDict):
+        alignment_period: NotRequired[pulumi.Input[str]]
+        """
+        The alignment period for per-time
+        series alignment. If present,
+        alignmentPeriod must be at least
+        60 seconds. After per-time series
+        alignment, each time series will
+        contain data points only on the
+        period boundaries. If
+        perSeriesAligner is not specified
+        or equals ALIGN_NONE, then this
+        field is ignored. If
+        perSeriesAligner is specified and
+        does not equal ALIGN_NONE, then
+        this field must be defined;
+        otherwise an error is returned.
+        """
+        cross_series_reducer: NotRequired[pulumi.Input[str]]
+        """
+        The approach to be used to combine
+        time series. Not all reducer
+        functions may be applied to all
+        time series, depending on the
+        metric type and the value type of
+        the original time series.
+        Reduction may change the metric
+        type of value type of the time
+        series.Time series data must be
+        aligned in order to perform cross-
+        time series reduction. If
+        crossSeriesReducer is specified,
+        then perSeriesAligner must be
+        specified and not equal ALIGN_NONE
+        and alignmentPeriod must be
+        specified; otherwise, an error is
+        returned.
+        Possible values are: `REDUCE_NONE`, `REDUCE_MEAN`, `REDUCE_MIN`, `REDUCE_MAX`, `REDUCE_SUM`, `REDUCE_STDDEV`, `REDUCE_COUNT`, `REDUCE_COUNT_TRUE`, `REDUCE_COUNT_FALSE`, `REDUCE_FRACTION_TRUE`, `REDUCE_PERCENTILE_99`, `REDUCE_PERCENTILE_95`, `REDUCE_PERCENTILE_50`, `REDUCE_PERCENTILE_05`.
+        """
+        group_by_fields: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The set of fields to preserve when
+        crossSeriesReducer is specified.
+        The groupByFields determine how
+        the time series are partitioned
+        into subsets prior to applying the
+        aggregation function. Each subset
+        contains time series that have the
+        same value for each of the
+        grouping fields. Each individual
+        time series is a member of exactly
+        one subset. The crossSeriesReducer
+        is applied to each subset of time
+        series. It is not possible to
+        reduce across different resource
+        types, so this field implicitly
+        contains resource.type. Fields not
+        specified in groupByFields are
+        aggregated away. If groupByFields
+        is not specified and all the time
+        series have the same resource
+        type, then the time series are
+        aggregated into a single output
+        time series. If crossSeriesReducer
+        is not defined, this field is
+        ignored.
+        """
+        per_series_aligner: NotRequired[pulumi.Input[str]]
+        """
+        The approach to be used to align
+        individual time series. Not all
+        alignment functions may be applied
+        to all time series, depending on
+        the metric type and value type of
+        the original time series.
+        Alignment may change the metric
+        type or the value type of the time
+        series.Time series data must be
+        aligned in order to perform cross-
+        time series reduction. If
+        crossSeriesReducer is specified,
+        then perSeriesAligner must be
+        specified and not equal ALIGN_NONE
+        and alignmentPeriod must be
+        specified; otherwise, an error is
+        returned.
+        Possible values are: `ALIGN_NONE`, `ALIGN_DELTA`, `ALIGN_RATE`, `ALIGN_INTERPOLATE`, `ALIGN_NEXT_OLDER`, `ALIGN_MIN`, `ALIGN_MAX`, `ALIGN_MEAN`, `ALIGN_COUNT`, `ALIGN_SUM`, `ALIGN_STDDEV`, `ALIGN_COUNT_TRUE`, `ALIGN_COUNT_FALSE`, `ALIGN_FRACTION_TRUE`, `ALIGN_PERCENTILE_99`, `ALIGN_PERCENTILE_95`, `ALIGN_PERCENTILE_50`, `ALIGN_PERCENTILE_05`, `ALIGN_PERCENT_CHANGE`.
+        """
+elif False:
+    AlertPolicyConditionConditionAbsentAggregationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertPolicyConditionConditionAbsentAggregationArgs:
     def __init__(__self__, *,
@@ -705,6 +1015,23 @@ class AlertPolicyConditionConditionAbsentAggregationArgs:
         pulumi.set(self, "per_series_aligner", value)
 
 
+if not MYPY:
+    class AlertPolicyConditionConditionAbsentTriggerArgsDict(TypedDict):
+        count: NotRequired[pulumi.Input[int]]
+        """
+        The absolute number of time series
+        that must fail the predicate for the
+        condition to be triggered.
+        """
+        percent: NotRequired[pulumi.Input[float]]
+        """
+        The percentage of time series that
+        must fail the predicate for the
+        condition to be triggered.
+        """
+elif False:
+    AlertPolicyConditionConditionAbsentTriggerArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertPolicyConditionConditionAbsentTriggerArgs:
     def __init__(__self__, *,
@@ -752,6 +1079,25 @@ class AlertPolicyConditionConditionAbsentTriggerArgs:
         pulumi.set(self, "percent", value)
 
 
+if not MYPY:
+    class AlertPolicyConditionConditionMatchedLogArgsDict(TypedDict):
+        filter: pulumi.Input[str]
+        """
+        A logs-based filter.
+        """
+        label_extractors: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        A map from a label key to an extractor expression, which is used to
+        extract the value for this label key. Each entry in this map is
+        a specification for how data should be extracted from log entries that
+        match filter. Each combination of extracted values is treated as
+        a separate rule for the purposes of triggering notifications.
+        Label keys and corresponding values can be used in notifications
+        generated by this condition.
+        """
+elif False:
+    AlertPolicyConditionConditionMatchedLogArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertPolicyConditionConditionMatchedLogArgs:
     def __init__(__self__, *,
@@ -802,39 +1148,85 @@ class AlertPolicyConditionConditionMatchedLogArgs:
         pulumi.set(self, "label_extractors", value)
 
 
-@pulumi.input_type
-class AlertPolicyConditionConditionMonitoringQueryLanguageArgs:
-    def __init__(__self__, *,
-                 duration: pulumi.Input[str],
-                 query: pulumi.Input[str],
-                 evaluation_missing_data: Optional[pulumi.Input[str]] = None,
-                 trigger: Optional[pulumi.Input['AlertPolicyConditionConditionMonitoringQueryLanguageTriggerArgs']] = None):
+if not MYPY:
+    class AlertPolicyConditionConditionMonitoringQueryLanguageArgsDict(TypedDict):
+        duration: pulumi.Input[str]
         """
-        :param pulumi.Input[str] duration: The amount of time that a time series must
-               violate the threshold to be considered
-               failing. Currently, only values that are a
-               multiple of a minute--e.g., 0, 60, 120, or
-               300 seconds--are supported. If an invalid
-               value is given, an error will be returned.
-               When choosing a duration, it is useful to
-               keep in mind the frequency of the underlying
-               time series data (which may also be affected
-               by any alignments specified in the
-               aggregations field); a good duration is long
-               enough so that a single outlier does not
-               generate spurious alerts, but short enough
-               that unhealthy states are detected and
-               alerted on quickly.
-        :param pulumi.Input[str] query: Monitoring Query Language query that outputs a boolean stream.
-        :param pulumi.Input[str] evaluation_missing_data: A condition control that determines how
-               metric-threshold conditions are evaluated when
-               data stops arriving.
-               Possible values are: `EVALUATION_MISSING_DATA_INACTIVE`, `EVALUATION_MISSING_DATA_ACTIVE`, `EVALUATION_MISSING_DATA_NO_OP`.
-        :param pulumi.Input['AlertPolicyConditionConditionMonitoringQueryLanguageTriggerArgs'] trigger: The number/percent of time series for which
-               the comparison must hold in order for the
-               condition to trigger. If unspecified, then
-               the condition will trigger if the comparison
-               is true for any of the time series that have
+        The amount of time that a time series must
+        violate the threshold to be considered
+        failing. Currently, only values that are a
+        multiple of a minute--e.g., 0, 60, 120, or
+        300 seconds--are supported. If an invalid
+        value is given, an error will be returned.
+        When choosing a duration, it is useful to
+        keep in mind the frequency of the underlying
+        time series data (which may also be affected
+        by any alignments specified in the
+        aggregations field); a good duration is long
+        enough so that a single outlier does not
+        generate spurious alerts, but short enough
+        that unhealthy states are detected and
+        alerted on quickly.
+        """
+        query: pulumi.Input[str]
+        """
+        Monitoring Query Language query that outputs a boolean stream.
+        """
+        evaluation_missing_data: NotRequired[pulumi.Input[str]]
+        """
+        A condition control that determines how
+        metric-threshold conditions are evaluated when
+        data stops arriving.
+        Possible values are: `EVALUATION_MISSING_DATA_INACTIVE`, `EVALUATION_MISSING_DATA_ACTIVE`, `EVALUATION_MISSING_DATA_NO_OP`.
+        """
+        trigger: NotRequired[pulumi.Input['AlertPolicyConditionConditionMonitoringQueryLanguageTriggerArgsDict']]
+        """
+        The number/percent of time series for which
+        the comparison must hold in order for the
+        condition to trigger. If unspecified, then
+        the condition will trigger if the comparison
+        is true for any of the time series that have
+        been identified by filter and aggregations,
+        or by the ratio, if denominator_filter and
+        denominator_aggregations are specified.
+        Structure is documented below.
+        """
+elif False:
+    AlertPolicyConditionConditionMonitoringQueryLanguageArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AlertPolicyConditionConditionMonitoringQueryLanguageArgs:
+    def __init__(__self__, *,
+                 duration: pulumi.Input[str],
+                 query: pulumi.Input[str],
+                 evaluation_missing_data: Optional[pulumi.Input[str]] = None,
+                 trigger: Optional[pulumi.Input['AlertPolicyConditionConditionMonitoringQueryLanguageTriggerArgs']] = None):
+        """
+        :param pulumi.Input[str] duration: The amount of time that a time series must
+               violate the threshold to be considered
+               failing. Currently, only values that are a
+               multiple of a minute--e.g., 0, 60, 120, or
+               300 seconds--are supported. If an invalid
+               value is given, an error will be returned.
+               When choosing a duration, it is useful to
+               keep in mind the frequency of the underlying
+               time series data (which may also be affected
+               by any alignments specified in the
+               aggregations field); a good duration is long
+               enough so that a single outlier does not
+               generate spurious alerts, but short enough
+               that unhealthy states are detected and
+               alerted on quickly.
+        :param pulumi.Input[str] query: Monitoring Query Language query that outputs a boolean stream.
+        :param pulumi.Input[str] evaluation_missing_data: A condition control that determines how
+               metric-threshold conditions are evaluated when
+               data stops arriving.
+               Possible values are: `EVALUATION_MISSING_DATA_INACTIVE`, `EVALUATION_MISSING_DATA_ACTIVE`, `EVALUATION_MISSING_DATA_NO_OP`.
+        :param pulumi.Input['AlertPolicyConditionConditionMonitoringQueryLanguageTriggerArgs'] trigger: The number/percent of time series for which
+               the comparison must hold in order for the
+               condition to trigger. If unspecified, then
+               the condition will trigger if the comparison
+               is true for any of the time series that have
                been identified by filter and aggregations,
                or by the ratio, if denominator_filter and
                denominator_aggregations are specified.
@@ -921,6 +1313,23 @@ class AlertPolicyConditionConditionMonitoringQueryLanguageArgs:
         pulumi.set(self, "trigger", value)
 
 
+if not MYPY:
+    class AlertPolicyConditionConditionMonitoringQueryLanguageTriggerArgsDict(TypedDict):
+        count: NotRequired[pulumi.Input[int]]
+        """
+        The absolute number of time series
+        that must fail the predicate for the
+        condition to be triggered.
+        """
+        percent: NotRequired[pulumi.Input[float]]
+        """
+        The percentage of time series that
+        must fail the predicate for the
+        condition to be triggered.
+        """
+elif False:
+    AlertPolicyConditionConditionMonitoringQueryLanguageTriggerArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertPolicyConditionConditionMonitoringQueryLanguageTriggerArgs:
     def __init__(__self__, *,
@@ -968,6 +1377,65 @@ class AlertPolicyConditionConditionMonitoringQueryLanguageTriggerArgs:
         pulumi.set(self, "percent", value)
 
 
+if not MYPY:
+    class AlertPolicyConditionConditionPrometheusQueryLanguageArgsDict(TypedDict):
+        query: pulumi.Input[str]
+        """
+        The PromQL expression to evaluate. Every evaluation cycle this
+        expression is evaluated at the current time, and all resultant time
+        series become pending/firing alerts. This field must not be empty.
+        """
+        alert_rule: NotRequired[pulumi.Input[str]]
+        """
+        The alerting rule name of this alert in the corresponding Prometheus
+        configuration file.
+        Some external tools may require this field to be populated correctly
+        in order to refer to the original Prometheus configuration file.
+        The rule group name and the alert name are necessary to update the
+        relevant AlertPolicies in case the definition of the rule group changes
+        in the future.
+        This field is optional. If this field is not empty, then it must be a
+        valid Prometheus label name.
+
+        - - -
+        """
+        duration: NotRequired[pulumi.Input[str]]
+        """
+        Alerts are considered firing once their PromQL expression evaluated
+        to be "true" for this long. Alerts whose PromQL expression was not
+        evaluated to be "true" for long enough are considered pending. The
+        default value is zero. Must be zero or positive.
+        """
+        evaluation_interval: NotRequired[pulumi.Input[str]]
+        """
+        How often this rule should be evaluated. Must be a positive multiple
+        of 30 seconds or missing. The default value is 30 seconds. If this
+        PrometheusQueryLanguageCondition was generated from a Prometheus
+        alerting rule, then this value should be taken from the enclosing
+        rule group.
+        """
+        labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Labels to add to or overwrite in the PromQL query result. Label names
+        must be valid.
+        Label values can be templatized by using variables. The only available
+        variable names are the names of the labels in the PromQL result, including
+        "__name__" and "value". "labels" may be empty. This field is intended to be
+        used for organizing and identifying the AlertPolicy
+        """
+        rule_group: NotRequired[pulumi.Input[str]]
+        """
+        The rule group name of this alert in the corresponding Prometheus
+        configuration file.
+        Some external tools may require this field to be populated correctly
+        in order to refer to the original Prometheus configuration file.
+        The rule group name and the alert name are necessary to update the
+        relevant AlertPolicies in case the definition of the rule group changes
+        in the future. This field is optional.
+        """
+elif False:
+    AlertPolicyConditionConditionPrometheusQueryLanguageArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertPolicyConditionConditionPrometheusQueryLanguageArgs:
     def __init__(__self__, *,
@@ -1130,6 +1598,145 @@ class AlertPolicyConditionConditionPrometheusQueryLanguageArgs:
         pulumi.set(self, "rule_group", value)
 
 
+if not MYPY:
+    class AlertPolicyConditionConditionThresholdArgsDict(TypedDict):
+        comparison: pulumi.Input[str]
+        """
+        The comparison to apply between the time
+        series (indicated by filter and aggregation)
+        and the threshold (indicated by
+        threshold_value). The comparison is applied
+        on each time series, with the time series on
+        the left-hand side and the threshold on the
+        right-hand side. Only COMPARISON_LT and
+        COMPARISON_GT are supported currently.
+        Possible values are: `COMPARISON_GT`, `COMPARISON_GE`, `COMPARISON_LT`, `COMPARISON_LE`, `COMPARISON_EQ`, `COMPARISON_NE`.
+        """
+        duration: pulumi.Input[str]
+        """
+        The amount of time that a time series must
+        violate the threshold to be considered
+        failing. Currently, only values that are a
+        multiple of a minute--e.g., 0, 60, 120, or
+        300 seconds--are supported. If an invalid
+        value is given, an error will be returned.
+        When choosing a duration, it is useful to
+        keep in mind the frequency of the underlying
+        time series data (which may also be affected
+        by any alignments specified in the
+        aggregations field); a good duration is long
+        enough so that a single outlier does not
+        generate spurious alerts, but short enough
+        that unhealthy states are detected and
+        alerted on quickly.
+        """
+        aggregations: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlertPolicyConditionConditionThresholdAggregationArgsDict']]]]
+        """
+        Specifies the alignment of data points in
+        individual time series as well as how to
+        combine the retrieved time series together
+        (such as when aggregating multiple streams
+        on each resource to a single stream for each
+        resource or when aggregating streams across
+        all members of a group of resources).
+        Multiple aggregations are applied in the
+        order specified.This field is similar to the
+        one in the MetricService.ListTimeSeries
+        request. It is advisable to use the
+        ListTimeSeries method when debugging this
+        field.
+        Structure is documented below.
+        """
+        denominator_aggregations: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlertPolicyConditionConditionThresholdDenominatorAggregationArgsDict']]]]
+        """
+        Specifies the alignment of data points in
+        individual time series selected by
+        denominatorFilter as well as how to combine
+        the retrieved time series together (such as
+        when aggregating multiple streams on each
+        resource to a single stream for each
+        resource or when aggregating streams across
+        all members of a group of resources).When
+        computing ratios, the aggregations and
+        denominator_aggregations fields must use the
+        same alignment period and produce time
+        series that have the same periodicity and
+        labels.This field is similar to the one in
+        the MetricService.ListTimeSeries request. It
+        is advisable to use the ListTimeSeries
+        method when debugging this field.
+        Structure is documented below.
+        """
+        denominator_filter: NotRequired[pulumi.Input[str]]
+        """
+        A filter that identifies a time series that
+        should be used as the denominator of a ratio
+        that will be compared with the threshold. If
+        a denominator_filter is specified, the time
+        series specified by the filter field will be
+        used as the numerator.The filter is similar
+        to the one that is specified in the
+        MetricService.ListTimeSeries request (that
+        call is useful to verify the time series
+        that will be retrieved / processed) and must
+        specify the metric type and optionally may
+        contain restrictions on resource type,
+        resource labels, and metric labels. This
+        field may not exceed 2048 Unicode characters
+        in length.
+        """
+        evaluation_missing_data: NotRequired[pulumi.Input[str]]
+        """
+        A condition control that determines how
+        metric-threshold conditions are evaluated when
+        data stops arriving.
+        Possible values are: `EVALUATION_MISSING_DATA_INACTIVE`, `EVALUATION_MISSING_DATA_ACTIVE`, `EVALUATION_MISSING_DATA_NO_OP`.
+        """
+        filter: NotRequired[pulumi.Input[str]]
+        """
+        A filter that identifies which time series
+        should be compared with the threshold.The
+        filter is similar to the one that is
+        specified in the
+        MetricService.ListTimeSeries request (that
+        call is useful to verify the time series
+        that will be retrieved / processed) and must
+        specify the metric type and optionally may
+        contain restrictions on resource type,
+        resource labels, and metric labels. This
+        field may not exceed 2048 Unicode characters
+        in length.
+        """
+        forecast_options: NotRequired[pulumi.Input['AlertPolicyConditionConditionThresholdForecastOptionsArgsDict']]
+        """
+        When this field is present, the `MetricThreshold`
+        condition forecasts whether the time series is
+        predicted to violate the threshold within the
+        `forecastHorizon`. When this field is not set, the
+        `MetricThreshold` tests the current value of the
+        timeseries against the threshold.
+        Structure is documented below.
+        """
+        threshold_value: NotRequired[pulumi.Input[float]]
+        """
+        A value against which to compare the time
+        series.
+        """
+        trigger: NotRequired[pulumi.Input['AlertPolicyConditionConditionThresholdTriggerArgsDict']]
+        """
+        The number/percent of time series for which
+        the comparison must hold in order for the
+        condition to trigger. If unspecified, then
+        the condition will trigger if the comparison
+        is true for any of the time series that have
+        been identified by filter and aggregations,
+        or by the ratio, if denominator_filter and
+        denominator_aggregations are specified.
+        Structure is documented below.
+        """
+elif False:
+    AlertPolicyConditionConditionThresholdArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertPolicyConditionConditionThresholdArgs:
     def __init__(__self__, *,
@@ -1456,32 +2063,124 @@ class AlertPolicyConditionConditionThresholdArgs:
         A value against which to compare the time
         series.
         """
-        return pulumi.get(self, "threshold_value")
-
-    @threshold_value.setter
-    def threshold_value(self, value: Optional[pulumi.Input[float]]):
-        pulumi.set(self, "threshold_value", value)
-
-    @property
-    @pulumi.getter
-    def trigger(self) -> Optional[pulumi.Input['AlertPolicyConditionConditionThresholdTriggerArgs']]:
+        return pulumi.get(self, "threshold_value")
+
+    @threshold_value.setter
+    def threshold_value(self, value: Optional[pulumi.Input[float]]):
+        pulumi.set(self, "threshold_value", value)
+
+    @property
+    @pulumi.getter
+    def trigger(self) -> Optional[pulumi.Input['AlertPolicyConditionConditionThresholdTriggerArgs']]:
+        """
+        The number/percent of time series for which
+        the comparison must hold in order for the
+        condition to trigger. If unspecified, then
+        the condition will trigger if the comparison
+        is true for any of the time series that have
+        been identified by filter and aggregations,
+        or by the ratio, if denominator_filter and
+        denominator_aggregations are specified.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "trigger")
+
+    @trigger.setter
+    def trigger(self, value: Optional[pulumi.Input['AlertPolicyConditionConditionThresholdTriggerArgs']]):
+        pulumi.set(self, "trigger", value)
+
+
+if not MYPY:
+    class AlertPolicyConditionConditionThresholdAggregationArgsDict(TypedDict):
+        alignment_period: NotRequired[pulumi.Input[str]]
+        """
+        The alignment period for per-time
+        series alignment. If present,
+        alignmentPeriod must be at least
+        60 seconds. After per-time series
+        alignment, each time series will
+        contain data points only on the
+        period boundaries. If
+        perSeriesAligner is not specified
+        or equals ALIGN_NONE, then this
+        field is ignored. If
+        perSeriesAligner is specified and
+        does not equal ALIGN_NONE, then
+        this field must be defined;
+        otherwise an error is returned.
+        """
+        cross_series_reducer: NotRequired[pulumi.Input[str]]
+        """
+        The approach to be used to combine
+        time series. Not all reducer
+        functions may be applied to all
+        time series, depending on the
+        metric type and the value type of
+        the original time series.
+        Reduction may change the metric
+        type of value type of the time
+        series.Time series data must be
+        aligned in order to perform cross-
+        time series reduction. If
+        crossSeriesReducer is specified,
+        then perSeriesAligner must be
+        specified and not equal ALIGN_NONE
+        and alignmentPeriod must be
+        specified; otherwise, an error is
+        returned.
+        Possible values are: `REDUCE_NONE`, `REDUCE_MEAN`, `REDUCE_MIN`, `REDUCE_MAX`, `REDUCE_SUM`, `REDUCE_STDDEV`, `REDUCE_COUNT`, `REDUCE_COUNT_TRUE`, `REDUCE_COUNT_FALSE`, `REDUCE_FRACTION_TRUE`, `REDUCE_PERCENTILE_99`, `REDUCE_PERCENTILE_95`, `REDUCE_PERCENTILE_50`, `REDUCE_PERCENTILE_05`.
+        """
+        group_by_fields: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The set of fields to preserve when
+        crossSeriesReducer is specified.
+        The groupByFields determine how
+        the time series are partitioned
+        into subsets prior to applying the
+        aggregation function. Each subset
+        contains time series that have the
+        same value for each of the
+        grouping fields. Each individual
+        time series is a member of exactly
+        one subset. The crossSeriesReducer
+        is applied to each subset of time
+        series. It is not possible to
+        reduce across different resource
+        types, so this field implicitly
+        contains resource.type. Fields not
+        specified in groupByFields are
+        aggregated away. If groupByFields
+        is not specified and all the time
+        series have the same resource
+        type, then the time series are
+        aggregated into a single output
+        time series. If crossSeriesReducer
+        is not defined, this field is
+        ignored.
+        """
+        per_series_aligner: NotRequired[pulumi.Input[str]]
         """
-        The number/percent of time series for which
-        the comparison must hold in order for the
-        condition to trigger. If unspecified, then
-        the condition will trigger if the comparison
-        is true for any of the time series that have
-        been identified by filter and aggregations,
-        or by the ratio, if denominator_filter and
-        denominator_aggregations are specified.
-        Structure is documented below.
+        The approach to be used to align
+        individual time series. Not all
+        alignment functions may be applied
+        to all time series, depending on
+        the metric type and value type of
+        the original time series.
+        Alignment may change the metric
+        type or the value type of the time
+        series.Time series data must be
+        aligned in order to perform cross-
+        time series reduction. If
+        crossSeriesReducer is specified,
+        then perSeriesAligner must be
+        specified and not equal ALIGN_NONE
+        and alignmentPeriod must be
+        specified; otherwise, an error is
+        returned.
+        Possible values are: `ALIGN_NONE`, `ALIGN_DELTA`, `ALIGN_RATE`, `ALIGN_INTERPOLATE`, `ALIGN_NEXT_OLDER`, `ALIGN_MIN`, `ALIGN_MAX`, `ALIGN_MEAN`, `ALIGN_COUNT`, `ALIGN_SUM`, `ALIGN_STDDEV`, `ALIGN_COUNT_TRUE`, `ALIGN_COUNT_FALSE`, `ALIGN_FRACTION_TRUE`, `ALIGN_PERCENTILE_99`, `ALIGN_PERCENTILE_95`, `ALIGN_PERCENTILE_50`, `ALIGN_PERCENTILE_05`, `ALIGN_PERCENT_CHANGE`.
         """
-        return pulumi.get(self, "trigger")
-
-    @trigger.setter
-    def trigger(self, value: Optional[pulumi.Input['AlertPolicyConditionConditionThresholdTriggerArgs']]):
-        pulumi.set(self, "trigger", value)
-
+elif False:
+    AlertPolicyConditionConditionThresholdAggregationArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class AlertPolicyConditionConditionThresholdAggregationArgs:
@@ -1696,6 +2395,98 @@ class AlertPolicyConditionConditionThresholdAggregationArgs:
         pulumi.set(self, "per_series_aligner", value)
 
 
+if not MYPY:
+    class AlertPolicyConditionConditionThresholdDenominatorAggregationArgsDict(TypedDict):
+        alignment_period: NotRequired[pulumi.Input[str]]
+        """
+        The alignment period for per-time
+        series alignment. If present,
+        alignmentPeriod must be at least
+        60 seconds. After per-time series
+        alignment, each time series will
+        contain data points only on the
+        period boundaries. If
+        perSeriesAligner is not specified
+        or equals ALIGN_NONE, then this
+        field is ignored. If
+        perSeriesAligner is specified and
+        does not equal ALIGN_NONE, then
+        this field must be defined;
+        otherwise an error is returned.
+        """
+        cross_series_reducer: NotRequired[pulumi.Input[str]]
+        """
+        The approach to be used to combine
+        time series. Not all reducer
+        functions may be applied to all
+        time series, depending on the
+        metric type and the value type of
+        the original time series.
+        Reduction may change the metric
+        type of value type of the time
+        series.Time series data must be
+        aligned in order to perform cross-
+        time series reduction. If
+        crossSeriesReducer is specified,
+        then perSeriesAligner must be
+        specified and not equal ALIGN_NONE
+        and alignmentPeriod must be
+        specified; otherwise, an error is
+        returned.
+        Possible values are: `REDUCE_NONE`, `REDUCE_MEAN`, `REDUCE_MIN`, `REDUCE_MAX`, `REDUCE_SUM`, `REDUCE_STDDEV`, `REDUCE_COUNT`, `REDUCE_COUNT_TRUE`, `REDUCE_COUNT_FALSE`, `REDUCE_FRACTION_TRUE`, `REDUCE_PERCENTILE_99`, `REDUCE_PERCENTILE_95`, `REDUCE_PERCENTILE_50`, `REDUCE_PERCENTILE_05`.
+        """
+        group_by_fields: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The set of fields to preserve when
+        crossSeriesReducer is specified.
+        The groupByFields determine how
+        the time series are partitioned
+        into subsets prior to applying the
+        aggregation function. Each subset
+        contains time series that have the
+        same value for each of the
+        grouping fields. Each individual
+        time series is a member of exactly
+        one subset. The crossSeriesReducer
+        is applied to each subset of time
+        series. It is not possible to
+        reduce across different resource
+        types, so this field implicitly
+        contains resource.type. Fields not
+        specified in groupByFields are
+        aggregated away. If groupByFields
+        is not specified and all the time
+        series have the same resource
+        type, then the time series are
+        aggregated into a single output
+        time series. If crossSeriesReducer
+        is not defined, this field is
+        ignored.
+        """
+        per_series_aligner: NotRequired[pulumi.Input[str]]
+        """
+        The approach to be used to align
+        individual time series. Not all
+        alignment functions may be applied
+        to all time series, depending on
+        the metric type and value type of
+        the original time series.
+        Alignment may change the metric
+        type or the value type of the time
+        series.Time series data must be
+        aligned in order to perform cross-
+        time series reduction. If
+        crossSeriesReducer is specified,
+        then perSeriesAligner must be
+        specified and not equal ALIGN_NONE
+        and alignmentPeriod must be
+        specified; otherwise, an error is
+        returned.
+        Possible values are: `ALIGN_NONE`, `ALIGN_DELTA`, `ALIGN_RATE`, `ALIGN_INTERPOLATE`, `ALIGN_NEXT_OLDER`, `ALIGN_MIN`, `ALIGN_MAX`, `ALIGN_MEAN`, `ALIGN_COUNT`, `ALIGN_SUM`, `ALIGN_STDDEV`, `ALIGN_COUNT_TRUE`, `ALIGN_COUNT_FALSE`, `ALIGN_FRACTION_TRUE`, `ALIGN_PERCENTILE_99`, `ALIGN_PERCENTILE_95`, `ALIGN_PERCENTILE_50`, `ALIGN_PERCENTILE_05`, `ALIGN_PERCENT_CHANGE`.
+        """
+elif False:
+    AlertPolicyConditionConditionThresholdDenominatorAggregationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertPolicyConditionConditionThresholdDenominatorAggregationArgs:
     def __init__(__self__, *,
@@ -1909,6 +2700,20 @@ class AlertPolicyConditionConditionThresholdDenominatorAggregationArgs:
         pulumi.set(self, "per_series_aligner", value)
 
 
+if not MYPY:
+    class AlertPolicyConditionConditionThresholdForecastOptionsArgsDict(TypedDict):
+        forecast_horizon: pulumi.Input[str]
+        """
+        The length of time into the future to forecast
+        whether a timeseries will violate the threshold.
+        If the predicted value is found to violate the
+        threshold, and the violation is observed in all
+        forecasts made for the Configured `duration`,
+        then the timeseries is considered to be failing.
+        """
+elif False:
+    AlertPolicyConditionConditionThresholdForecastOptionsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertPolicyConditionConditionThresholdForecastOptionsArgs:
     def __init__(__self__, *,
@@ -1941,6 +2746,23 @@ class AlertPolicyConditionConditionThresholdForecastOptionsArgs:
         pulumi.set(self, "forecast_horizon", value)
 
 
+if not MYPY:
+    class AlertPolicyConditionConditionThresholdTriggerArgsDict(TypedDict):
+        count: NotRequired[pulumi.Input[int]]
+        """
+        The absolute number of time series
+        that must fail the predicate for the
+        condition to be triggered.
+        """
+        percent: NotRequired[pulumi.Input[float]]
+        """
+        The percentage of time series that
+        must fail the predicate for the
+        condition to be triggered.
+        """
+elif False:
+    AlertPolicyConditionConditionThresholdTriggerArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertPolicyConditionConditionThresholdTriggerArgs:
     def __init__(__self__, *,
@@ -1988,6 +2810,21 @@ class AlertPolicyConditionConditionThresholdTriggerArgs:
         pulumi.set(self, "percent", value)
 
 
+if not MYPY:
+    class AlertPolicyCreationRecordArgsDict(TypedDict):
+        mutate_time: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        When the change occurred.
+        """
+        mutated_by: NotRequired[pulumi.Input[str]]
+        """
+        (Output)
+        The email address of the user making the change.
+        """
+elif False:
+    AlertPolicyCreationRecordArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertPolicyCreationRecordArgs:
     def __init__(__self__, *,
@@ -2031,10 +2868,40 @@ class AlertPolicyCreationRecordArgs:
         pulumi.set(self, "mutated_by", value)
 
 
+if not MYPY:
+    class AlertPolicyDocumentationArgsDict(TypedDict):
+        content: NotRequired[pulumi.Input[str]]
+        """
+        The text of the documentation, interpreted according to mimeType.
+        The content may not exceed 8,192 Unicode characters and may not
+        exceed more than 10,240 bytes when encoded in UTF-8 format,
+        whichever is smaller.
+        """
+        links: NotRequired[pulumi.Input[Sequence[pulumi.Input['AlertPolicyDocumentationLinkArgsDict']]]]
+        """
+        Links to content such as playbooks, repositories, and other resources. This field can contain up to 3 entries.
+        Structure is documented below.
+        """
+        mime_type: NotRequired[pulumi.Input[str]]
+        """
+        The format of the content field. Presently, only the value
+        "text/markdown" is supported.
+        """
+        subject: NotRequired[pulumi.Input[str]]
+        """
+        The subject line of the notification. The subject line may not
+        exceed 10,240 bytes. In notifications generated by this policy the contents
+        of the subject line after variable expansion will be truncated to 255 bytes
+        or shorter at the latest UTF-8 character boundary.
+        """
+elif False:
+    AlertPolicyDocumentationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class AlertPolicyDocumentationArgs:
     def __init__(__self__, *,
                  content: Optional[pulumi.Input[str]] = None,
+                 links: Optional[pulumi.Input[Sequence[pulumi.Input['AlertPolicyDocumentationLinkArgs']]]] = None,
                  mime_type: Optional[pulumi.Input[str]] = None,
                  subject: Optional[pulumi.Input[str]] = None):
         """
@@ -2042,6 +2909,8 @@ class AlertPolicyDocumentationArgs:
                The content may not exceed 8,192 Unicode characters and may not
                exceed more than 10,240 bytes when encoded in UTF-8 format,
                whichever is smaller.
+        :param pulumi.Input[Sequence[pulumi.Input['AlertPolicyDocumentationLinkArgs']]] links: Links to content such as playbooks, repositories, and other resources. This field can contain up to 3 entries.
+               Structure is documented below.
         :param pulumi.Input[str] mime_type: The format of the content field. Presently, only the value
                "text/markdown" is supported.
         :param pulumi.Input[str] subject: The subject line of the notification. The subject line may not
@@ -2051,6 +2920,8 @@ class AlertPolicyDocumentationArgs:
         """
         if content is not None:
             pulumi.set(__self__, "content", content)
+        if links is not None:
+            pulumi.set(__self__, "links", links)
         if mime_type is not None:
             pulumi.set(__self__, "mime_type", mime_type)
         if subject is not None:
@@ -2071,6 +2942,19 @@ class AlertPolicyDocumentationArgs:
     def content(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "content", value)
 
+    @property
+    @pulumi.getter
+    def links(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['AlertPolicyDocumentationLinkArgs']]]]:
+        """
+        Links to content such as playbooks, repositories, and other resources. This field can contain up to 3 entries.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "links")
+
+    @links.setter
+    def links(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['AlertPolicyDocumentationLinkArgs']]]]):
+        pulumi.set(self, "links", value)
+
     @property
     @pulumi.getter(name="mimeType")
     def mime_type(self) -> Optional[pulumi.Input[str]]:
@@ -2100,6 +2984,69 @@ class AlertPolicyDocumentationArgs:
         pulumi.set(self, "subject", value)
 
 
+if not MYPY:
+    class AlertPolicyDocumentationLinkArgsDict(TypedDict):
+        display_name: NotRequired[pulumi.Input[str]]
+        """
+        A short display name for the link. The display name must not be empty or exceed 63 characters. Example: "playbook".
+        """
+        url: NotRequired[pulumi.Input[str]]
+        """
+        The url of a webpage. A url can be templatized by using variables in the path or the query parameters. The total length of a URL should not exceed 2083 characters before and after variable expansion. Example: "https://my_domain.com/playbook?name=${resource.name}".
+        """
+elif False:
+    AlertPolicyDocumentationLinkArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class AlertPolicyDocumentationLinkArgs:
+    def __init__(__self__, *,
+                 display_name: Optional[pulumi.Input[str]] = None,
+                 url: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] display_name: A short display name for the link. The display name must not be empty or exceed 63 characters. Example: "playbook".
+        :param pulumi.Input[str] url: The url of a webpage. A url can be templatized by using variables in the path or the query parameters. The total length of a URL should not exceed 2083 characters before and after variable expansion. Example: "https://my_domain.com/playbook?name=${resource.name}".
+        """
+        if display_name is not None:
+            pulumi.set(__self__, "display_name", display_name)
+        if url is not None:
+            pulumi.set(__self__, "url", url)
+
+    @property
+    @pulumi.getter(name="displayName")
+    def display_name(self) -> Optional[pulumi.Input[str]]:
+        """
+        A short display name for the link. The display name must not be empty or exceed 63 characters. Example: "playbook".
+        """
+        return pulumi.get(self, "display_name")
+
+    @display_name.setter
+    def display_name(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "display_name", value)
+
+    @property
+    @pulumi.getter
+    def url(self) -> Optional[pulumi.Input[str]]:
+        """
+        The url of a webpage. A url can be templatized by using variables in the path or the query parameters. The total length of a URL should not exceed 2083 characters before and after variable expansion. Example: "https://my_domain.com/playbook?name=${resource.name}".
+        """
+        return pulumi.get(self, "url")
+
+    @url.setter
+    def url(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "url", value)
+
+
+if not MYPY:
+    class CustomServiceTelemetryArgsDict(TypedDict):
+        resource_name: NotRequired[pulumi.Input[str]]
+        """
+        The full name of the resource that defines this service.
+        Formatted as described in
+        https://cloud.google.com/apis/design/resource_names.
+        """
+elif False:
+    CustomServiceTelemetryArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class CustomServiceTelemetryArgs:
     def __init__(__self__, *,
@@ -2127,6 +3074,21 @@ class CustomServiceTelemetryArgs:
         pulumi.set(self, "resource_name", value)
 
 
+if not MYPY:
+    class GenericServiceBasicServiceArgsDict(TypedDict):
+        service_labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        Labels that specify the resource that emits the monitoring data
+        which is used for SLO reporting of this `Service`.
+        """
+        service_type: NotRequired[pulumi.Input[str]]
+        """
+        The type of service that this basic service defines, e.g.
+        APP_ENGINE service type
+        """
+elif False:
+    GenericServiceBasicServiceArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GenericServiceBasicServiceArgs:
     def __init__(__self__, *,
@@ -2170,6 +3132,17 @@ class GenericServiceBasicServiceArgs:
         pulumi.set(self, "service_type", value)
 
 
+if not MYPY:
+    class GenericServiceTelemetryArgsDict(TypedDict):
+        resource_name: NotRequired[pulumi.Input[str]]
+        """
+        The full name of the resource that defines this service.
+        Formatted as described in
+        https://cloud.google.com/apis/design/resource_names.
+        """
+elif False:
+    GenericServiceTelemetryArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class GenericServiceTelemetryArgs:
     def __init__(__self__, *,
@@ -2197,6 +3170,25 @@ class GenericServiceTelemetryArgs:
         pulumi.set(self, "resource_name", value)
 
 
+if not MYPY:
+    class MetricDescriptorLabelArgsDict(TypedDict):
+        key: pulumi.Input[str]
+        """
+        The key for this label. The key must not exceed 100 characters. The first character of the key must be an upper- or lower-case letter, the remaining characters must be letters, digits or underscores, and the key must match the regular expression [a-zA-Z][a-zA-Z0-9_]*
+        """
+        description: NotRequired[pulumi.Input[str]]
+        """
+        A human-readable description for the label.
+        """
+        value_type: NotRequired[pulumi.Input[str]]
+        """
+        The type of data that can be assigned to the label.
+        Default value is `STRING`.
+        Possible values are: `STRING`, `BOOL`, `INT64`.
+        """
+elif False:
+    MetricDescriptorLabelArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetricDescriptorLabelArgs:
     def __init__(__self__, *,
@@ -2255,6 +3247,19 @@ class MetricDescriptorLabelArgs:
         pulumi.set(self, "value_type", value)
 
 
+if not MYPY:
+    class MetricDescriptorMetadataArgsDict(TypedDict):
+        ingest_delay: NotRequired[pulumi.Input[str]]
+        """
+        The delay of data points caused by ingestion. Data points older than this age are guaranteed to be ingested and available to be read, excluding data loss due to errors. In `[duration format](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf?&_ga=2.264881487.1507873253.1593446723-935052455.1591817775#google.protobuf.Duration)`.
+        """
+        sample_period: NotRequired[pulumi.Input[str]]
+        """
+        The sampling period of metric data points. For metrics which are written periodically, consecutive data points are stored at this time interval, excluding data loss due to errors. Metrics with a higher granularity have a smaller sampling period. In `[duration format](https://developers.google.com/protocol-buffers/docs/reference/google.protobuf?&_ga=2.264881487.1507873253.1593446723-935052455.1591817775#google.protobuf.Duration)`.
+        """
+elif False:
+    MetricDescriptorMetadataArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class MetricDescriptorMetadataArgs:
     def __init__(__self__, *,
@@ -2294,6 +3299,26 @@ class MetricDescriptorMetadataArgs:
         pulumi.set(self, "sample_period", value)
 
 
+if not MYPY:
+    class NotificationChannelSensitiveLabelsArgsDict(TypedDict):
+        auth_token: NotRequired[pulumi.Input[str]]
+        """
+        An authorization token for a notification channel. Channel types that support this field include: slack
+        **Note**: This property is sensitive and will not be displayed in the plan.
+        """
+        password: NotRequired[pulumi.Input[str]]
+        """
+        An password for a notification channel. Channel types that support this field include: webhook_basicauth
+        **Note**: This property is sensitive and will not be displayed in the plan.
+        """
+        service_key: NotRequired[pulumi.Input[str]]
+        """
+        An servicekey token for a notification channel. Channel types that support this field include: pagerduty
+        **Note**: This property is sensitive and will not be displayed in the plan.
+        """
+elif False:
+    NotificationChannelSensitiveLabelsArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class NotificationChannelSensitiveLabelsArgs:
     def __init__(__self__, *,
@@ -2355,6 +3380,48 @@ class NotificationChannelSensitiveLabelsArgs:
         pulumi.set(self, "service_key", value)
 
 
+if not MYPY:
+    class SloBasicSliArgsDict(TypedDict):
+        availability: NotRequired[pulumi.Input['SloBasicSliAvailabilityArgsDict']]
+        """
+        Availability based SLI, dervied from count of requests made to this service that return successfully.
+        Structure is documented below.
+        """
+        latency: NotRequired[pulumi.Input['SloBasicSliLatencyArgsDict']]
+        """
+        Parameters for a latency threshold SLI.
+        Structure is documented below.
+        """
+        locations: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        An optional set of locations to which this SLI is relevant.
+        Telemetry from other locations will not be used to calculate
+        performance for this SLI. If omitted, this SLI applies to all
+        locations in which the Service has activity. For service types
+        that don't support breaking down by location, setting this
+        field will result in an error.
+        """
+        methods: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        An optional set of RPCs to which this SLI is relevant.
+        Telemetry from other methods will not be used to calculate
+        performance for this SLI. If omitted, this SLI applies to all
+        the Service's methods. For service types that don't support
+        breaking down by method, setting this field will result in an
+        error.
+        """
+        versions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The set of API versions to which this SLI is relevant.
+        Telemetry from other API versions will not be used to
+        calculate performance for this SLI. If omitted,
+        this SLI applies to all API versions. For service types
+        that don't support breaking down by version, setting this
+        field will result in an error.
+        """
+elif False:
+    SloBasicSliArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloBasicSliArgs:
     def __init__(__self__, *,
@@ -2476,6 +3543,15 @@ class SloBasicSliArgs:
         pulumi.set(self, "versions", value)
 
 
+if not MYPY:
+    class SloBasicSliAvailabilityArgsDict(TypedDict):
+        enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Whether an availability SLI is enabled or not. Must be set to `true. Defaults to `true`.
+        """
+elif False:
+    SloBasicSliAvailabilityArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloBasicSliAvailabilityArgs:
     def __init__(__self__, *,
@@ -2499,6 +3575,17 @@ class SloBasicSliAvailabilityArgs:
         pulumi.set(self, "enabled", value)
 
 
+if not MYPY:
+    class SloBasicSliLatencyArgsDict(TypedDict):
+        threshold: pulumi.Input[str]
+        """
+        A duration string, e.g. 10s.
+        Good service is defined to be the count of requests made to
+        this service that return in no more than threshold.
+        """
+elif False:
+    SloBasicSliLatencyArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloBasicSliLatencyArgs:
     def __init__(__self__, *,
@@ -2525,6 +3612,31 @@ class SloBasicSliLatencyArgs:
         pulumi.set(self, "threshold", value)
 
 
+if not MYPY:
+    class SloRequestBasedSliArgsDict(TypedDict):
+        distribution_cut: NotRequired[pulumi.Input['SloRequestBasedSliDistributionCutArgsDict']]
+        """
+        Used when good_service is defined by a count of values aggregated in a
+        Distribution that fall into a good range. The total_service is the
+        total count of all values aggregated in the Distribution.
+        Defines a distribution TimeSeries filter and thresholds used for
+        measuring good service and total service.
+        Exactly one of `distribution_cut` or `good_total_ratio` can be set.
+        Structure is documented below.
+        """
+        good_total_ratio: NotRequired[pulumi.Input['SloRequestBasedSliGoodTotalRatioArgsDict']]
+        """
+        A means to compute a ratio of `good_service` to `total_service`.
+        Defines computing this ratio with two TimeSeries [monitoring filters](https://cloud.google.com/monitoring/api/v3/filters)
+        Must specify exactly two of good, bad, and total service filters.
+        The relationship good_service + bad_service = total_service
+        will be assumed.
+        Exactly one of `distribution_cut` or `good_total_ratio` can be set.
+        Structure is documented below.
+        """
+elif False:
+    SloRequestBasedSliArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloRequestBasedSliArgs:
     def __init__(__self__, *,
@@ -2588,6 +3700,27 @@ class SloRequestBasedSliArgs:
         pulumi.set(self, "good_total_ratio", value)
 
 
+if not MYPY:
+    class SloRequestBasedSliDistributionCutArgsDict(TypedDict):
+        distribution_filter: pulumi.Input[str]
+        """
+        A TimeSeries [monitoring filter](https://cloud.google.com/monitoring/api/v3/filters)
+        aggregating values to quantify the good service provided.
+        Must have ValueType = DISTRIBUTION and
+        MetricKind = DELTA or MetricKind = CUMULATIVE.
+        """
+        range: pulumi.Input['SloRequestBasedSliDistributionCutRangeArgsDict']
+        """
+        Range of numerical values. The computed good_service
+        will be the count of values x in the Distribution such
+        that range.min <= x <= range.max. inclusive of min and
+        max. Open ranges can be defined by setting
+        just one of min or max.
+        Structure is documented below.
+        """
+elif False:
+    SloRequestBasedSliDistributionCutArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloRequestBasedSliDistributionCutArgs:
     def __init__(__self__, *,
@@ -2641,6 +3774,23 @@ class SloRequestBasedSliDistributionCutArgs:
         pulumi.set(self, "range", value)
 
 
+if not MYPY:
+    class SloRequestBasedSliDistributionCutRangeArgsDict(TypedDict):
+        max: NotRequired[pulumi.Input[float]]
+        """
+        max value for the range (inclusive). If not given,
+        will be set to "infinity", defining an open range
+        ">= range.min"
+        """
+        min: NotRequired[pulumi.Input[float]]
+        """
+        Min value for the range (inclusive). If not given,
+        will be set to "-infinity", defining an open range
+        "< range.max"
+        """
+elif False:
+    SloRequestBasedSliDistributionCutRangeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloRequestBasedSliDistributionCutRangeArgs:
     def __init__(__self__, *,
@@ -2688,6 +3838,40 @@ class SloRequestBasedSliDistributionCutRangeArgs:
         pulumi.set(self, "min", value)
 
 
+if not MYPY:
+    class SloRequestBasedSliGoodTotalRatioArgsDict(TypedDict):
+        bad_service_filter: NotRequired[pulumi.Input[str]]
+        """
+        A TimeSeries [monitoring filter](https://cloud.google.com/monitoring/api/v3/filters)
+        quantifying bad service provided, either demanded service that
+        was not provided or demanded service that was of inadequate
+        quality. Exactly two of
+        good, bad, or total service filter must be defined (where
+        good + bad = total is assumed)
+        Must have ValueType = DOUBLE or ValueType = INT64 and
+        must have MetricKind = DELTA or MetricKind = CUMULATIVE.
+        """
+        good_service_filter: NotRequired[pulumi.Input[str]]
+        """
+        A TimeSeries [monitoring filter](https://cloud.google.com/monitoring/api/v3/filters)
+        quantifying good service provided. Exactly two of
+        good, bad, or total service filter must be defined (where
+        good + bad = total is assumed)
+        Must have ValueType = DOUBLE or ValueType = INT64 and
+        must have MetricKind = DELTA or MetricKind = CUMULATIVE.
+        """
+        total_service_filter: NotRequired[pulumi.Input[str]]
+        """
+        A TimeSeries [monitoring filter](https://cloud.google.com/monitoring/api/v3/filters)
+        quantifying total demanded service. Exactly two of
+        good, bad, or total service filter must be defined (where
+        good + bad = total is assumed)
+        Must have ValueType = DOUBLE or ValueType = INT64 and
+        must have MetricKind = DELTA or MetricKind = CUMULATIVE.
+        """
+elif False:
+    SloRequestBasedSliGoodTotalRatioArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloRequestBasedSliGoodTotalRatioArgs:
     def __init__(__self__, *,
@@ -2777,6 +3961,55 @@ class SloRequestBasedSliGoodTotalRatioArgs:
         pulumi.set(self, "total_service_filter", value)
 
 
+if not MYPY:
+    class SloWindowsBasedSliArgsDict(TypedDict):
+        good_bad_metric_filter: NotRequired[pulumi.Input[str]]
+        """
+        A TimeSeries [monitoring filter](https://cloud.google.com/monitoring/api/v3/filters)
+        with ValueType = BOOL. The window is good if any true values
+        appear in the window. One of `good_bad_metric_filter`,
+        `good_total_ratio_threshold`, `metric_mean_in_range`,
+        `metric_sum_in_range` must be set for `windows_based_sli`.
+        """
+        good_total_ratio_threshold: NotRequired[pulumi.Input['SloWindowsBasedSliGoodTotalRatioThresholdArgsDict']]
+        """
+        Criterion that describes a window as good if its performance is
+        high enough. One of `good_bad_metric_filter`,
+        `good_total_ratio_threshold`, `metric_mean_in_range`,
+        `metric_sum_in_range` must be set for `windows_based_sli`.
+        Structure is documented below.
+        """
+        metric_mean_in_range: NotRequired[pulumi.Input['SloWindowsBasedSliMetricMeanInRangeArgsDict']]
+        """
+        Criterion that describes a window as good if the metric's value
+        is in a good range, *averaged* across returned streams.
+        One of `good_bad_metric_filter`,
+        `good_total_ratio_threshold`, `metric_mean_in_range`,
+        `metric_sum_in_range` must be set for `windows_based_sli`.
+        Average value X of `time_series` should satisfy
+        `range.min <= X <= range.max` for a good window.
+        Structure is documented below.
+        """
+        metric_sum_in_range: NotRequired[pulumi.Input['SloWindowsBasedSliMetricSumInRangeArgsDict']]
+        """
+        Criterion that describes a window as good if the metric's value
+        is in a good range, *summed* across returned streams.
+        Summed value `X` of `time_series` should satisfy
+        `range.min <= X <= range.max` for a good window.
+        One of `good_bad_metric_filter`,
+        `good_total_ratio_threshold`, `metric_mean_in_range`,
+        `metric_sum_in_range` must be set for `windows_based_sli`.
+        Structure is documented below.
+        """
+        window_period: NotRequired[pulumi.Input[str]]
+        """
+        Duration over which window quality is evaluated, given as a
+        duration string "{X}s" representing X seconds. Must be an
+        integer fraction of a day and at least 60s.
+        """
+elif False:
+    SloWindowsBasedSliArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloWindowsBasedSliArgs:
     def __init__(__self__, *,
@@ -2912,6 +4145,26 @@ class SloWindowsBasedSliArgs:
         pulumi.set(self, "window_period", value)
 
 
+if not MYPY:
+    class SloWindowsBasedSliGoodTotalRatioThresholdArgsDict(TypedDict):
+        basic_sli_performance: NotRequired[pulumi.Input['SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceArgsDict']]
+        """
+        Basic SLI to evaluate to judge window quality.
+        Structure is documented below.
+        """
+        performance: NotRequired[pulumi.Input['SloWindowsBasedSliGoodTotalRatioThresholdPerformanceArgsDict']]
+        """
+        Request-based SLI to evaluate to judge window quality.
+        Structure is documented below.
+        """
+        threshold: NotRequired[pulumi.Input[float]]
+        """
+        If window performance >= threshold, the window is counted
+        as good.
+        """
+elif False:
+    SloWindowsBasedSliGoodTotalRatioThresholdArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloWindowsBasedSliGoodTotalRatioThresholdArgs:
     def __init__(__self__, *,
@@ -2973,6 +4226,48 @@ class SloWindowsBasedSliGoodTotalRatioThresholdArgs:
         pulumi.set(self, "threshold", value)
 
 
+if not MYPY:
+    class SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceArgsDict(TypedDict):
+        availability: NotRequired[pulumi.Input['SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceAvailabilityArgsDict']]
+        """
+        Availability based SLI, dervied from count of requests made to this service that return successfully.
+        Structure is documented below.
+        """
+        latency: NotRequired[pulumi.Input['SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceLatencyArgsDict']]
+        """
+        Parameters for a latency threshold SLI.
+        Structure is documented below.
+        """
+        locations: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        An optional set of locations to which this SLI is relevant.
+        Telemetry from other locations will not be used to calculate
+        performance for this SLI. If omitted, this SLI applies to all
+        locations in which the Service has activity. For service types
+        that don't support breaking down by location, setting this
+        field will result in an error.
+        """
+        methods: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        An optional set of RPCs to which this SLI is relevant.
+        Telemetry from other methods will not be used to calculate
+        performance for this SLI. If omitted, this SLI applies to all
+        the Service's methods. For service types that don't support
+        breaking down by method, setting this field will result in an
+        error.
+        """
+        versions: NotRequired[pulumi.Input[Sequence[pulumi.Input[str]]]]
+        """
+        The set of API versions to which this SLI is relevant.
+        Telemetry from other API versions will not be used to
+        calculate performance for this SLI. If omitted,
+        this SLI applies to all API versions. For service types
+        that don't support breaking down by version, setting this
+        field will result in an error.
+        """
+elif False:
+    SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceArgs:
     def __init__(__self__, *,
@@ -3094,6 +4389,15 @@ class SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceArgs:
         pulumi.set(self, "versions", value)
 
 
+if not MYPY:
+    class SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceAvailabilityArgsDict(TypedDict):
+        enabled: NotRequired[pulumi.Input[bool]]
+        """
+        Whether an availability SLI is enabled or not. Must be set to `true. Defaults to `true`.
+        """
+elif False:
+    SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceAvailabilityArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceAvailabilityArgs:
     def __init__(__self__, *,
@@ -3117,6 +4421,17 @@ class SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceAvailabilityAr
         pulumi.set(self, "enabled", value)
 
 
+if not MYPY:
+    class SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceLatencyArgsDict(TypedDict):
+        threshold: pulumi.Input[str]
+        """
+        A duration string, e.g. 10s.
+        Good service is defined to be the count of requests made to
+        this service that return in no more than threshold.
+        """
+elif False:
+    SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceLatencyArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceLatencyArgs:
     def __init__(__self__, *,
@@ -3136,12 +4451,35 @@ class SloWindowsBasedSliGoodTotalRatioThresholdBasicSliPerformanceLatencyArgs:
         Good service is defined to be the count of requests made to
         this service that return in no more than threshold.
         """
-        return pulumi.get(self, "threshold")
-
-    @threshold.setter
-    def threshold(self, value: pulumi.Input[str]):
-        pulumi.set(self, "threshold", value)
-
+        return pulumi.get(self, "threshold")
+
+    @threshold.setter
+    def threshold(self, value: pulumi.Input[str]):
+        pulumi.set(self, "threshold", value)
+
+
+if not MYPY:
+    class SloWindowsBasedSliGoodTotalRatioThresholdPerformanceArgsDict(TypedDict):
+        distribution_cut: NotRequired[pulumi.Input['SloWindowsBasedSliGoodTotalRatioThresholdPerformanceDistributionCutArgsDict']]
+        """
+        Used when good_service is defined by a count of values aggregated in a
+        Distribution that fall into a good range. The total_service is the
+        total count of all values aggregated in the Distribution.
+        Defines a distribution TimeSeries filter and thresholds used for
+        measuring good service and total service.
+        Structure is documented below.
+        """
+        good_total_ratio: NotRequired[pulumi.Input['SloWindowsBasedSliGoodTotalRatioThresholdPerformanceGoodTotalRatioArgsDict']]
+        """
+        A means to compute a ratio of `good_service` to `total_service`.
+        Defines computing this ratio with two TimeSeries [monitoring filters](https://cloud.google.com/monitoring/api/v3/filters)
+        Must specify exactly two of good, bad, and total service filters.
+        The relationship good_service + bad_service = total_service
+        will be assumed.
+        Structure is documented below.
+        """
+elif False:
+    SloWindowsBasedSliGoodTotalRatioThresholdPerformanceArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class SloWindowsBasedSliGoodTotalRatioThresholdPerformanceArgs:
@@ -3202,6 +4540,27 @@ class SloWindowsBasedSliGoodTotalRatioThresholdPerformanceArgs:
         pulumi.set(self, "good_total_ratio", value)
 
 
+if not MYPY:
+    class SloWindowsBasedSliGoodTotalRatioThresholdPerformanceDistributionCutArgsDict(TypedDict):
+        distribution_filter: pulumi.Input[str]
+        """
+        A TimeSeries [monitoring filter](https://cloud.google.com/monitoring/api/v3/filters)
+        aggregating values to quantify the good service provided.
+        Must have ValueType = DISTRIBUTION and
+        MetricKind = DELTA or MetricKind = CUMULATIVE.
+        """
+        range: pulumi.Input['SloWindowsBasedSliGoodTotalRatioThresholdPerformanceDistributionCutRangeArgsDict']
+        """
+        Range of numerical values. The computed good_service
+        will be the count of values x in the Distribution such
+        that range.min <= x <= range.max. inclusive of min and
+        max. Open ranges can be defined by setting
+        just one of min or max.
+        Structure is documented below.
+        """
+elif False:
+    SloWindowsBasedSliGoodTotalRatioThresholdPerformanceDistributionCutArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloWindowsBasedSliGoodTotalRatioThresholdPerformanceDistributionCutArgs:
     def __init__(__self__, *,
@@ -3255,6 +4614,23 @@ class SloWindowsBasedSliGoodTotalRatioThresholdPerformanceDistributionCutArgs:
         pulumi.set(self, "range", value)
 
 
+if not MYPY:
+    class SloWindowsBasedSliGoodTotalRatioThresholdPerformanceDistributionCutRangeArgsDict(TypedDict):
+        max: NotRequired[pulumi.Input[float]]
+        """
+        max value for the range (inclusive). If not given,
+        will be set to "infinity", defining an open range
+        ">= range.min"
+        """
+        min: NotRequired[pulumi.Input[float]]
+        """
+        Min value for the range (inclusive). If not given,
+        will be set to "-infinity", defining an open range
+        "< range.max"
+        """
+elif False:
+    SloWindowsBasedSliGoodTotalRatioThresholdPerformanceDistributionCutRangeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloWindowsBasedSliGoodTotalRatioThresholdPerformanceDistributionCutRangeArgs:
     def __init__(__self__, *,
@@ -3302,6 +4678,40 @@ class SloWindowsBasedSliGoodTotalRatioThresholdPerformanceDistributionCutRangeAr
         pulumi.set(self, "min", value)
 
 
+if not MYPY:
+    class SloWindowsBasedSliGoodTotalRatioThresholdPerformanceGoodTotalRatioArgsDict(TypedDict):
+        bad_service_filter: NotRequired[pulumi.Input[str]]
+        """
+        A TimeSeries [monitoring filter](https://cloud.google.com/monitoring/api/v3/filters)
+        quantifying bad service provided, either demanded service that
+        was not provided or demanded service that was of inadequate
+        quality. Exactly two of
+        good, bad, or total service filter must be defined (where
+        good + bad = total is assumed)
+        Must have ValueType = DOUBLE or ValueType = INT64 and
+        must have MetricKind = DELTA or MetricKind = CUMULATIVE.
+        """
+        good_service_filter: NotRequired[pulumi.Input[str]]
+        """
+        A TimeSeries [monitoring filter](https://cloud.google.com/monitoring/api/v3/filters)
+        quantifying good service provided. Exactly two of
+        good, bad, or total service filter must be defined (where
+        good + bad = total is assumed)
+        Must have ValueType = DOUBLE or ValueType = INT64 and
+        must have MetricKind = DELTA or MetricKind = CUMULATIVE.
+        """
+        total_service_filter: NotRequired[pulumi.Input[str]]
+        """
+        A TimeSeries [monitoring filter](https://cloud.google.com/monitoring/api/v3/filters)
+        quantifying total demanded service. Exactly two of
+        good, bad, or total service filter must be defined (where
+        good + bad = total is assumed)
+        Must have ValueType = DOUBLE or ValueType = INT64 and
+        must have MetricKind = DELTA or MetricKind = CUMULATIVE.
+        """
+elif False:
+    SloWindowsBasedSliGoodTotalRatioThresholdPerformanceGoodTotalRatioArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloWindowsBasedSliGoodTotalRatioThresholdPerformanceGoodTotalRatioArgs:
     def __init__(__self__, *,
@@ -3391,6 +4801,31 @@ class SloWindowsBasedSliGoodTotalRatioThresholdPerformanceGoodTotalRatioArgs:
         pulumi.set(self, "total_service_filter", value)
 
 
+if not MYPY:
+    class SloWindowsBasedSliMetricMeanInRangeArgsDict(TypedDict):
+        range: pulumi.Input['SloWindowsBasedSliMetricMeanInRangeRangeArgsDict']
+        """
+        Range of numerical values. The computed good_service
+        will be the count of values x in the Distribution such
+        that range.min <= x <= range.max. inclusive of min and
+        max. Open ranges can be defined by setting
+        just one of min or max. Mean value `X` of `time_series`
+        values should satisfy `range.min <= X <= range.max` for a
+        good service.
+        Structure is documented below.
+        """
+        time_series: pulumi.Input[str]
+        """
+        A [monitoring filter](https://cloud.google.com/monitoring/api/v3/filters)
+        specifying the TimeSeries to use for evaluating window
+        The provided TimeSeries must have ValueType = INT64 or
+        ValueType = DOUBLE and MetricKind = GAUGE. Mean value `X`
+        should satisfy `range.min <= X <= range.max`
+        under good service.
+        """
+elif False:
+    SloWindowsBasedSliMetricMeanInRangeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloWindowsBasedSliMetricMeanInRangeArgs:
     def __init__(__self__, *,
@@ -3452,6 +4887,23 @@ class SloWindowsBasedSliMetricMeanInRangeArgs:
         pulumi.set(self, "time_series", value)
 
 
+if not MYPY:
+    class SloWindowsBasedSliMetricMeanInRangeRangeArgsDict(TypedDict):
+        max: NotRequired[pulumi.Input[float]]
+        """
+        max value for the range (inclusive). If not given,
+        will be set to "infinity", defining an open range
+        ">= range.min"
+        """
+        min: NotRequired[pulumi.Input[float]]
+        """
+        Min value for the range (inclusive). If not given,
+        will be set to "-infinity", defining an open range
+        "< range.max"
+        """
+elif False:
+    SloWindowsBasedSliMetricMeanInRangeRangeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloWindowsBasedSliMetricMeanInRangeRangeArgs:
     def __init__(__self__, *,
@@ -3499,6 +4951,31 @@ class SloWindowsBasedSliMetricMeanInRangeRangeArgs:
         pulumi.set(self, "min", value)
 
 
+if not MYPY:
+    class SloWindowsBasedSliMetricSumInRangeArgsDict(TypedDict):
+        range: pulumi.Input['SloWindowsBasedSliMetricSumInRangeRangeArgsDict']
+        """
+        Range of numerical values. The computed good_service
+        will be the count of values x in the Distribution such
+        that range.min <= x <= range.max. inclusive of min and
+        max. Open ranges can be defined by setting
+        just one of min or max. Summed value `X` should satisfy
+        `range.min <= X <= range.max` for a good window.
+        Structure is documented below.
+        """
+        time_series: pulumi.Input[str]
+        """
+        A [monitoring filter](https://cloud.google.com/monitoring/api/v3/filters)
+        specifying the TimeSeries to use for evaluating window
+        quality. The provided TimeSeries must have
+        ValueType = INT64 or ValueType = DOUBLE and
+        MetricKind = GAUGE.
+        Summed value `X` should satisfy
+        `range.min <= X <= range.max` for a good window.
+        """
+elif False:
+    SloWindowsBasedSliMetricSumInRangeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloWindowsBasedSliMetricSumInRangeArgs:
     def __init__(__self__, *,
@@ -3560,6 +5037,23 @@ class SloWindowsBasedSliMetricSumInRangeArgs:
         pulumi.set(self, "time_series", value)
 
 
+if not MYPY:
+    class SloWindowsBasedSliMetricSumInRangeRangeArgsDict(TypedDict):
+        max: NotRequired[pulumi.Input[float]]
+        """
+        max value for the range (inclusive). If not given,
+        will be set to "infinity", defining an open range
+        ">= range.min"
+        """
+        min: NotRequired[pulumi.Input[float]]
+        """
+        Min value for the range (inclusive). If not given,
+        will be set to "-infinity", defining an open range
+        "< range.max"
+        """
+elif False:
+    SloWindowsBasedSliMetricSumInRangeRangeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class SloWindowsBasedSliMetricSumInRangeRangeArgs:
     def __init__(__self__, *,
@@ -3607,6 +5101,26 @@ class SloWindowsBasedSliMetricSumInRangeRangeArgs:
         pulumi.set(self, "min", value)
 
 
+if not MYPY:
+    class UptimeCheckConfigContentMatcherArgsDict(TypedDict):
+        content: pulumi.Input[str]
+        """
+        String or regex content to match (max 1024 bytes)
+        """
+        json_path_matcher: NotRequired[pulumi.Input['UptimeCheckConfigContentMatcherJsonPathMatcherArgsDict']]
+        """
+        Information needed to perform a JSONPath content match. Used for `ContentMatcherOption::MATCHES_JSON_PATH` and `ContentMatcherOption::NOT_MATCHES_JSON_PATH`.
+        Structure is documented below.
+        """
+        matcher: NotRequired[pulumi.Input[str]]
+        """
+        The type of content matcher that will be applied to the server output, compared to the content string when the check is run.
+        Default value is `CONTAINS_STRING`.
+        Possible values are: `CONTAINS_STRING`, `NOT_CONTAINS_STRING`, `MATCHES_REGEX`, `NOT_MATCHES_REGEX`, `MATCHES_JSON_PATH`, `NOT_MATCHES_JSON_PATH`.
+        """
+elif False:
+    UptimeCheckConfigContentMatcherArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class UptimeCheckConfigContentMatcherArgs:
     def __init__(__self__, *,
@@ -3667,6 +5181,21 @@ class UptimeCheckConfigContentMatcherArgs:
         pulumi.set(self, "matcher", value)
 
 
+if not MYPY:
+    class UptimeCheckConfigContentMatcherJsonPathMatcherArgsDict(TypedDict):
+        json_path: pulumi.Input[str]
+        """
+        JSONPath within the response output pointing to the expected `ContentMatcher::content` to match against.
+        """
+        json_matcher: NotRequired[pulumi.Input[str]]
+        """
+        Options to perform JSONPath content matching.
+        Default value is `EXACT_MATCH`.
+        Possible values are: `EXACT_MATCH`, `REGEX_MATCH`.
+        """
+elif False:
+    UptimeCheckConfigContentMatcherJsonPathMatcherArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class UptimeCheckConfigContentMatcherJsonPathMatcherArgs:
     def __init__(__self__, *,
@@ -3709,6 +5238,74 @@ class UptimeCheckConfigContentMatcherJsonPathMatcherArgs:
         pulumi.set(self, "json_matcher", value)
 
 
+if not MYPY:
+    class UptimeCheckConfigHttpCheckArgsDict(TypedDict):
+        accepted_response_status_codes: NotRequired[pulumi.Input[Sequence[pulumi.Input['UptimeCheckConfigHttpCheckAcceptedResponseStatusCodeArgsDict']]]]
+        """
+        If present, the check will only pass if the HTTP response status code is in this set of status codes. If empty, the HTTP status code will only pass if the HTTP status code is 200-299.
+        Structure is documented below.
+        """
+        auth_info: NotRequired[pulumi.Input['UptimeCheckConfigHttpCheckAuthInfoArgsDict']]
+        """
+        The authentication information using username and password. Optional when creating an HTTP check; defaults to empty. Do not use with other authentication fields.
+        Structure is documented below.
+        """
+        body: NotRequired[pulumi.Input[str]]
+        """
+        The request body associated with the HTTP POST request. If `content_type` is `URL_ENCODED`, the body passed in must be URL-encoded. Users can provide a `Content-Length` header via the `headers` field or the API will do so. If the `request_method` is `GET` and `body` is not empty, the API will return an error. The maximum byte size is 1 megabyte. Note - As with all bytes fields JSON representations are base64 encoded. e.g. `foo=bar` in URL-encoded form is `foo%3Dbar` and in base64 encoding is `Zm9vJTI1M0RiYXI=`.
+        """
+        content_type: NotRequired[pulumi.Input[str]]
+        """
+        The content type to use for the check.
+        Possible values are: `TYPE_UNSPECIFIED`, `URL_ENCODED`, `USER_PROVIDED`.
+        """
+        custom_content_type: NotRequired[pulumi.Input[str]]
+        """
+        A user provided content type header to use for the check. The invalid configurations outlined in the `content_type` field apply to custom_content_type`, as well as the following 1. `content_type` is `URL_ENCODED` and `custom_content_type` is set. 2. `content_type` is `USER_PROVIDED` and `custom_content_type` is not set.
+        """
+        headers: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
+        """
+        The list of headers to send as part of the uptime check request. If two headers have the same key and different values, they should be entered as a single header, with the value being a comma-separated list of all the desired values as described in [RFC 2616 (page 31)](https://www.w3.org/Protocols/rfc2616/rfc2616.txt). Entering two separate headers with the same key in a Create call will cause the first to be overwritten by the second. The maximum number of headers allowed is 100.
+        """
+        mask_headers: NotRequired[pulumi.Input[bool]]
+        """
+        Boolean specifying whether to encrypt the header information. Encryption should be specified for any headers related to authentication that you do not wish to be seen when retrieving the configuration. The server will be responsible for encrypting the headers. On Get/List calls, if `mask_headers` is set to `true` then the headers will be obscured with `******`.
+        """
+        path: NotRequired[pulumi.Input[str]]
+        """
+        The path to the page to run the check against. Will be combined with the host (specified within the MonitoredResource) and port to construct the full URL. If the provided path does not begin with `/`, a `/` will be prepended automatically. Optional (defaults to `/`).
+        """
+        ping_config: NotRequired[pulumi.Input['UptimeCheckConfigHttpCheckPingConfigArgsDict']]
+        """
+        Contains information needed to add pings to an HTTP check.
+        Structure is documented below.
+        """
+        port: NotRequired[pulumi.Input[int]]
+        """
+        The port to the page to run the check against. Will be combined with `host` (specified within the `monitored_resource`) and path to construct the full URL. Optional (defaults to 80 without SSL, or 443 with SSL).
+        """
+        request_method: NotRequired[pulumi.Input[str]]
+        """
+        The HTTP request method to use for the check. If set to `METHOD_UNSPECIFIED` then `request_method` defaults to `GET`.
+        Default value is `GET`.
+        Possible values are: `METHOD_UNSPECIFIED`, `GET`, `POST`.
+        """
+        service_agent_authentication: NotRequired[pulumi.Input['UptimeCheckConfigHttpCheckServiceAgentAuthenticationArgsDict']]
+        """
+        The authentication information using the Monitoring Service Agent. Optional when creating an HTTPS check; defaults to empty. Do not use with other authentication fields.
+        Structure is documented below.
+        """
+        use_ssl: NotRequired[pulumi.Input[bool]]
+        """
+        If true, use HTTPS instead of HTTP to run the check.
+        """
+        validate_ssl: NotRequired[pulumi.Input[bool]]
+        """
+        Boolean specifying whether to include SSL certificate validation as a part of the Uptime check. Only applies to checks where `monitored_resource` is set to `uptime_url`. If `use_ssl` is `false`, setting `validate_ssl` to `true` has no effect.
+        """
+elif False:
+    UptimeCheckConfigHttpCheckArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class UptimeCheckConfigHttpCheckArgs:
     def __init__(__self__, *,
@@ -3954,6 +5551,20 @@ class UptimeCheckConfigHttpCheckArgs:
         pulumi.set(self, "validate_ssl", value)
 
 
+if not MYPY:
+    class UptimeCheckConfigHttpCheckAcceptedResponseStatusCodeArgsDict(TypedDict):
+        status_class: NotRequired[pulumi.Input[str]]
+        """
+        A class of status codes to accept.
+        Possible values are: `STATUS_CLASS_1XX`, `STATUS_CLASS_2XX`, `STATUS_CLASS_3XX`, `STATUS_CLASS_4XX`, `STATUS_CLASS_5XX`, `STATUS_CLASS_ANY`.
+        """
+        status_value: NotRequired[pulumi.Input[int]]
+        """
+        A status code to accept.
+        """
+elif False:
+    UptimeCheckConfigHttpCheckAcceptedResponseStatusCodeArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class UptimeCheckConfigHttpCheckAcceptedResponseStatusCodeArgs:
     def __init__(__self__, *,
@@ -3995,6 +5606,20 @@ class UptimeCheckConfigHttpCheckAcceptedResponseStatusCodeArgs:
         pulumi.set(self, "status_value", value)
 
 
+if not MYPY:
+    class UptimeCheckConfigHttpCheckAuthInfoArgsDict(TypedDict):
+        password: pulumi.Input[str]
+        """
+        The password to authenticate.
+        **Note**: This property is sensitive and will not be displayed in the plan.
+        """
+        username: pulumi.Input[str]
+        """
+        The username to authenticate.
+        """
+elif False:
+    UptimeCheckConfigHttpCheckAuthInfoArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class UptimeCheckConfigHttpCheckAuthInfoArgs:
     def __init__(__self__, *,
@@ -4034,6 +5659,15 @@ class UptimeCheckConfigHttpCheckAuthInfoArgs:
         pulumi.set(self, "username", value)
 
 
+if not MYPY:
+    class UptimeCheckConfigHttpCheckPingConfigArgsDict(TypedDict):
+        pings_count: pulumi.Input[int]
+        """
+        Number of ICMP pings. A maximum of 3 ICMP pings is currently supported.
+        """
+elif False:
+    UptimeCheckConfigHttpCheckPingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class UptimeCheckConfigHttpCheckPingConfigArgs:
     def __init__(__self__, *,
@@ -4056,6 +5690,16 @@ class UptimeCheckConfigHttpCheckPingConfigArgs:
         pulumi.set(self, "pings_count", value)
 
 
+if not MYPY:
+    class UptimeCheckConfigHttpCheckServiceAgentAuthenticationArgsDict(TypedDict):
+        type: NotRequired[pulumi.Input[str]]
+        """
+        The type of authentication to use.
+        Possible values are: `SERVICE_AGENT_AUTHENTICATION_TYPE_UNSPECIFIED`, `OIDC_TOKEN`.
+        """
+elif False:
+    UptimeCheckConfigHttpCheckServiceAgentAuthenticationArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class UptimeCheckConfigHttpCheckServiceAgentAuthenticationArgs:
     def __init__(__self__, *,
@@ -4081,6 +5725,19 @@ class UptimeCheckConfigHttpCheckServiceAgentAuthenticationArgs:
         pulumi.set(self, "type", value)
 
 
+if not MYPY:
+    class UptimeCheckConfigMonitoredResourceArgsDict(TypedDict):
+        labels: pulumi.Input[Mapping[str, pulumi.Input[str]]]
+        """
+        Values for all of the labels listed in the associated monitored resource descriptor. For example, Compute Engine VM instances use the labels `project_id`, `instance_id`, and `zone`.
+        """
+        type: pulumi.Input[str]
+        """
+        The monitored resource type. This field must match the type field of a [`MonitoredResourceDescriptor`](https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.monitoredResourceDescriptors#MonitoredResourceDescriptor) object. For example, the type of a Compute Engine VM instance is `gce_instance`. For a list of types, see [Monitoring resource types](https://cloud.google.com/monitoring/api/resources) and [Logging resource types](https://cloud.google.com/logging/docs/api/v2/resource-list).
+        """
+elif False:
+    UptimeCheckConfigMonitoredResourceArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class UptimeCheckConfigMonitoredResourceArgs:
     def __init__(__self__, *,
@@ -4118,6 +5775,20 @@ class UptimeCheckConfigMonitoredResourceArgs:
         pulumi.set(self, "type", value)
 
 
+if not MYPY:
+    class UptimeCheckConfigResourceGroupArgsDict(TypedDict):
+        group_id: NotRequired[pulumi.Input[str]]
+        """
+        The group of resources being monitored. Should be the `name` of a group
+        """
+        resource_type: NotRequired[pulumi.Input[str]]
+        """
+        The resource type of the group members.
+        Possible values are: `RESOURCE_TYPE_UNSPECIFIED`, `INSTANCE`, `AWS_ELB_LOAD_BALANCER`.
+        """
+elif False:
+    UptimeCheckConfigResourceGroupArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class UptimeCheckConfigResourceGroupArgs:
     def __init__(__self__, *,
@@ -4159,6 +5830,19 @@ class UptimeCheckConfigResourceGroupArgs:
         pulumi.set(self, "resource_type", value)
 
 
+if not MYPY:
+    class UptimeCheckConfigSyntheticMonitorArgsDict(TypedDict):
+        cloud_function_v2: pulumi.Input['UptimeCheckConfigSyntheticMonitorCloudFunctionV2ArgsDict']
+        """
+        Target a Synthetic Monitor GCFv2 Instance
+        Structure is documented below.
+
+
+        <a name="nested_cloud_function_v2"></a>The `cloud_function_v2` block supports:
+        """
+elif False:
+    UptimeCheckConfigSyntheticMonitorArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class UptimeCheckConfigSyntheticMonitorArgs:
     def __init__(__self__, *,
@@ -4189,6 +5873,15 @@ class UptimeCheckConfigSyntheticMonitorArgs:
         pulumi.set(self, "cloud_function_v2", value)
 
 
+if not MYPY:
+    class UptimeCheckConfigSyntheticMonitorCloudFunctionV2ArgsDict(TypedDict):
+        name: pulumi.Input[str]
+        """
+        A unique resource name for this UptimeCheckConfig. The format is `projects/[PROJECT_ID]/uptimeCheckConfigs/[UPTIME_CHECK_ID]`.
+        """
+elif False:
+    UptimeCheckConfigSyntheticMonitorCloudFunctionV2ArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class UptimeCheckConfigSyntheticMonitorCloudFunctionV2Args:
     def __init__(__self__, *,
@@ -4211,6 +5904,20 @@ class UptimeCheckConfigSyntheticMonitorCloudFunctionV2Args:
         pulumi.set(self, "name", value)
 
 
+if not MYPY:
+    class UptimeCheckConfigTcpCheckArgsDict(TypedDict):
+        port: pulumi.Input[int]
+        """
+        The port to the page to run the check against. Will be combined with host (specified within the `monitored_resource`) to construct the full URL.
+        """
+        ping_config: NotRequired[pulumi.Input['UptimeCheckConfigTcpCheckPingConfigArgsDict']]
+        """
+        Contains information needed to add pings to a TCP check.
+        Structure is documented below.
+        """
+elif False:
+    UptimeCheckConfigTcpCheckArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class UptimeCheckConfigTcpCheckArgs:
     def __init__(__self__, *,
@@ -4251,6 +5958,15 @@ class UptimeCheckConfigTcpCheckArgs:
         pulumi.set(self, "ping_config", value)
 
 
+if not MYPY:
+    class UptimeCheckConfigTcpCheckPingConfigArgsDict(TypedDict):
+        pings_count: pulumi.Input[int]
+        """
+        Number of ICMP pings. A maximum of 3 ICMP pings is currently supported.
+        """
+elif False:
+    UptimeCheckConfigTcpCheckPingConfigArgsDict: TypeAlias = Mapping[str, Any]
+
 @pulumi.input_type
 class UptimeCheckConfigTcpCheckPingConfigArgs:
     def __init__(__self__, *,