// Copyright 2025 Google LLC
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v6.31.0
// source: google/monitoring/v3/alert.proto

package monitoringpb

import (
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"

	_ "google.golang.org/genproto/googleapis/api/annotations"
	status "google.golang.org/genproto/googleapis/rpc/status"
	timeofday "google.golang.org/genproto/googleapis/type/timeofday"
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	durationpb "google.golang.org/protobuf/types/known/durationpb"
	wrapperspb "google.golang.org/protobuf/types/known/wrapperspb"
)

const (
	// Verify that this generated code is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
	// Verify that runtime/protoimpl is sufficiently up-to-date.
	_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)

// Operators for combining conditions.
type AlertPolicy_ConditionCombinerType int32

const (
	// An unspecified combiner.
	AlertPolicy_COMBINE_UNSPECIFIED AlertPolicy_ConditionCombinerType = 0
	// Combine conditions using the logical `AND` operator. An
	// incident is created only if all the conditions are met
	// simultaneously. This combiner is satisfied if all conditions are
	// met, even if they are met on completely different resources.
	AlertPolicy_AND AlertPolicy_ConditionCombinerType = 1
	// Combine conditions using the logical `OR` operator. An incident
	// is created if any of the listed conditions is met.
	AlertPolicy_OR AlertPolicy_ConditionCombinerType = 2
	// Combine conditions using logical `AND` operator, but unlike the regular
	// `AND` option, an incident is created only if all conditions are met
	// simultaneously on at least one resource.
	AlertPolicy_AND_WITH_MATCHING_RESOURCE AlertPolicy_ConditionCombinerType = 3
)

// Enum value maps for AlertPolicy_ConditionCombinerType.
var (
	AlertPolicy_ConditionCombinerType_name = map[int32]string{
		0: "COMBINE_UNSPECIFIED",
		1: "AND",
		2: "OR",
		3: "AND_WITH_MATCHING_RESOURCE",
	}
	AlertPolicy_ConditionCombinerType_value = map[string]int32{
		"COMBINE_UNSPECIFIED":        0,
		"AND":                        1,
		"OR":                         2,
		"AND_WITH_MATCHING_RESOURCE": 3,
	}
)

func (x AlertPolicy_ConditionCombinerType) Enum() *AlertPolicy_ConditionCombinerType {
	p := new(AlertPolicy_ConditionCombinerType)
	*p = x
	return p
}

func (x AlertPolicy_ConditionCombinerType) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (AlertPolicy_ConditionCombinerType) Descriptor() protoreflect.EnumDescriptor {
	return file_google_monitoring_v3_alert_proto_enumTypes[0].Descriptor()
}

func (AlertPolicy_ConditionCombinerType) Type() protoreflect.EnumType {
	return &file_google_monitoring_v3_alert_proto_enumTypes[0]
}

func (x AlertPolicy_ConditionCombinerType) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use AlertPolicy_ConditionCombinerType.Descriptor instead.
func (AlertPolicy_ConditionCombinerType) EnumDescriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 0}
}

// An enumeration of possible severity level for an alerting policy.
type AlertPolicy_Severity int32

const (
	// No severity is specified. This is the default value.
	AlertPolicy_SEVERITY_UNSPECIFIED AlertPolicy_Severity = 0
	// This is the highest severity level. Use this if the problem could
	// cause significant damage or downtime.
	AlertPolicy_CRITICAL AlertPolicy_Severity = 1
	// This is the medium severity level. Use this if the problem could
	// cause minor damage or downtime.
	AlertPolicy_ERROR AlertPolicy_Severity = 2
	// This is the lowest severity level. Use this if the problem is not causing
	// any damage or downtime, but could potentially lead to a problem in the
	// future.
	AlertPolicy_WARNING AlertPolicy_Severity = 3
)

// Enum value maps for AlertPolicy_Severity.
var (
	AlertPolicy_Severity_name = map[int32]string{
		0: "SEVERITY_UNSPECIFIED",
		1: "CRITICAL",
		2: "ERROR",
		3: "WARNING",
	}
	AlertPolicy_Severity_value = map[string]int32{
		"SEVERITY_UNSPECIFIED": 0,
		"CRITICAL":             1,
		"ERROR":                2,
		"WARNING":              3,
	}
)

func (x AlertPolicy_Severity) Enum() *AlertPolicy_Severity {
	p := new(AlertPolicy_Severity)
	*p = x
	return p
}

func (x AlertPolicy_Severity) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (AlertPolicy_Severity) Descriptor() protoreflect.EnumDescriptor {
	return file_google_monitoring_v3_alert_proto_enumTypes[1].Descriptor()
}

func (AlertPolicy_Severity) Type() protoreflect.EnumType {
	return &file_google_monitoring_v3_alert_proto_enumTypes[1]
}

func (x AlertPolicy_Severity) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use AlertPolicy_Severity.Descriptor instead.
func (AlertPolicy_Severity) EnumDescriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 1}
}

// A condition control that determines how metric-threshold conditions
// are evaluated when data stops arriving.
// This control doesn't affect metric-absence policies.
type AlertPolicy_Condition_EvaluationMissingData int32

const (
	// An unspecified evaluation missing data option.  Equivalent to
	// EVALUATION_MISSING_DATA_NO_OP.
	AlertPolicy_Condition_EVALUATION_MISSING_DATA_UNSPECIFIED AlertPolicy_Condition_EvaluationMissingData = 0
	// If there is no data to evaluate the condition, then evaluate the
	// condition as false.
	AlertPolicy_Condition_EVALUATION_MISSING_DATA_INACTIVE AlertPolicy_Condition_EvaluationMissingData = 1
	// If there is no data to evaluate the condition, then evaluate the
	// condition as true.
	AlertPolicy_Condition_EVALUATION_MISSING_DATA_ACTIVE AlertPolicy_Condition_EvaluationMissingData = 2
	// Do not evaluate the condition to any value if there is no data.
	AlertPolicy_Condition_EVALUATION_MISSING_DATA_NO_OP AlertPolicy_Condition_EvaluationMissingData = 3
)

// Enum value maps for AlertPolicy_Condition_EvaluationMissingData.
var (
	AlertPolicy_Condition_EvaluationMissingData_name = map[int32]string{
		0: "EVALUATION_MISSING_DATA_UNSPECIFIED",
		1: "EVALUATION_MISSING_DATA_INACTIVE",
		2: "EVALUATION_MISSING_DATA_ACTIVE",
		3: "EVALUATION_MISSING_DATA_NO_OP",
	}
	AlertPolicy_Condition_EvaluationMissingData_value = map[string]int32{
		"EVALUATION_MISSING_DATA_UNSPECIFIED": 0,
		"EVALUATION_MISSING_DATA_INACTIVE":    1,
		"EVALUATION_MISSING_DATA_ACTIVE":      2,
		"EVALUATION_MISSING_DATA_NO_OP":       3,
	}
)

func (x AlertPolicy_Condition_EvaluationMissingData) Enum() *AlertPolicy_Condition_EvaluationMissingData {
	p := new(AlertPolicy_Condition_EvaluationMissingData)
	*p = x
	return p
}

func (x AlertPolicy_Condition_EvaluationMissingData) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (AlertPolicy_Condition_EvaluationMissingData) Descriptor() protoreflect.EnumDescriptor {
	return file_google_monitoring_v3_alert_proto_enumTypes[2].Descriptor()
}

func (AlertPolicy_Condition_EvaluationMissingData) Type() protoreflect.EnumType {
	return &file_google_monitoring_v3_alert_proto_enumTypes[2]
}

func (x AlertPolicy_Condition_EvaluationMissingData) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use AlertPolicy_Condition_EvaluationMissingData.Descriptor instead.
func (AlertPolicy_Condition_EvaluationMissingData) EnumDescriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 1, 0}
}

// Control when notifications will be sent out.
type AlertPolicy_AlertStrategy_NotificationPrompt int32

const (
	// No strategy specified. Treated as error.
	AlertPolicy_AlertStrategy_NOTIFICATION_PROMPT_UNSPECIFIED AlertPolicy_AlertStrategy_NotificationPrompt = 0
	// Notify when an incident is opened.
	AlertPolicy_AlertStrategy_OPENED AlertPolicy_AlertStrategy_NotificationPrompt = 1
	// Notify when an incident is closed.
	AlertPolicy_AlertStrategy_CLOSED AlertPolicy_AlertStrategy_NotificationPrompt = 3
)

// Enum value maps for AlertPolicy_AlertStrategy_NotificationPrompt.
var (
	AlertPolicy_AlertStrategy_NotificationPrompt_name = map[int32]string{
		0: "NOTIFICATION_PROMPT_UNSPECIFIED",
		1: "OPENED",
		3: "CLOSED",
	}
	AlertPolicy_AlertStrategy_NotificationPrompt_value = map[string]int32{
		"NOTIFICATION_PROMPT_UNSPECIFIED": 0,
		"OPENED":                          1,
		"CLOSED":                          3,
	}
)

func (x AlertPolicy_AlertStrategy_NotificationPrompt) Enum() *AlertPolicy_AlertStrategy_NotificationPrompt {
	p := new(AlertPolicy_AlertStrategy_NotificationPrompt)
	*p = x
	return p
}

func (x AlertPolicy_AlertStrategy_NotificationPrompt) String() string {
	return protoimpl.X.EnumStringOf(x.Descriptor(), protoreflect.EnumNumber(x))
}

func (AlertPolicy_AlertStrategy_NotificationPrompt) Descriptor() protoreflect.EnumDescriptor {
	return file_google_monitoring_v3_alert_proto_enumTypes[3].Descriptor()
}

func (AlertPolicy_AlertStrategy_NotificationPrompt) Type() protoreflect.EnumType {
	return &file_google_monitoring_v3_alert_proto_enumTypes[3]
}

func (x AlertPolicy_AlertStrategy_NotificationPrompt) Number() protoreflect.EnumNumber {
	return protoreflect.EnumNumber(x)
}

// Deprecated: Use AlertPolicy_AlertStrategy_NotificationPrompt.Descriptor instead.
func (AlertPolicy_AlertStrategy_NotificationPrompt) EnumDescriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 2, 0}
}

// A description of the conditions under which some aspect of your system is
// considered to be "unhealthy" and the ways to notify people or services about
// this state. For an overview of alerting policies, see
// [Introduction to Alerting](https://cloud.google.com/monitoring/alerts/).
type AlertPolicy struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Identifier. Required if the policy exists. The resource name for this
	// policy. The format is:
	//
	//	projects/[PROJECT_ID_OR_NUMBER]/alertPolicies/[ALERT_POLICY_ID]
	//
	// `[ALERT_POLICY_ID]` is assigned by Cloud Monitoring when the policy
	// is created. When calling the
	// [alertPolicies.create][google.monitoring.v3.AlertPolicyService.CreateAlertPolicy]
	// method, do not include the `name` field in the alerting policy passed as
	// part of the request.
	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	// A short name or phrase used to identify the policy in dashboards,
	// notifications, and incidents. To avoid confusion, don't use the same
	// display name for multiple policies in the same project. The name is
	// limited to 512 Unicode characters.
	//
	// The convention for the display_name of a PrometheusQueryLanguageCondition
	// is "{rule group name}/{alert name}", where the {rule group name} and
	// {alert name} should be taken from the corresponding Prometheus
	// configuration file. This convention is not enforced.
	// In any case the display_name is not a unique key of the AlertPolicy.
	DisplayName string `protobuf:"bytes,2,opt,name=display_name,json=displayName,proto3" json:"display_name,omitempty"`
	// Documentation that is included with notifications and incidents related to
	// this policy. Best practice is for the documentation to include information
	// to help responders understand, mitigate, escalate, and correct the
	// underlying problems detected by the alerting policy. Notification channels
	// that have limited capacity might not show this documentation.
	Documentation *AlertPolicy_Documentation `protobuf:"bytes,13,opt,name=documentation,proto3" json:"documentation,omitempty"`
	// User-supplied key/value data to be used for organizing and
	// identifying the `AlertPolicy` objects.
	//
	// The field can contain up to 64 entries. Each key and value is limited to
	// 63 Unicode characters or 128 bytes, whichever is smaller. Labels and
	// values can contain only lowercase letters, numerals, underscores, and
	// dashes. Keys must begin with a letter.
	//
	// Note that Prometheus {alert name} is a
	// [valid Prometheus label
	// names](https://prometheus.io/docs/concepts/data_model/#metric-names-and-labels),
	// whereas Prometheus {rule group} is an unrestricted UTF-8 string.
	// This means that they cannot be stored as-is in user labels, because
	// they may contain characters that are not allowed in user-label values.
	UserLabels map[string]string `protobuf:"bytes,16,rep,name=user_labels,json=userLabels,proto3" json:"user_labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// A list of conditions for the policy. The conditions are combined by AND or
	// OR according to the `combiner` field. If the combined conditions evaluate
	// to true, then an incident is created. A policy can have from one to six
	// conditions.
	// If `condition_time_series_query_language` is present, it must be the only
	// `condition`.
	// If `condition_monitoring_query_language` is present, it must be the only
	// `condition`.
	Conditions []*AlertPolicy_Condition `protobuf:"bytes,12,rep,name=conditions,proto3" json:"conditions,omitempty"`
	// How to combine the results of multiple conditions to determine if an
	// incident should be opened.
	// If `condition_time_series_query_language` is present, this must be
	// `COMBINE_UNSPECIFIED`.
	Combiner AlertPolicy_ConditionCombinerType `protobuf:"varint,6,opt,name=combiner,proto3,enum=google.monitoring.v3.AlertPolicy_ConditionCombinerType" json:"combiner,omitempty"`
	// Whether or not the policy is enabled. On write, the default interpretation
	// if unset is that the policy is enabled. On read, clients should not make
	// any assumption about the state if it has not been populated. The
	// field should always be populated on List and Get operations, unless
	// a field projection has been specified that strips it out.
	Enabled *wrapperspb.BoolValue `protobuf:"bytes,17,opt,name=enabled,proto3" json:"enabled,omitempty"`
	// Read-only description of how the alerting policy is invalid. This field is
	// only set when the alerting policy is invalid. An invalid alerting policy
	// will not generate incidents.
	Validity *status.Status `protobuf:"bytes,18,opt,name=validity,proto3" json:"validity,omitempty"`
	// Identifies the notification channels to which notifications should be sent
	// when incidents are opened or closed or when new violations occur on
	// an already opened incident. Each element of this array corresponds to
	// the `name` field in each of the
	// [`NotificationChannel`][google.monitoring.v3.NotificationChannel]
	// objects that are returned from the [`ListNotificationChannels`]
	// [google.monitoring.v3.NotificationChannelService.ListNotificationChannels]
	// method. The format of the entries in this field is:
	//
	//	projects/[PROJECT_ID_OR_NUMBER]/notificationChannels/[CHANNEL_ID]
	NotificationChannels []string `protobuf:"bytes,14,rep,name=notification_channels,json=notificationChannels,proto3" json:"notification_channels,omitempty"`
	// A read-only record of the creation of the alerting policy. If provided
	// in a call to create or update, this field will be ignored.
	CreationRecord *MutationRecord `protobuf:"bytes,10,opt,name=creation_record,json=creationRecord,proto3" json:"creation_record,omitempty"`
	// A read-only record of the most recent change to the alerting policy. If
	// provided in a call to create or update, this field will be ignored.
	MutationRecord *MutationRecord `protobuf:"bytes,11,opt,name=mutation_record,json=mutationRecord,proto3" json:"mutation_record,omitempty"`
	// Control over how this alerting policy's notification channels are notified.
	AlertStrategy *AlertPolicy_AlertStrategy `protobuf:"bytes,21,opt,name=alert_strategy,json=alertStrategy,proto3" json:"alert_strategy,omitempty"`
	// Optional. The severity of an alerting policy indicates how important
	// incidents generated by that policy are. The severity level will be
	// displayed on the Incident detail page and in notifications.
	Severity      AlertPolicy_Severity `protobuf:"varint,22,opt,name=severity,proto3,enum=google.monitoring.v3.AlertPolicy_Severity" json:"severity,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AlertPolicy) Reset() {
	*x = AlertPolicy{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[0]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy) ProtoMessage() {}

func (x *AlertPolicy) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[0]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy.ProtoReflect.Descriptor instead.
func (*AlertPolicy) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0}
}

func (x *AlertPolicy) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *AlertPolicy) GetDisplayName() string {
	if x != nil {
		return x.DisplayName
	}
	return ""
}

func (x *AlertPolicy) GetDocumentation() *AlertPolicy_Documentation {
	if x != nil {
		return x.Documentation
	}
	return nil
}

func (x *AlertPolicy) GetUserLabels() map[string]string {
	if x != nil {
		return x.UserLabels
	}
	return nil
}

func (x *AlertPolicy) GetConditions() []*AlertPolicy_Condition {
	if x != nil {
		return x.Conditions
	}
	return nil
}

func (x *AlertPolicy) GetCombiner() AlertPolicy_ConditionCombinerType {
	if x != nil {
		return x.Combiner
	}
	return AlertPolicy_COMBINE_UNSPECIFIED
}

func (x *AlertPolicy) GetEnabled() *wrapperspb.BoolValue {
	if x != nil {
		return x.Enabled
	}
	return nil
}

func (x *AlertPolicy) GetValidity() *status.Status {
	if x != nil {
		return x.Validity
	}
	return nil
}

func (x *AlertPolicy) GetNotificationChannels() []string {
	if x != nil {
		return x.NotificationChannels
	}
	return nil
}

func (x *AlertPolicy) GetCreationRecord() *MutationRecord {
	if x != nil {
		return x.CreationRecord
	}
	return nil
}

func (x *AlertPolicy) GetMutationRecord() *MutationRecord {
	if x != nil {
		return x.MutationRecord
	}
	return nil
}

func (x *AlertPolicy) GetAlertStrategy() *AlertPolicy_AlertStrategy {
	if x != nil {
		return x.AlertStrategy
	}
	return nil
}

func (x *AlertPolicy) GetSeverity() AlertPolicy_Severity {
	if x != nil {
		return x.Severity
	}
	return AlertPolicy_SEVERITY_UNSPECIFIED
}

// Documentation that is included in the notifications and incidents
// pertaining to this policy.
type AlertPolicy_Documentation struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The body of the documentation, interpreted according to `mime_type`.
	// 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. This text can be [templatized by using
	// variables](https://cloud.google.com/monitoring/alerts/doc-variables#doc-vars).
	Content string `protobuf:"bytes,1,opt,name=content,proto3" json:"content,omitempty"`
	// The format of the `content` field. Presently, only the value
	// `"text/markdown"` is supported. See
	// [Markdown](https://en.wikipedia.org/wiki/Markdown) for more information.
	MimeType string `protobuf:"bytes,2,opt,name=mime_type,json=mimeType,proto3" json:"mime_type,omitempty"`
	// Optional. 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. The
	// 255-byte limit is recommended by [this
	// thread](https://stackoverflow.com/questions/1592291/what-is-the-email-subject-length-limit).
	// It is both the limit imposed by some third-party ticketing products and
	// it is common to define textual fields in databases as VARCHAR(255).
	//
	// The contents of the subject line can be [templatized by using
	// variables](https://cloud.google.com/monitoring/alerts/doc-variables#doc-vars).
	// If this field is missing or empty, a default subject line will be
	// generated.
	Subject string `protobuf:"bytes,3,opt,name=subject,proto3" json:"subject,omitempty"`
	// Optional. Links to content such as playbooks, repositories, and other
	// resources. This field can contain up to 3 entries.
	Links         []*AlertPolicy_Documentation_Link `protobuf:"bytes,4,rep,name=links,proto3" json:"links,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AlertPolicy_Documentation) Reset() {
	*x = AlertPolicy_Documentation{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[1]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_Documentation) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_Documentation) ProtoMessage() {}

func (x *AlertPolicy_Documentation) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[1]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_Documentation.ProtoReflect.Descriptor instead.
func (*AlertPolicy_Documentation) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 0}
}

func (x *AlertPolicy_Documentation) GetContent() string {
	if x != nil {
		return x.Content
	}
	return ""
}

func (x *AlertPolicy_Documentation) GetMimeType() string {
	if x != nil {
		return x.MimeType
	}
	return ""
}

func (x *AlertPolicy_Documentation) GetSubject() string {
	if x != nil {
		return x.Subject
	}
	return ""
}

func (x *AlertPolicy_Documentation) GetLinks() []*AlertPolicy_Documentation_Link {
	if x != nil {
		return x.Links
	}
	return nil
}

// A condition is a true/false test that determines when an alerting policy
// should open an incident. If a condition evaluates to true, it signifies
// that something is wrong.
type AlertPolicy_Condition struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Required if the condition exists. The unique resource name for this
	// condition. Its format is:
	//
	//	projects/[PROJECT_ID_OR_NUMBER]/alertPolicies/[POLICY_ID]/conditions/[CONDITION_ID]
	//
	// `[CONDITION_ID]` is assigned by Cloud Monitoring when the
	// condition is created as part of a new or updated alerting policy.
	//
	// When calling the
	// [alertPolicies.create][google.monitoring.v3.AlertPolicyService.CreateAlertPolicy]
	// method, do not include the `name` field in the conditions of the
	// requested alerting policy. Cloud Monitoring creates the
	// condition identifiers and includes them in the new policy.
	//
	// When calling the
	// [alertPolicies.update][google.monitoring.v3.AlertPolicyService.UpdateAlertPolicy]
	// method to update a policy, including a condition `name` causes the
	// existing condition to be updated. Conditions without names are added to
	// the updated policy. Existing conditions are deleted if they are not
	// updated.
	//
	// Best practice is to preserve `[CONDITION_ID]` if you make only small
	// changes, such as those to condition thresholds, durations, or trigger
	// values.  Otherwise, treat the change as a new condition and let the
	// existing condition be deleted.
	Name string `protobuf:"bytes,12,opt,name=name,proto3" json:"name,omitempty"`
	// 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.
	DisplayName string `protobuf:"bytes,6,opt,name=display_name,json=displayName,proto3" json:"display_name,omitempty"`
	// Only one of the following condition types will be specified.
	//
	// Types that are valid to be assigned to Condition:
	//
	//	*AlertPolicy_Condition_ConditionThreshold
	//	*AlertPolicy_Condition_ConditionAbsent
	//	*AlertPolicy_Condition_ConditionMatchedLog
	//	*AlertPolicy_Condition_ConditionMonitoringQueryLanguage
	//	*AlertPolicy_Condition_ConditionPrometheusQueryLanguage
	//	*AlertPolicy_Condition_ConditionSql
	Condition     isAlertPolicy_Condition_Condition `protobuf_oneof:"condition"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AlertPolicy_Condition) Reset() {
	*x = AlertPolicy_Condition{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[2]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_Condition) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_Condition) ProtoMessage() {}

func (x *AlertPolicy_Condition) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[2]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_Condition.ProtoReflect.Descriptor instead.
func (*AlertPolicy_Condition) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 1}
}

func (x *AlertPolicy_Condition) GetName() string {
	if x != nil {
		return x.Name
	}
	return ""
}

func (x *AlertPolicy_Condition) GetDisplayName() string {
	if x != nil {
		return x.DisplayName
	}
	return ""
}

func (x *AlertPolicy_Condition) GetCondition() isAlertPolicy_Condition_Condition {
	if x != nil {
		return x.Condition
	}
	return nil
}

func (x *AlertPolicy_Condition) GetConditionThreshold() *AlertPolicy_Condition_MetricThreshold {
	if x != nil {
		if x, ok := x.Condition.(*AlertPolicy_Condition_ConditionThreshold); ok {
			return x.ConditionThreshold
		}
	}
	return nil
}

func (x *AlertPolicy_Condition) GetConditionAbsent() *AlertPolicy_Condition_MetricAbsence {
	if x != nil {
		if x, ok := x.Condition.(*AlertPolicy_Condition_ConditionAbsent); ok {
			return x.ConditionAbsent
		}
	}
	return nil
}

func (x *AlertPolicy_Condition) GetConditionMatchedLog() *AlertPolicy_Condition_LogMatch {
	if x != nil {
		if x, ok := x.Condition.(*AlertPolicy_Condition_ConditionMatchedLog); ok {
			return x.ConditionMatchedLog
		}
	}
	return nil
}

func (x *AlertPolicy_Condition) GetConditionMonitoringQueryLanguage() *AlertPolicy_Condition_MonitoringQueryLanguageCondition {
	if x != nil {
		if x, ok := x.Condition.(*AlertPolicy_Condition_ConditionMonitoringQueryLanguage); ok {
			return x.ConditionMonitoringQueryLanguage
		}
	}
	return nil
}

func (x *AlertPolicy_Condition) GetConditionPrometheusQueryLanguage() *AlertPolicy_Condition_PrometheusQueryLanguageCondition {
	if x != nil {
		if x, ok := x.Condition.(*AlertPolicy_Condition_ConditionPrometheusQueryLanguage); ok {
			return x.ConditionPrometheusQueryLanguage
		}
	}
	return nil
}

func (x *AlertPolicy_Condition) GetConditionSql() *AlertPolicy_Condition_SqlCondition {
	if x != nil {
		if x, ok := x.Condition.(*AlertPolicy_Condition_ConditionSql); ok {
			return x.ConditionSql
		}
	}
	return nil
}

type isAlertPolicy_Condition_Condition interface {
	isAlertPolicy_Condition_Condition()
}

type AlertPolicy_Condition_ConditionThreshold struct {
	// A condition that compares a time series against a threshold.
	ConditionThreshold *AlertPolicy_Condition_MetricThreshold `protobuf:"bytes,1,opt,name=condition_threshold,json=conditionThreshold,proto3,oneof"`
}

type AlertPolicy_Condition_ConditionAbsent struct {
	// A condition that checks that a time series continues to
	// receive new data points.
	ConditionAbsent *AlertPolicy_Condition_MetricAbsence `protobuf:"bytes,2,opt,name=condition_absent,json=conditionAbsent,proto3,oneof"`
}

type AlertPolicy_Condition_ConditionMatchedLog struct {
	// A condition that checks for log messages matching given constraints. If
	// set, no other conditions can be present.
	ConditionMatchedLog *AlertPolicy_Condition_LogMatch `protobuf:"bytes,20,opt,name=condition_matched_log,json=conditionMatchedLog,proto3,oneof"`
}

type AlertPolicy_Condition_ConditionMonitoringQueryLanguage struct {
	// A condition that uses the Monitoring Query Language to define
	// alerts.
	ConditionMonitoringQueryLanguage *AlertPolicy_Condition_MonitoringQueryLanguageCondition `protobuf:"bytes,19,opt,name=condition_monitoring_query_language,json=conditionMonitoringQueryLanguage,proto3,oneof"`
}

type AlertPolicy_Condition_ConditionPrometheusQueryLanguage struct {
	// A condition that uses the Prometheus query language to define alerts.
	ConditionPrometheusQueryLanguage *AlertPolicy_Condition_PrometheusQueryLanguageCondition `protobuf:"bytes,21,opt,name=condition_prometheus_query_language,json=conditionPrometheusQueryLanguage,proto3,oneof"`
}

type AlertPolicy_Condition_ConditionSql struct {
	// A condition that periodically evaluates a SQL query result.
	ConditionSql *AlertPolicy_Condition_SqlCondition `protobuf:"bytes,22,opt,name=condition_sql,json=conditionSql,proto3,oneof"`
}

func (*AlertPolicy_Condition_ConditionThreshold) isAlertPolicy_Condition_Condition() {}

func (*AlertPolicy_Condition_ConditionAbsent) isAlertPolicy_Condition_Condition() {}

func (*AlertPolicy_Condition_ConditionMatchedLog) isAlertPolicy_Condition_Condition() {}

func (*AlertPolicy_Condition_ConditionMonitoringQueryLanguage) isAlertPolicy_Condition_Condition() {}

func (*AlertPolicy_Condition_ConditionPrometheusQueryLanguage) isAlertPolicy_Condition_Condition() {}

func (*AlertPolicy_Condition_ConditionSql) isAlertPolicy_Condition_Condition() {}

// Control over how the notification channels in `notification_channels`
// are notified when this alert fires.
type AlertPolicy_AlertStrategy struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Required for log-based alerting policies, i.e. policies with a `LogMatch`
	// condition.
	//
	// This limit is not implemented for alerting policies that do not have
	// a LogMatch condition.
	NotificationRateLimit *AlertPolicy_AlertStrategy_NotificationRateLimit `protobuf:"bytes,1,opt,name=notification_rate_limit,json=notificationRateLimit,proto3" json:"notification_rate_limit,omitempty"`
	// For log-based alert policies, the notification prompts is always
	// [OPENED]. For non log-based alert policies, the notification prompts can
	// be [OPENED] or [OPENED, CLOSED].
	NotificationPrompts []AlertPolicy_AlertStrategy_NotificationPrompt `protobuf:"varint,2,rep,packed,name=notification_prompts,json=notificationPrompts,proto3,enum=google.monitoring.v3.AlertPolicy_AlertStrategy_NotificationPrompt" json:"notification_prompts,omitempty"`
	// If an alerting policy that was active has no data for this long, any open
	// incidents will close
	AutoClose *durationpb.Duration `protobuf:"bytes,3,opt,name=auto_close,json=autoClose,proto3" json:"auto_close,omitempty"`
	// Control how notifications will be sent out, on a per-channel basis.
	NotificationChannelStrategy []*AlertPolicy_AlertStrategy_NotificationChannelStrategy `protobuf:"bytes,4,rep,name=notification_channel_strategy,json=notificationChannelStrategy,proto3" json:"notification_channel_strategy,omitempty"`
	unknownFields               protoimpl.UnknownFields
	sizeCache                   protoimpl.SizeCache
}

func (x *AlertPolicy_AlertStrategy) Reset() {
	*x = AlertPolicy_AlertStrategy{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[3]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_AlertStrategy) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_AlertStrategy) ProtoMessage() {}

func (x *AlertPolicy_AlertStrategy) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[3]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_AlertStrategy.ProtoReflect.Descriptor instead.
func (*AlertPolicy_AlertStrategy) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 2}
}

func (x *AlertPolicy_AlertStrategy) GetNotificationRateLimit() *AlertPolicy_AlertStrategy_NotificationRateLimit {
	if x != nil {
		return x.NotificationRateLimit
	}
	return nil
}

func (x *AlertPolicy_AlertStrategy) GetNotificationPrompts() []AlertPolicy_AlertStrategy_NotificationPrompt {
	if x != nil {
		return x.NotificationPrompts
	}
	return nil
}

func (x *AlertPolicy_AlertStrategy) GetAutoClose() *durationpb.Duration {
	if x != nil {
		return x.AutoClose
	}
	return nil
}

func (x *AlertPolicy_AlertStrategy) GetNotificationChannelStrategy() []*AlertPolicy_AlertStrategy_NotificationChannelStrategy {
	if x != nil {
		return x.NotificationChannelStrategy
	}
	return nil
}

// Links to content such as playbooks, repositories, and other resources.
type AlertPolicy_Documentation_Link struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A short display name for the link. The display name must not be empty
	// or exceed 63 characters. Example: "playbook".
	DisplayName string `protobuf:"bytes,1,opt,name=display_name,json=displayName,proto3" json:"display_name,omitempty"`
	// 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}"
	Url           string `protobuf:"bytes,2,opt,name=url,proto3" json:"url,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AlertPolicy_Documentation_Link) Reset() {
	*x = AlertPolicy_Documentation_Link{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[5]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_Documentation_Link) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_Documentation_Link) ProtoMessage() {}

func (x *AlertPolicy_Documentation_Link) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[5]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_Documentation_Link.ProtoReflect.Descriptor instead.
func (*AlertPolicy_Documentation_Link) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 0, 0}
}

func (x *AlertPolicy_Documentation_Link) GetDisplayName() string {
	if x != nil {
		return x.DisplayName
	}
	return ""
}

func (x *AlertPolicy_Documentation_Link) GetUrl() string {
	if x != nil {
		return x.Url
	}
	return ""
}

// Specifies how many time series must fail a predicate to trigger a
// condition. If not specified, then a `{count: 1}` trigger is used.
type AlertPolicy_Condition_Trigger struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// A type of trigger.
	//
	// Types that are valid to be assigned to Type:
	//
	//	*AlertPolicy_Condition_Trigger_Count
	//	*AlertPolicy_Condition_Trigger_Percent
	Type          isAlertPolicy_Condition_Trigger_Type `protobuf_oneof:"type"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AlertPolicy_Condition_Trigger) Reset() {
	*x = AlertPolicy_Condition_Trigger{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[6]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_Condition_Trigger) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_Condition_Trigger) ProtoMessage() {}

func (x *AlertPolicy_Condition_Trigger) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[6]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_Condition_Trigger.ProtoReflect.Descriptor instead.
func (*AlertPolicy_Condition_Trigger) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 1, 0}
}

func (x *AlertPolicy_Condition_Trigger) GetType() isAlertPolicy_Condition_Trigger_Type {
	if x != nil {
		return x.Type
	}
	return nil
}

func (x *AlertPolicy_Condition_Trigger) GetCount() int32 {
	if x != nil {
		if x, ok := x.Type.(*AlertPolicy_Condition_Trigger_Count); ok {
			return x.Count
		}
	}
	return 0
}

func (x *AlertPolicy_Condition_Trigger) GetPercent() float64 {
	if x != nil {
		if x, ok := x.Type.(*AlertPolicy_Condition_Trigger_Percent); ok {
			return x.Percent
		}
	}
	return 0
}

type isAlertPolicy_Condition_Trigger_Type interface {
	isAlertPolicy_Condition_Trigger_Type()
}

type AlertPolicy_Condition_Trigger_Count struct {
	// The absolute number of time series that must fail
	// the predicate for the condition to be triggered.
	Count int32 `protobuf:"varint,1,opt,name=count,proto3,oneof"`
}

type AlertPolicy_Condition_Trigger_Percent struct {
	// The percentage of time series that must fail the
	// predicate for the condition to be triggered.
	Percent float64 `protobuf:"fixed64,2,opt,name=percent,proto3,oneof"`
}

func (*AlertPolicy_Condition_Trigger_Count) isAlertPolicy_Condition_Trigger_Type() {}

func (*AlertPolicy_Condition_Trigger_Percent) isAlertPolicy_Condition_Trigger_Type() {}

// A condition type that compares a collection of time series
// against a threshold.
type AlertPolicy_Condition_MetricThreshold struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Required. A
	// [filter](https://cloud.google.com/monitoring/api/v3/filters) that
	// identifies which time series should be compared with the threshold.
	//
	// The filter is similar to the one that is specified in the
	// [`ListTimeSeries`
	// request](https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.timeSeries/list)
	// (that call is useful to verify the time series that will be retrieved /
	// processed). The filter must specify the metric type and the resource
	// type. Optionally, it can specify resource labels and metric labels.
	// This field must not exceed 2048 Unicode characters in length.
	Filter string `protobuf:"bytes,2,opt,name=filter,proto3" json:"filter,omitempty"`
	// 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 [`ListTimeSeries`
	// request](https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.timeSeries/list).
	// It is advisable to use the `ListTimeSeries` method when debugging this
	// field.
	Aggregations []*Aggregation `protobuf:"bytes,8,rep,name=aggregations,proto3" json:"aggregations,omitempty"`
	// A [filter](https://cloud.google.com/monitoring/api/v3/filters) 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 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.
	DenominatorFilter string `protobuf:"bytes,9,opt,name=denominator_filter,json=denominatorFilter,proto3" json:"denominator_filter,omitempty"`
	// 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.
	DenominatorAggregations []*Aggregation `protobuf:"bytes,10,rep,name=denominator_aggregations,json=denominatorAggregations,proto3" json:"denominator_aggregations,omitempty"`
	// When this field is present, the `MetricThreshold` condition forecasts
	// whether the time series is predicted to violate the threshold within
	// the `forecast_horizon`. When this field is not set, the
	// `MetricThreshold` tests the current value of the timeseries against the
	// threshold.
	ForecastOptions *AlertPolicy_Condition_MetricThreshold_ForecastOptions `protobuf:"bytes,12,opt,name=forecast_options,json=forecastOptions,proto3" json:"forecast_options,omitempty"`
	// 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.
	Comparison ComparisonType `protobuf:"varint,4,opt,name=comparison,proto3,enum=google.monitoring.v3.ComparisonType" json:"comparison,omitempty"`
	// A value against which to compare the time series.
	ThresholdValue float64 `protobuf:"fixed64,5,opt,name=threshold_value,json=thresholdValue,proto3" json:"threshold_value,omitempty"`
	// 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.
	Duration *durationpb.Duration `protobuf:"bytes,6,opt,name=duration,proto3" json:"duration,omitempty"`
	// 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.
	Trigger *AlertPolicy_Condition_Trigger `protobuf:"bytes,7,opt,name=trigger,proto3" json:"trigger,omitempty"`
	// A condition control that determines how metric-threshold conditions
	// are evaluated when data stops arriving. To use this control, the value
	// of the `duration` field must be greater than or equal to 60 seconds.
	EvaluationMissingData AlertPolicy_Condition_EvaluationMissingData `protobuf:"varint,11,opt,name=evaluation_missing_data,json=evaluationMissingData,proto3,enum=google.monitoring.v3.AlertPolicy_Condition_EvaluationMissingData" json:"evaluation_missing_data,omitempty"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

func (x *AlertPolicy_Condition_MetricThreshold) Reset() {
	*x = AlertPolicy_Condition_MetricThreshold{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[7]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_Condition_MetricThreshold) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_Condition_MetricThreshold) ProtoMessage() {}

func (x *AlertPolicy_Condition_MetricThreshold) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[7]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_Condition_MetricThreshold.ProtoReflect.Descriptor instead.
func (*AlertPolicy_Condition_MetricThreshold) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 1, 1}
}

func (x *AlertPolicy_Condition_MetricThreshold) GetFilter() string {
	if x != nil {
		return x.Filter
	}
	return ""
}

func (x *AlertPolicy_Condition_MetricThreshold) GetAggregations() []*Aggregation {
	if x != nil {
		return x.Aggregations
	}
	return nil
}

func (x *AlertPolicy_Condition_MetricThreshold) GetDenominatorFilter() string {
	if x != nil {
		return x.DenominatorFilter
	}
	return ""
}

func (x *AlertPolicy_Condition_MetricThreshold) GetDenominatorAggregations() []*Aggregation {
	if x != nil {
		return x.DenominatorAggregations
	}
	return nil
}

func (x *AlertPolicy_Condition_MetricThreshold) GetForecastOptions() *AlertPolicy_Condition_MetricThreshold_ForecastOptions {
	if x != nil {
		return x.ForecastOptions
	}
	return nil
}

func (x *AlertPolicy_Condition_MetricThreshold) GetComparison() ComparisonType {
	if x != nil {
		return x.Comparison
	}
	return ComparisonType_COMPARISON_UNSPECIFIED
}

func (x *AlertPolicy_Condition_MetricThreshold) GetThresholdValue() float64 {
	if x != nil {
		return x.ThresholdValue
	}
	return 0
}

func (x *AlertPolicy_Condition_MetricThreshold) GetDuration() *durationpb.Duration {
	if x != nil {
		return x.Duration
	}
	return nil
}

func (x *AlertPolicy_Condition_MetricThreshold) GetTrigger() *AlertPolicy_Condition_Trigger {
	if x != nil {
		return x.Trigger
	}
	return nil
}

func (x *AlertPolicy_Condition_MetricThreshold) GetEvaluationMissingData() AlertPolicy_Condition_EvaluationMissingData {
	if x != nil {
		return x.EvaluationMissingData
	}
	return AlertPolicy_Condition_EVALUATION_MISSING_DATA_UNSPECIFIED
}

// A condition type that checks that monitored resources
// are reporting data. The configuration defines a metric and
// a set of monitored resources. The predicate is considered in violation
// when a time series for the specified metric of a monitored
// resource does not include any data in the specified `duration`.
type AlertPolicy_Condition_MetricAbsence struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Required. A
	// [filter](https://cloud.google.com/monitoring/api/v3/filters) that
	// identifies which time series should be compared with the threshold.
	//
	// The filter is similar to the one that is specified in the
	// [`ListTimeSeries`
	// request](https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.timeSeries/list)
	// (that call is useful to verify the time series that will be retrieved /
	// processed). The filter must specify the metric type and the resource
	// type. Optionally, it can specify resource labels and metric labels.
	// This field must not exceed 2048 Unicode characters in length.
	Filter string `protobuf:"bytes,1,opt,name=filter,proto3" json:"filter,omitempty"`
	// 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 [`ListTimeSeries`
	// request](https://cloud.google.com/monitoring/api/ref_v3/rest/v3/projects.timeSeries/list).
	// It is advisable to use the `ListTimeSeries` method when debugging this
	// field.
	Aggregations []*Aggregation `protobuf:"bytes,5,rep,name=aggregations,proto3" json:"aggregations,omitempty"`
	// The amount of time that a time series must fail to report new
	// data to be considered failing. The minimum value of this field
	// is 120 seconds. Larger values that are a multiple of a
	// minute--for example, 240 or 300 seconds--are supported.
	// If an invalid value is given, an
	// error will be returned. The `Duration.nanos` field is
	// ignored.
	Duration *durationpb.Duration `protobuf:"bytes,2,opt,name=duration,proto3" json:"duration,omitempty"`
	// 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`.
	Trigger       *AlertPolicy_Condition_Trigger `protobuf:"bytes,3,opt,name=trigger,proto3" json:"trigger,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AlertPolicy_Condition_MetricAbsence) Reset() {
	*x = AlertPolicy_Condition_MetricAbsence{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[8]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_Condition_MetricAbsence) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_Condition_MetricAbsence) ProtoMessage() {}

func (x *AlertPolicy_Condition_MetricAbsence) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[8]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_Condition_MetricAbsence.ProtoReflect.Descriptor instead.
func (*AlertPolicy_Condition_MetricAbsence) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 1, 2}
}

func (x *AlertPolicy_Condition_MetricAbsence) GetFilter() string {
	if x != nil {
		return x.Filter
	}
	return ""
}

func (x *AlertPolicy_Condition_MetricAbsence) GetAggregations() []*Aggregation {
	if x != nil {
		return x.Aggregations
	}
	return nil
}

func (x *AlertPolicy_Condition_MetricAbsence) GetDuration() *durationpb.Duration {
	if x != nil {
		return x.Duration
	}
	return nil
}

func (x *AlertPolicy_Condition_MetricAbsence) GetTrigger() *AlertPolicy_Condition_Trigger {
	if x != nil {
		return x.Trigger
	}
	return nil
}

// A condition type that checks whether a log message in the [scoping
// project](https://cloud.google.com/monitoring/api/v3#project_name)
// satisfies the given filter. Logs from other projects in the metrics
// scope are not evaluated.
type AlertPolicy_Condition_LogMatch struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Required. A logs-based filter. See [Advanced Logs
	// Queries](https://cloud.google.com/logging/docs/view/advanced-queries)
	// for how this filter should be constructed.
	Filter string `protobuf:"bytes,1,opt,name=filter,proto3" json:"filter,omitempty"`
	// Optional. 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.
	//
	// Please see [the documentation on logs-based metric
	// `valueExtractor`s](https://cloud.google.com/logging/docs/reference/v2/rest/v2/projects.metrics#LogMetric.FIELDS.value_extractor)
	// for syntax and examples.
	LabelExtractors map[string]string `protobuf:"bytes,2,rep,name=label_extractors,json=labelExtractors,proto3" json:"label_extractors,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *AlertPolicy_Condition_LogMatch) Reset() {
	*x = AlertPolicy_Condition_LogMatch{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[9]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_Condition_LogMatch) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_Condition_LogMatch) ProtoMessage() {}

func (x *AlertPolicy_Condition_LogMatch) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[9]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_Condition_LogMatch.ProtoReflect.Descriptor instead.
func (*AlertPolicy_Condition_LogMatch) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 1, 3}
}

func (x *AlertPolicy_Condition_LogMatch) GetFilter() string {
	if x != nil {
		return x.Filter
	}
	return ""
}

func (x *AlertPolicy_Condition_LogMatch) GetLabelExtractors() map[string]string {
	if x != nil {
		return x.LabelExtractors
	}
	return nil
}

// A condition type that allows alerting policies to be defined using
// [Monitoring Query Language](https://cloud.google.com/monitoring/mql).
type AlertPolicy_Condition_MonitoringQueryLanguageCondition struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// [Monitoring Query Language](https://cloud.google.com/monitoring/mql)
	// query that outputs a boolean stream.
	Query string `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
	// 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.
	Duration *durationpb.Duration `protobuf:"bytes,2,opt,name=duration,proto3" json:"duration,omitempty"`
	// 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.
	Trigger *AlertPolicy_Condition_Trigger `protobuf:"bytes,3,opt,name=trigger,proto3" json:"trigger,omitempty"`
	// A condition control that determines how metric-threshold conditions
	// are evaluated when data stops arriving.
	EvaluationMissingData AlertPolicy_Condition_EvaluationMissingData `protobuf:"varint,4,opt,name=evaluation_missing_data,json=evaluationMissingData,proto3,enum=google.monitoring.v3.AlertPolicy_Condition_EvaluationMissingData" json:"evaluation_missing_data,omitempty"`
	unknownFields         protoimpl.UnknownFields
	sizeCache             protoimpl.SizeCache
}

func (x *AlertPolicy_Condition_MonitoringQueryLanguageCondition) Reset() {
	*x = AlertPolicy_Condition_MonitoringQueryLanguageCondition{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[10]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_Condition_MonitoringQueryLanguageCondition) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_Condition_MonitoringQueryLanguageCondition) ProtoMessage() {}

func (x *AlertPolicy_Condition_MonitoringQueryLanguageCondition) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[10]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_Condition_MonitoringQueryLanguageCondition.ProtoReflect.Descriptor instead.
func (*AlertPolicy_Condition_MonitoringQueryLanguageCondition) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 1, 4}
}

func (x *AlertPolicy_Condition_MonitoringQueryLanguageCondition) GetQuery() string {
	if x != nil {
		return x.Query
	}
	return ""
}

func (x *AlertPolicy_Condition_MonitoringQueryLanguageCondition) GetDuration() *durationpb.Duration {
	if x != nil {
		return x.Duration
	}
	return nil
}

func (x *AlertPolicy_Condition_MonitoringQueryLanguageCondition) GetTrigger() *AlertPolicy_Condition_Trigger {
	if x != nil {
		return x.Trigger
	}
	return nil
}

func (x *AlertPolicy_Condition_MonitoringQueryLanguageCondition) GetEvaluationMissingData() AlertPolicy_Condition_EvaluationMissingData {
	if x != nil {
		return x.EvaluationMissingData
	}
	return AlertPolicy_Condition_EVALUATION_MISSING_DATA_UNSPECIFIED
}

// A condition type that allows alerting policies to be defined using
// [Prometheus Query Language
// (PromQL)](https://prometheus.io/docs/prometheus/latest/querying/basics/).
//
// The PrometheusQueryLanguageCondition message contains information
// from a Prometheus alerting rule and its associated rule group.
//
// A Prometheus alerting rule is described
// [here](https://prometheus.io/docs/prometheus/latest/configuration/alerting_rules/).
// The semantics of a Prometheus alerting rule is described
// [here](https://prometheus.io/docs/prometheus/latest/configuration/recording_rules/#rule).
//
// A Prometheus rule group is described
// [here](https://prometheus.io/docs/prometheus/latest/configuration/recording_rules/).
// The semantics of a Prometheus rule group is described
// [here](https://prometheus.io/docs/prometheus/latest/configuration/recording_rules/#rule_group).
//
// Because Cloud Alerting has no representation of a Prometheus rule
// group resource, we must embed the information of the parent rule
// group inside each of the conditions that refer to it. We must also
// update the contents of all Prometheus alerts in case the information
// of their rule group changes.
//
// The PrometheusQueryLanguageCondition protocol buffer combines the
// information of the corresponding rule group and alerting rule.
// The structure of the PrometheusQueryLanguageCondition protocol buffer
// does NOT mimic the structure of the Prometheus rule group and alerting
// rule YAML declarations. The PrometheusQueryLanguageCondition protocol
// buffer may change in the future to support future rule group and/or
// alerting rule features. There are no new such features at the present
// time (2023-06-26).
type AlertPolicy_Condition_PrometheusQueryLanguageCondition struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Required. 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.
	Query string `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
	// Optional. Alerts are considered firing once their PromQL expression was
	// evaluated to be "true" for this long.
	// Alerts whose PromQL expression was not evaluated to be "true" for
	// long enough are considered pending.
	// Must be a non-negative duration or missing.
	// This field is optional. Its default value is zero.
	Duration *durationpb.Duration `protobuf:"bytes,2,opt,name=duration,proto3" json:"duration,omitempty"`
	// Optional. How often this rule should be evaluated.
	// Must be a positive multiple of 30 seconds or missing.
	// This field is optional. Its 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.
	EvaluationInterval *durationpb.Duration `protobuf:"bytes,3,opt,name=evaluation_interval,json=evaluationInterval,proto3" json:"evaluation_interval,omitempty"`
	// Optional. Labels to add to or overwrite in the PromQL query result.
	// Label names [must be
	// valid](https://prometheus.io/docs/concepts/data_model/#metric-names-and-labels).
	// Label values can be [templatized by using
	// variables](https://cloud.google.com/monitoring/alerts/doc-variables#doc-vars).
	// The only available variable names are the names of the labels in the
	// PromQL result, including "__name__" and "value". "labels" may be empty.
	Labels map[string]string `protobuf:"bytes,4,rep,name=labels,proto3" json:"labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// Optional. 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. If this field is not empty, then it must
	// contain a valid UTF-8 string.
	// This field may not exceed 2048 Unicode characters in length.
	RuleGroup string `protobuf:"bytes,5,opt,name=rule_group,json=ruleGroup,proto3" json:"rule_group,omitempty"`
	// Optional. 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](https://prometheus.io/docs/concepts/data_model/#metric-names-and-labels).
	// This field may not exceed 2048 Unicode characters in length.
	AlertRule string `protobuf:"bytes,6,opt,name=alert_rule,json=alertRule,proto3" json:"alert_rule,omitempty"`
	// Optional. Whether to disable metric existence validation for this
	// condition.
	//
	// This allows alerting policies to be defined on metrics that do not yet
	// exist, improving advanced customer workflows such as configuring
	// alerting policies using Terraform.
	//
	// Users with the `monitoring.alertPolicyViewer` role are able to see the
	// name of the non-existent metric in the alerting policy condition.
	DisableMetricValidation bool `protobuf:"varint,7,opt,name=disable_metric_validation,json=disableMetricValidation,proto3" json:"disable_metric_validation,omitempty"`
	unknownFields           protoimpl.UnknownFields
	sizeCache               protoimpl.SizeCache
}

func (x *AlertPolicy_Condition_PrometheusQueryLanguageCondition) Reset() {
	*x = AlertPolicy_Condition_PrometheusQueryLanguageCondition{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[11]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_Condition_PrometheusQueryLanguageCondition) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_Condition_PrometheusQueryLanguageCondition) ProtoMessage() {}

func (x *AlertPolicy_Condition_PrometheusQueryLanguageCondition) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[11]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_Condition_PrometheusQueryLanguageCondition.ProtoReflect.Descriptor instead.
func (*AlertPolicy_Condition_PrometheusQueryLanguageCondition) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 1, 5}
}

func (x *AlertPolicy_Condition_PrometheusQueryLanguageCondition) GetQuery() string {
	if x != nil {
		return x.Query
	}
	return ""
}

func (x *AlertPolicy_Condition_PrometheusQueryLanguageCondition) GetDuration() *durationpb.Duration {
	if x != nil {
		return x.Duration
	}
	return nil
}

func (x *AlertPolicy_Condition_PrometheusQueryLanguageCondition) GetEvaluationInterval() *durationpb.Duration {
	if x != nil {
		return x.EvaluationInterval
	}
	return nil
}

func (x *AlertPolicy_Condition_PrometheusQueryLanguageCondition) GetLabels() map[string]string {
	if x != nil {
		return x.Labels
	}
	return nil
}

func (x *AlertPolicy_Condition_PrometheusQueryLanguageCondition) GetRuleGroup() string {
	if x != nil {
		return x.RuleGroup
	}
	return ""
}

func (x *AlertPolicy_Condition_PrometheusQueryLanguageCondition) GetAlertRule() string {
	if x != nil {
		return x.AlertRule
	}
	return ""
}

func (x *AlertPolicy_Condition_PrometheusQueryLanguageCondition) GetDisableMetricValidation() bool {
	if x != nil {
		return x.DisableMetricValidation
	}
	return false
}

// A condition that allows alerting policies to be defined using GoogleSQL.
// SQL conditions examine a sliding window of logs using GoogleSQL.
// Alert policies with SQL conditions may incur additional billing.
type AlertPolicy_Condition_SqlCondition struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Required. The Log Analytics SQL query to run, as a string.  The query
	// must conform to the required shape. Specifically, the query must not
	// try to filter the input by time.  A filter will automatically be
	// applied to filter the input so that the query receives all rows
	// received since the last time the query was run.
	//
	// For example, the following query extracts all log entries containing an
	// HTTP request:
	//
	//	SELECT
	//	  timestamp, log_name, severity, http_request, resource, labels
	//	FROM
	//	  my-project.global._Default._AllLogs
	//	WHERE
	//	  http_request IS NOT NULL
	Query string `protobuf:"bytes,1,opt,name=query,proto3" json:"query,omitempty"`
	// The schedule indicates how often the query should be run.
	//
	// Types that are valid to be assigned to Schedule:
	//
	//	*AlertPolicy_Condition_SqlCondition_Minutes_
	//	*AlertPolicy_Condition_SqlCondition_Hourly_
	//	*AlertPolicy_Condition_SqlCondition_Daily_
	Schedule isAlertPolicy_Condition_SqlCondition_Schedule `protobuf_oneof:"schedule"`
	// The test to be run against the SQL result set.
	//
	// Types that are valid to be assigned to Evaluate:
	//
	//	*AlertPolicy_Condition_SqlCondition_RowCountTest_
	//	*AlertPolicy_Condition_SqlCondition_BooleanTest_
	Evaluate      isAlertPolicy_Condition_SqlCondition_Evaluate `protobuf_oneof:"evaluate"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AlertPolicy_Condition_SqlCondition) Reset() {
	*x = AlertPolicy_Condition_SqlCondition{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[12]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_Condition_SqlCondition) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_Condition_SqlCondition) ProtoMessage() {}

func (x *AlertPolicy_Condition_SqlCondition) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[12]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_Condition_SqlCondition.ProtoReflect.Descriptor instead.
func (*AlertPolicy_Condition_SqlCondition) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 1, 6}
}

func (x *AlertPolicy_Condition_SqlCondition) GetQuery() string {
	if x != nil {
		return x.Query
	}
	return ""
}

func (x *AlertPolicy_Condition_SqlCondition) GetSchedule() isAlertPolicy_Condition_SqlCondition_Schedule {
	if x != nil {
		return x.Schedule
	}
	return nil
}

func (x *AlertPolicy_Condition_SqlCondition) GetMinutes() *AlertPolicy_Condition_SqlCondition_Minutes {
	if x != nil {
		if x, ok := x.Schedule.(*AlertPolicy_Condition_SqlCondition_Minutes_); ok {
			return x.Minutes
		}
	}
	return nil
}

func (x *AlertPolicy_Condition_SqlCondition) GetHourly() *AlertPolicy_Condition_SqlCondition_Hourly {
	if x != nil {
		if x, ok := x.Schedule.(*AlertPolicy_Condition_SqlCondition_Hourly_); ok {
			return x.Hourly
		}
	}
	return nil
}

func (x *AlertPolicy_Condition_SqlCondition) GetDaily() *AlertPolicy_Condition_SqlCondition_Daily {
	if x != nil {
		if x, ok := x.Schedule.(*AlertPolicy_Condition_SqlCondition_Daily_); ok {
			return x.Daily
		}
	}
	return nil
}

func (x *AlertPolicy_Condition_SqlCondition) GetEvaluate() isAlertPolicy_Condition_SqlCondition_Evaluate {
	if x != nil {
		return x.Evaluate
	}
	return nil
}

func (x *AlertPolicy_Condition_SqlCondition) GetRowCountTest() *AlertPolicy_Condition_SqlCondition_RowCountTest {
	if x != nil {
		if x, ok := x.Evaluate.(*AlertPolicy_Condition_SqlCondition_RowCountTest_); ok {
			return x.RowCountTest
		}
	}
	return nil
}

func (x *AlertPolicy_Condition_SqlCondition) GetBooleanTest() *AlertPolicy_Condition_SqlCondition_BooleanTest {
	if x != nil {
		if x, ok := x.Evaluate.(*AlertPolicy_Condition_SqlCondition_BooleanTest_); ok {
			return x.BooleanTest
		}
	}
	return nil
}

type isAlertPolicy_Condition_SqlCondition_Schedule interface {
	isAlertPolicy_Condition_SqlCondition_Schedule()
}

type AlertPolicy_Condition_SqlCondition_Minutes_ struct {
	// Schedule the query to execute every so many minutes.
	Minutes *AlertPolicy_Condition_SqlCondition_Minutes `protobuf:"bytes,2,opt,name=minutes,proto3,oneof"`
}

type AlertPolicy_Condition_SqlCondition_Hourly_ struct {
	// Schedule the query to execute every so many hours.
	Hourly *AlertPolicy_Condition_SqlCondition_Hourly `protobuf:"bytes,3,opt,name=hourly,proto3,oneof"`
}

type AlertPolicy_Condition_SqlCondition_Daily_ struct {
	// Schedule the query to execute every so many days.
	Daily *AlertPolicy_Condition_SqlCondition_Daily `protobuf:"bytes,4,opt,name=daily,proto3,oneof"`
}

func (*AlertPolicy_Condition_SqlCondition_Minutes_) isAlertPolicy_Condition_SqlCondition_Schedule() {}

func (*AlertPolicy_Condition_SqlCondition_Hourly_) isAlertPolicy_Condition_SqlCondition_Schedule() {}

func (*AlertPolicy_Condition_SqlCondition_Daily_) isAlertPolicy_Condition_SqlCondition_Schedule() {}

type isAlertPolicy_Condition_SqlCondition_Evaluate interface {
	isAlertPolicy_Condition_SqlCondition_Evaluate()
}

type AlertPolicy_Condition_SqlCondition_RowCountTest_ struct {
	// Test the row count against a threshold.
	RowCountTest *AlertPolicy_Condition_SqlCondition_RowCountTest `protobuf:"bytes,5,opt,name=row_count_test,json=rowCountTest,proto3,oneof"`
}

type AlertPolicy_Condition_SqlCondition_BooleanTest_ struct {
	// Test the boolean value in the indicated column.
	BooleanTest *AlertPolicy_Condition_SqlCondition_BooleanTest `protobuf:"bytes,6,opt,name=boolean_test,json=booleanTest,proto3,oneof"`
}

func (*AlertPolicy_Condition_SqlCondition_RowCountTest_) isAlertPolicy_Condition_SqlCondition_Evaluate() {
}

func (*AlertPolicy_Condition_SqlCondition_BooleanTest_) isAlertPolicy_Condition_SqlCondition_Evaluate() {
}

// Options used when forecasting the time series and testing
// the predicted value against the threshold.
type AlertPolicy_Condition_MetricThreshold_ForecastOptions struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Required. The length of time into the future to forecast whether a
	// time series 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 time series is
	// considered to be failing.
	// The forecast horizon can range from 1 hour to 60 hours.
	ForecastHorizon *durationpb.Duration `protobuf:"bytes,1,opt,name=forecast_horizon,json=forecastHorizon,proto3" json:"forecast_horizon,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

func (x *AlertPolicy_Condition_MetricThreshold_ForecastOptions) Reset() {
	*x = AlertPolicy_Condition_MetricThreshold_ForecastOptions{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[13]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_Condition_MetricThreshold_ForecastOptions) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_Condition_MetricThreshold_ForecastOptions) ProtoMessage() {}

func (x *AlertPolicy_Condition_MetricThreshold_ForecastOptions) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[13]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_Condition_MetricThreshold_ForecastOptions.ProtoReflect.Descriptor instead.
func (*AlertPolicy_Condition_MetricThreshold_ForecastOptions) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 1, 1, 0}
}

func (x *AlertPolicy_Condition_MetricThreshold_ForecastOptions) GetForecastHorizon() *durationpb.Duration {
	if x != nil {
		return x.ForecastHorizon
	}
	return nil
}

// Used to schedule the query to run every so many minutes.
type AlertPolicy_Condition_SqlCondition_Minutes struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Required. Number of minutes between runs. The interval must be
	// greater than or equal to 5 minutes and less than or equal to 1440
	// minutes.
	Periodicity   int32 `protobuf:"varint,1,opt,name=periodicity,proto3" json:"periodicity,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AlertPolicy_Condition_SqlCondition_Minutes) Reset() {
	*x = AlertPolicy_Condition_SqlCondition_Minutes{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[16]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_Condition_SqlCondition_Minutes) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_Condition_SqlCondition_Minutes) ProtoMessage() {}

func (x *AlertPolicy_Condition_SqlCondition_Minutes) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[16]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_Condition_SqlCondition_Minutes.ProtoReflect.Descriptor instead.
func (*AlertPolicy_Condition_SqlCondition_Minutes) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 1, 6, 0}
}

func (x *AlertPolicy_Condition_SqlCondition_Minutes) GetPeriodicity() int32 {
	if x != nil {
		return x.Periodicity
	}
	return 0
}

// Used to schedule the query to run every so many hours.
type AlertPolicy_Condition_SqlCondition_Hourly struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Required. The number of hours between runs. Must be greater than or
	// equal to 1 hour and less than or equal to 48 hours.
	Periodicity int32 `protobuf:"varint,1,opt,name=periodicity,proto3" json:"periodicity,omitempty"`
	// Optional. The number of minutes after the hour (in UTC) to run the
	// query. Must be greater than or equal to 0 minutes and less than or
	// equal to 59 minutes.  If left unspecified, then an arbitrary offset
	// is used.
	MinuteOffset  *int32 `protobuf:"varint,2,opt,name=minute_offset,json=minuteOffset,proto3,oneof" json:"minute_offset,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AlertPolicy_Condition_SqlCondition_Hourly) Reset() {
	*x = AlertPolicy_Condition_SqlCondition_Hourly{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[17]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_Condition_SqlCondition_Hourly) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_Condition_SqlCondition_Hourly) ProtoMessage() {}

func (x *AlertPolicy_Condition_SqlCondition_Hourly) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[17]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_Condition_SqlCondition_Hourly.ProtoReflect.Descriptor instead.
func (*AlertPolicy_Condition_SqlCondition_Hourly) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 1, 6, 1}
}

func (x *AlertPolicy_Condition_SqlCondition_Hourly) GetPeriodicity() int32 {
	if x != nil {
		return x.Periodicity
	}
	return 0
}

func (x *AlertPolicy_Condition_SqlCondition_Hourly) GetMinuteOffset() int32 {
	if x != nil && x.MinuteOffset != nil {
		return *x.MinuteOffset
	}
	return 0
}

// Used to schedule the query to run every so many days.
type AlertPolicy_Condition_SqlCondition_Daily struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Required. The number of days between runs. Must be greater than or
	// equal to 1 day and less than or equal to 31 days.
	Periodicity int32 `protobuf:"varint,1,opt,name=periodicity,proto3" json:"periodicity,omitempty"`
	// Optional. The time of day (in UTC) at which the query should run. If
	// left unspecified, the server picks an arbitrary time of day and runs
	// the query at the same time each day.
	ExecutionTime *timeofday.TimeOfDay `protobuf:"bytes,2,opt,name=execution_time,json=executionTime,proto3" json:"execution_time,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AlertPolicy_Condition_SqlCondition_Daily) Reset() {
	*x = AlertPolicy_Condition_SqlCondition_Daily{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[18]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_Condition_SqlCondition_Daily) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_Condition_SqlCondition_Daily) ProtoMessage() {}

func (x *AlertPolicy_Condition_SqlCondition_Daily) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[18]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_Condition_SqlCondition_Daily.ProtoReflect.Descriptor instead.
func (*AlertPolicy_Condition_SqlCondition_Daily) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 1, 6, 2}
}

func (x *AlertPolicy_Condition_SqlCondition_Daily) GetPeriodicity() int32 {
	if x != nil {
		return x.Periodicity
	}
	return 0
}

func (x *AlertPolicy_Condition_SqlCondition_Daily) GetExecutionTime() *timeofday.TimeOfDay {
	if x != nil {
		return x.ExecutionTime
	}
	return nil
}

// A test that checks if the number of rows in the result set
// violates some threshold.
type AlertPolicy_Condition_SqlCondition_RowCountTest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Required. The comparison to apply between the number of rows returned
	// by the query and the threshold.
	Comparison ComparisonType `protobuf:"varint,1,opt,name=comparison,proto3,enum=google.monitoring.v3.ComparisonType" json:"comparison,omitempty"`
	// Required. The value against which to compare the row count.
	Threshold     int64 `protobuf:"varint,2,opt,name=threshold,proto3" json:"threshold,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AlertPolicy_Condition_SqlCondition_RowCountTest) Reset() {
	*x = AlertPolicy_Condition_SqlCondition_RowCountTest{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[19]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_Condition_SqlCondition_RowCountTest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_Condition_SqlCondition_RowCountTest) ProtoMessage() {}

func (x *AlertPolicy_Condition_SqlCondition_RowCountTest) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[19]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_Condition_SqlCondition_RowCountTest.ProtoReflect.Descriptor instead.
func (*AlertPolicy_Condition_SqlCondition_RowCountTest) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 1, 6, 3}
}

func (x *AlertPolicy_Condition_SqlCondition_RowCountTest) GetComparison() ComparisonType {
	if x != nil {
		return x.Comparison
	}
	return ComparisonType_COMPARISON_UNSPECIFIED
}

func (x *AlertPolicy_Condition_SqlCondition_RowCountTest) GetThreshold() int64 {
	if x != nil {
		return x.Threshold
	}
	return 0
}

// A test that uses an alerting result in a boolean column produced by
// the SQL query.
type AlertPolicy_Condition_SqlCondition_BooleanTest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Required. The name of the column containing the boolean value. If the
	// value in a row is NULL, that row is ignored.
	Column        string `protobuf:"bytes,1,opt,name=column,proto3" json:"column,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AlertPolicy_Condition_SqlCondition_BooleanTest) Reset() {
	*x = AlertPolicy_Condition_SqlCondition_BooleanTest{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[20]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_Condition_SqlCondition_BooleanTest) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_Condition_SqlCondition_BooleanTest) ProtoMessage() {}

func (x *AlertPolicy_Condition_SqlCondition_BooleanTest) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[20]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_Condition_SqlCondition_BooleanTest.ProtoReflect.Descriptor instead.
func (*AlertPolicy_Condition_SqlCondition_BooleanTest) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 1, 6, 4}
}

func (x *AlertPolicy_Condition_SqlCondition_BooleanTest) GetColumn() string {
	if x != nil {
		return x.Column
	}
	return ""
}

// Control over the rate of notifications sent to this alerting policy's
// notification channels.
type AlertPolicy_AlertStrategy_NotificationRateLimit struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Not more than one notification per `period`.
	Period        *durationpb.Duration `protobuf:"bytes,1,opt,name=period,proto3" json:"period,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *AlertPolicy_AlertStrategy_NotificationRateLimit) Reset() {
	*x = AlertPolicy_AlertStrategy_NotificationRateLimit{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[21]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_AlertStrategy_NotificationRateLimit) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_AlertStrategy_NotificationRateLimit) ProtoMessage() {}

func (x *AlertPolicy_AlertStrategy_NotificationRateLimit) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[21]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_AlertStrategy_NotificationRateLimit.ProtoReflect.Descriptor instead.
func (*AlertPolicy_AlertStrategy_NotificationRateLimit) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 2, 0}
}

func (x *AlertPolicy_AlertStrategy_NotificationRateLimit) GetPeriod() *durationpb.Duration {
	if x != nil {
		return x.Period
	}
	return nil
}

// Control over how the notification channels in `notification_channels`
// are notified when this alert fires, on a per-channel basis.
type AlertPolicy_AlertStrategy_NotificationChannelStrategy struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// The full REST resource name for 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]
	NotificationChannelNames []string `protobuf:"bytes,1,rep,name=notification_channel_names,json=notificationChannelNames,proto3" json:"notification_channel_names,omitempty"`
	// The frequency at which to send reminder notifications for open
	// incidents.
	RenotifyInterval *durationpb.Duration `protobuf:"bytes,2,opt,name=renotify_interval,json=renotifyInterval,proto3" json:"renotify_interval,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

func (x *AlertPolicy_AlertStrategy_NotificationChannelStrategy) Reset() {
	*x = AlertPolicy_AlertStrategy_NotificationChannelStrategy{}
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[22]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

func (x *AlertPolicy_AlertStrategy_NotificationChannelStrategy) String() string {
	return protoimpl.X.MessageStringOf(x)
}

func (*AlertPolicy_AlertStrategy_NotificationChannelStrategy) ProtoMessage() {}

func (x *AlertPolicy_AlertStrategy_NotificationChannelStrategy) ProtoReflect() protoreflect.Message {
	mi := &file_google_monitoring_v3_alert_proto_msgTypes[22]
	if x != nil {
		ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
		if ms.LoadMessageInfo() == nil {
			ms.StoreMessageInfo(mi)
		}
		return ms
	}
	return mi.MessageOf(x)
}

// Deprecated: Use AlertPolicy_AlertStrategy_NotificationChannelStrategy.ProtoReflect.Descriptor instead.
func (*AlertPolicy_AlertStrategy_NotificationChannelStrategy) Descriptor() ([]byte, []int) {
	return file_google_monitoring_v3_alert_proto_rawDescGZIP(), []int{0, 2, 1}
}

func (x *AlertPolicy_AlertStrategy_NotificationChannelStrategy) GetNotificationChannelNames() []string {
	if x != nil {
		return x.NotificationChannelNames
	}
	return nil
}

func (x *AlertPolicy_AlertStrategy_NotificationChannelStrategy) GetRenotifyInterval() *durationpb.Duration {
	if x != nil {
		return x.RenotifyInterval
	}
	return nil
}

var File_google_monitoring_v3_alert_proto protoreflect.FileDescriptor

const file_google_monitoring_v3_alert_proto_rawDesc = "" +
	"\n" +
	" google/monitoring/v3/alert.proto\x12\x14google.monitoring.v3\x1a\x1fgoogle/api/field_behavior.proto\x1a\x19google/api/resource.proto\x1a!google/monitoring/v3/common.proto\x1a*google/monitoring/v3/mutation_record.proto\x1a\x1egoogle/protobuf/duration.proto\x1a\x1egoogle/protobuf/wrappers.proto\x1a\x17google/rpc/status.proto\x1a\x1bgoogle/type/timeofday.proto\"\xe55\n" +
	"\vAlertPolicy\x12\x17\n" +
	"\x04name\x18\x01 \x01(\tB\x03\xe0A\bR\x04name\x12!\n" +
	"\fdisplay_name\x18\x02 \x01(\tR\vdisplayName\x12U\n" +
	"\rdocumentation\x18\r \x01(\v2/.google.monitoring.v3.AlertPolicy.DocumentationR\rdocumentation\x12R\n" +
	"\vuser_labels\x18\x10 \x03(\v21.google.monitoring.v3.AlertPolicy.UserLabelsEntryR\n" +
	"userLabels\x12K\n" +
	"\n" +
	"conditions\x18\f \x03(\v2+.google.monitoring.v3.AlertPolicy.ConditionR\n" +
	"conditions\x12S\n" +
	"\bcombiner\x18\x06 \x01(\x0e27.google.monitoring.v3.AlertPolicy.ConditionCombinerTypeR\bcombiner\x124\n" +
	"\aenabled\x18\x11 \x01(\v2\x1a.google.protobuf.BoolValueR\aenabled\x12.\n" +
	"\bvalidity\x18\x12 \x01(\v2\x12.google.rpc.StatusR\bvalidity\x123\n" +
	"\x15notification_channels\x18\x0e \x03(\tR\x14notificationChannels\x12M\n" +
	"\x0fcreation_record\x18\n" +
	" \x01(\v2$.google.monitoring.v3.MutationRecordR\x0ecreationRecord\x12M\n" +
	"\x0fmutation_record\x18\v \x01(\v2$.google.monitoring.v3.MutationRecordR\x0emutationRecord\x12V\n" +
	"\x0ealert_strategy\x18\x15 \x01(\v2/.google.monitoring.v3.AlertPolicy.AlertStrategyR\ralertStrategy\x12K\n" +
	"\bseverity\x18\x16 \x01(\x0e2*.google.monitoring.v3.AlertPolicy.SeverityB\x03\xe0A\x01R\bseverity\x1a\xf3\x01\n" +
	"\rDocumentation\x12\x18\n" +
	"\acontent\x18\x01 \x01(\tR\acontent\x12\x1b\n" +
	"\tmime_type\x18\x02 \x01(\tR\bmimeType\x12\x1d\n" +
	"\asubject\x18\x03 \x01(\tB\x03\xe0A\x01R\asubject\x12O\n" +
	"\x05links\x18\x04 \x03(\v24.google.monitoring.v3.AlertPolicy.Documentation.LinkB\x03\xe0A\x01R\x05links\x1a;\n" +
	"\x04Link\x12!\n" +
	"\fdisplay_name\x18\x01 \x01(\tR\vdisplayName\x12\x10\n" +
	"\x03url\x18\x02 \x01(\tR\x03url\x1a\xa5#\n" +
	"\tCondition\x12\x12\n" +
	"\x04name\x18\f \x01(\tR\x04name\x12!\n" +
	"\fdisplay_name\x18\x06 \x01(\tR\vdisplayName\x12n\n" +
	"\x13condition_threshold\x18\x01 \x01(\v2;.google.monitoring.v3.AlertPolicy.Condition.MetricThresholdH\x00R\x12conditionThreshold\x12f\n" +
	"\x10condition_absent\x18\x02 \x01(\v29.google.monitoring.v3.AlertPolicy.Condition.MetricAbsenceH\x00R\x0fconditionAbsent\x12j\n" +
	"\x15condition_matched_log\x18\x14 \x01(\v24.google.monitoring.v3.AlertPolicy.Condition.LogMatchH\x00R\x13conditionMatchedLog\x12\x9d\x01\n" +
	"#condition_monitoring_query_language\x18\x13 \x01(\v2L.google.monitoring.v3.AlertPolicy.Condition.MonitoringQueryLanguageConditionH\x00R conditionMonitoringQueryLanguage\x12\x9d\x01\n" +
	"#condition_prometheus_query_language\x18\x15 \x01(\v2L.google.monitoring.v3.AlertPolicy.Condition.PrometheusQueryLanguageConditionH\x00R conditionPrometheusQueryLanguage\x12_\n" +
	"\rcondition_sql\x18\x16 \x01(\v28.google.monitoring.v3.AlertPolicy.Condition.SqlConditionH\x00R\fconditionSql\x1aE\n" +
	"\aTrigger\x12\x16\n" +
	"\x05count\x18\x01 \x01(\x05H\x00R\x05count\x12\x1a\n" +
	"\apercent\x18\x02 \x01(\x01H\x00R\apercentB\x06\n" +
	"\x04type\x1a\xc8\x06\n" +
	"\x0fMetricThreshold\x12\x1b\n" +
	"\x06filter\x18\x02 \x01(\tB\x03\xe0A\x02R\x06filter\x12E\n" +
	"\faggregations\x18\b \x03(\v2!.google.monitoring.v3.AggregationR\faggregations\x12-\n" +
	"\x12denominator_filter\x18\t \x01(\tR\x11denominatorFilter\x12\\\n" +
	"\x18denominator_aggregations\x18\n" +
	" \x03(\v2!.google.monitoring.v3.AggregationR\x17denominatorAggregations\x12v\n" +
	"\x10forecast_options\x18\f \x01(\v2K.google.monitoring.v3.AlertPolicy.Condition.MetricThreshold.ForecastOptionsR\x0fforecastOptions\x12D\n" +
	"\n" +
	"comparison\x18\x04 \x01(\x0e2$.google.monitoring.v3.ComparisonTypeR\n" +
	"comparison\x12'\n" +
	"\x0fthreshold_value\x18\x05 \x01(\x01R\x0ethresholdValue\x125\n" +
	"\bduration\x18\x06 \x01(\v2\x19.google.protobuf.DurationR\bduration\x12M\n" +
	"\atrigger\x18\a \x01(\v23.google.monitoring.v3.AlertPolicy.Condition.TriggerR\atrigger\x12y\n" +
	"\x17evaluation_missing_data\x18\v \x01(\x0e2A.google.monitoring.v3.AlertPolicy.Condition.EvaluationMissingDataR\x15evaluationMissingData\x1a\\\n" +
	"\x0fForecastOptions\x12I\n" +
	"\x10forecast_horizon\x18\x01 \x01(\v2\x19.google.protobuf.DurationB\x03\xe0A\x02R\x0fforecastHorizon\x1a\xf9\x01\n" +
	"\rMetricAbsence\x12\x1b\n" +
	"\x06filter\x18\x01 \x01(\tB\x03\xe0A\x02R\x06filter\x12E\n" +
	"\faggregations\x18\x05 \x03(\v2!.google.monitoring.v3.AggregationR\faggregations\x125\n" +
	"\bduration\x18\x02 \x01(\v2\x19.google.protobuf.DurationR\bduration\x12M\n" +
	"\atrigger\x18\x03 \x01(\v23.google.monitoring.v3.AlertPolicy.Condition.TriggerR\atrigger\x1a\xe1\x01\n" +
	"\bLogMatch\x12\x1b\n" +
	"\x06filter\x18\x01 \x01(\tB\x03\xe0A\x02R\x06filter\x12t\n" +
	"\x10label_extractors\x18\x02 \x03(\v2I.google.monitoring.v3.AlertPolicy.Condition.LogMatch.LabelExtractorsEntryR\x0flabelExtractors\x1aB\n" +
	"\x14LabelExtractorsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\x1a\xb9\x02\n" +
	" MonitoringQueryLanguageCondition\x12\x14\n" +
	"\x05query\x18\x01 \x01(\tR\x05query\x125\n" +
	"\bduration\x18\x02 \x01(\v2\x19.google.protobuf.DurationR\bduration\x12M\n" +
	"\atrigger\x18\x03 \x01(\v23.google.monitoring.v3.AlertPolicy.Condition.TriggerR\atrigger\x12y\n" +
	"\x17evaluation_missing_data\x18\x04 \x01(\x0e2A.google.monitoring.v3.AlertPolicy.Condition.EvaluationMissingDataR\x15evaluationMissingData\x1a\x85\x04\n" +
	" PrometheusQueryLanguageCondition\x12\x19\n" +
	"\x05query\x18\x01 \x01(\tB\x03\xe0A\x02R\x05query\x12:\n" +
	"\bduration\x18\x02 \x01(\v2\x19.google.protobuf.DurationB\x03\xe0A\x01R\bduration\x12O\n" +
	"\x13evaluation_interval\x18\x03 \x01(\v2\x19.google.protobuf.DurationB\x03\xe0A\x01R\x12evaluationInterval\x12u\n" +
	"\x06labels\x18\x04 \x03(\v2X.google.monitoring.v3.AlertPolicy.Condition.PrometheusQueryLanguageCondition.LabelsEntryB\x03\xe0A\x01R\x06labels\x12\"\n" +
	"\n" +
	"rule_group\x18\x05 \x01(\tB\x03\xe0A\x01R\truleGroup\x12\"\n" +
	"\n" +
	"alert_rule\x18\x06 \x01(\tB\x03\xe0A\x01R\talertRule\x12?\n" +
	"\x19disable_metric_validation\x18\a \x01(\bB\x03\xe0A\x01R\x17disableMetricValidation\x1a9\n" +
	"\vLabelsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\x1a\xee\a\n" +
	"\fSqlCondition\x12\x19\n" +
	"\x05query\x18\x01 \x01(\tB\x03\xe0A\x02R\x05query\x12\\\n" +
	"\aminutes\x18\x02 \x01(\v2@.google.monitoring.v3.AlertPolicy.Condition.SqlCondition.MinutesH\x00R\aminutes\x12Y\n" +
	"\x06hourly\x18\x03 \x01(\v2?.google.monitoring.v3.AlertPolicy.Condition.SqlCondition.HourlyH\x00R\x06hourly\x12V\n" +
	"\x05daily\x18\x04 \x01(\v2>.google.monitoring.v3.AlertPolicy.Condition.SqlCondition.DailyH\x00R\x05daily\x12m\n" +
	"\x0erow_count_test\x18\x05 \x01(\v2E.google.monitoring.v3.AlertPolicy.Condition.SqlCondition.RowCountTestH\x01R\frowCountTest\x12i\n" +
	"\fboolean_test\x18\x06 \x01(\v2D.google.monitoring.v3.AlertPolicy.Condition.SqlCondition.BooleanTestH\x01R\vbooleanTest\x1a0\n" +
	"\aMinutes\x12%\n" +
	"\vperiodicity\x18\x01 \x01(\x05B\x03\xe0A\x02R\vperiodicity\x1ap\n" +
	"\x06Hourly\x12%\n" +
	"\vperiodicity\x18\x01 \x01(\x05B\x03\xe0A\x02R\vperiodicity\x12-\n" +
	"\rminute_offset\x18\x02 \x01(\x05B\x03\xe0A\x01H\x00R\fminuteOffset\x88\x01\x01B\x10\n" +
	"\x0e_minute_offset\x1ar\n" +
	"\x05Daily\x12%\n" +
	"\vperiodicity\x18\x01 \x01(\x05B\x03\xe0A\x02R\vperiodicity\x12B\n" +
	"\x0eexecution_time\x18\x02 \x01(\v2\x16.google.type.TimeOfDayB\x03\xe0A\x01R\rexecutionTime\x1a|\n" +
	"\fRowCountTest\x12I\n" +
	"\n" +
	"comparison\x18\x01 \x01(\x0e2$.google.monitoring.v3.ComparisonTypeB\x03\xe0A\x02R\n" +
	"comparison\x12!\n" +
	"\tthreshold\x18\x02 \x01(\x03B\x03\xe0A\x02R\tthreshold\x1a*\n" +
	"\vBooleanTest\x12\x1b\n" +
	"\x06column\x18\x01 \x01(\tB\x03\xe0A\x02R\x06columnB\n" +
	"\n" +
	"\bscheduleB\n" +
	"\n" +
	"\bevaluate\"\xad\x01\n" +
	"\x15EvaluationMissingData\x12'\n" +
	"#EVALUATION_MISSING_DATA_UNSPECIFIED\x10\x00\x12$\n" +
	" EVALUATION_MISSING_DATA_INACTIVE\x10\x01\x12\"\n" +
	"\x1eEVALUATION_MISSING_DATA_ACTIVE\x10\x02\x12!\n" +
	"\x1dEVALUATION_MISSING_DATA_NO_OP\x10\x03:\x97\x02\xeaA\x93\x02\n" +
	".monitoring.googleapis.com/AlertPolicyCondition\x12Fprojects/{project}/alertPolicies/{alert_policy}/conditions/{condition}\x12Porganizations/{organization}/alertPolicies/{alert_policy}/conditions/{condition}\x12Dfolders/{folder}/alertPolicies/{alert_policy}/conditions/{condition}\x12\x01*B\v\n" +
	"\tcondition\x1a\x96\x06\n" +
	"\rAlertStrategy\x12}\n" +
	"\x17notification_rate_limit\x18\x01 \x01(\v2E.google.monitoring.v3.AlertPolicy.AlertStrategy.NotificationRateLimitR\x15notificationRateLimit\x12u\n" +
	"\x14notification_prompts\x18\x02 \x03(\x0e2B.google.monitoring.v3.AlertPolicy.AlertStrategy.NotificationPromptR\x13notificationPrompts\x128\n" +
	"\n" +
	"auto_close\x18\x03 \x01(\v2\x19.google.protobuf.DurationR\tautoClose\x12\x8f\x01\n" +
	"\x1dnotification_channel_strategy\x18\x04 \x03(\v2K.google.monitoring.v3.AlertPolicy.AlertStrategy.NotificationChannelStrategyR\x1bnotificationChannelStrategy\x1aJ\n" +
	"\x15NotificationRateLimit\x121\n" +
	"\x06period\x18\x01 \x01(\v2\x19.google.protobuf.DurationR\x06period\x1a\xa3\x01\n" +
	"\x1bNotificationChannelStrategy\x12<\n" +
	"\x1anotification_channel_names\x18\x01 \x03(\tR\x18notificationChannelNames\x12F\n" +
	"\x11renotify_interval\x18\x02 \x01(\v2\x19.google.protobuf.DurationR\x10renotifyInterval\"Q\n" +
	"\x12NotificationPrompt\x12#\n" +
	"\x1fNOTIFICATION_PROMPT_UNSPECIFIED\x10\x00\x12\n" +
	"\n" +
	"\x06OPENED\x10\x01\x12\n" +
	"\n" +
	"\x06CLOSED\x10\x03\x1a=\n" +
	"\x0fUserLabelsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"a\n" +
	"\x15ConditionCombinerType\x12\x17\n" +
	"\x13COMBINE_UNSPECIFIED\x10\x00\x12\a\n" +
	"\x03AND\x10\x01\x12\x06\n" +
	"\x02OR\x10\x02\x12\x1e\n" +
	"\x1aAND_WITH_MATCHING_RESOURCE\x10\x03\"J\n" +
	"\bSeverity\x12\x18\n" +
	"\x14SEVERITY_UNSPECIFIED\x10\x00\x12\f\n" +
	"\bCRITICAL\x10\x01\x12\t\n" +
	"\x05ERROR\x10\x02\x12\v\n" +
	"\aWARNING\x10\x03:\xc9\x01\xeaA\xc5\x01\n" +
	"%monitoring.googleapis.com/AlertPolicy\x12/projects/{project}/alertPolicies/{alert_policy}\x129organizations/{organization}/alertPolicies/{alert_policy}\x12-folders/{folder}/alertPolicies/{alert_policy}\x12\x01*B\xc5\x01\n" +
	"\x18com.google.monitoring.v3B\n" +
	"AlertProtoP\x01ZAcloud.google.com/go/monitoring/apiv3/v2/monitoringpb;monitoringpb\xaa\x02\x1aGoogle.Cloud.Monitoring.V3\xca\x02\x1aGoogle\\Cloud\\Monitoring\\V3\xea\x02\x1dGoogle::Cloud::Monitoring::V3b\x06proto3"

var (
	file_google_monitoring_v3_alert_proto_rawDescOnce sync.Once
	file_google_monitoring_v3_alert_proto_rawDescData []byte
)

func file_google_monitoring_v3_alert_proto_rawDescGZIP() []byte {
	file_google_monitoring_v3_alert_proto_rawDescOnce.Do(func() {
		file_google_monitoring_v3_alert_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_google_monitoring_v3_alert_proto_rawDesc), len(file_google_monitoring_v3_alert_proto_rawDesc)))
	})
	return file_google_monitoring_v3_alert_proto_rawDescData
}

var file_google_monitoring_v3_alert_proto_enumTypes = make([]protoimpl.EnumInfo, 4)
var file_google_monitoring_v3_alert_proto_msgTypes = make([]protoimpl.MessageInfo, 23)
var file_google_monitoring_v3_alert_proto_goTypes = []any{
	(AlertPolicy_ConditionCombinerType)(0),                         // 0: google.monitoring.v3.AlertPolicy.ConditionCombinerType
	(AlertPolicy_Severity)(0),                                      // 1: google.monitoring.v3.AlertPolicy.Severity
	(AlertPolicy_Condition_EvaluationMissingData)(0),               // 2: google.monitoring.v3.AlertPolicy.Condition.EvaluationMissingData
	(AlertPolicy_AlertStrategy_NotificationPrompt)(0),              // 3: google.monitoring.v3.AlertPolicy.AlertStrategy.NotificationPrompt
	(*AlertPolicy)(nil),                                            // 4: google.monitoring.v3.AlertPolicy
	(*AlertPolicy_Documentation)(nil),                              // 5: google.monitoring.v3.AlertPolicy.Documentation
	(*AlertPolicy_Condition)(nil),                                  // 6: google.monitoring.v3.AlertPolicy.Condition
	(*AlertPolicy_AlertStrategy)(nil),                              // 7: google.monitoring.v3.AlertPolicy.AlertStrategy
	nil,                                                            // 8: google.monitoring.v3.AlertPolicy.UserLabelsEntry
	(*AlertPolicy_Documentation_Link)(nil),                         // 9: google.monitoring.v3.AlertPolicy.Documentation.Link
	(*AlertPolicy_Condition_Trigger)(nil),                          // 10: google.monitoring.v3.AlertPolicy.Condition.Trigger
	(*AlertPolicy_Condition_MetricThreshold)(nil),                  // 11: google.monitoring.v3.AlertPolicy.Condition.MetricThreshold
	(*AlertPolicy_Condition_MetricAbsence)(nil),                    // 12: google.monitoring.v3.AlertPolicy.Condition.MetricAbsence
	(*AlertPolicy_Condition_LogMatch)(nil),                         // 13: google.monitoring.v3.AlertPolicy.Condition.LogMatch
	(*AlertPolicy_Condition_MonitoringQueryLanguageCondition)(nil), // 14: google.monitoring.v3.AlertPolicy.Condition.MonitoringQueryLanguageCondition
	(*AlertPolicy_Condition_PrometheusQueryLanguageCondition)(nil), // 15: google.monitoring.v3.AlertPolicy.Condition.PrometheusQueryLanguageCondition
	(*AlertPolicy_Condition_SqlCondition)(nil),                     // 16: google.monitoring.v3.AlertPolicy.Condition.SqlCondition
	(*AlertPolicy_Condition_MetricThreshold_ForecastOptions)(nil),  // 17: google.monitoring.v3.AlertPolicy.Condition.MetricThreshold.ForecastOptions
	nil, // 18: google.monitoring.v3.AlertPolicy.Condition.LogMatch.LabelExtractorsEntry
	nil, // 19: google.monitoring.v3.AlertPolicy.Condition.PrometheusQueryLanguageCondition.LabelsEntry
	(*AlertPolicy_Condition_SqlCondition_Minutes)(nil),            // 20: google.monitoring.v3.AlertPolicy.Condition.SqlCondition.Minutes
	(*AlertPolicy_Condition_SqlCondition_Hourly)(nil),             // 21: google.monitoring.v3.AlertPolicy.Condition.SqlCondition.Hourly
	(*AlertPolicy_Condition_SqlCondition_Daily)(nil),              // 22: google.monitoring.v3.AlertPolicy.Condition.SqlCondition.Daily
	(*AlertPolicy_Condition_SqlCondition_RowCountTest)(nil),       // 23: google.monitoring.v3.AlertPolicy.Condition.SqlCondition.RowCountTest
	(*AlertPolicy_Condition_SqlCondition_BooleanTest)(nil),        // 24: google.monitoring.v3.AlertPolicy.Condition.SqlCondition.BooleanTest
	(*AlertPolicy_AlertStrategy_NotificationRateLimit)(nil),       // 25: google.monitoring.v3.AlertPolicy.AlertStrategy.NotificationRateLimit
	(*AlertPolicy_AlertStrategy_NotificationChannelStrategy)(nil), // 26: google.monitoring.v3.AlertPolicy.AlertStrategy.NotificationChannelStrategy
	(*wrapperspb.BoolValue)(nil),                                  // 27: google.protobuf.BoolValue
	(*status.Status)(nil),                                         // 28: google.rpc.Status
	(*MutationRecord)(nil),                                        // 29: google.monitoring.v3.MutationRecord
	(*durationpb.Duration)(nil),                                   // 30: google.protobuf.Duration
	(*Aggregation)(nil),                                           // 31: google.monitoring.v3.Aggregation
	(ComparisonType)(0),                                           // 32: google.monitoring.v3.ComparisonType
	(*timeofday.TimeOfDay)(nil),                                   // 33: google.type.TimeOfDay
}
var file_google_monitoring_v3_alert_proto_depIdxs = []int32{
	5,  // 0: google.monitoring.v3.AlertPolicy.documentation:type_name -> google.monitoring.v3.AlertPolicy.Documentation
	8,  // 1: google.monitoring.v3.AlertPolicy.user_labels:type_name -> google.monitoring.v3.AlertPolicy.UserLabelsEntry
	6,  // 2: google.monitoring.v3.AlertPolicy.conditions:type_name -> google.monitoring.v3.AlertPolicy.Condition
	0,  // 3: google.monitoring.v3.AlertPolicy.combiner:type_name -> google.monitoring.v3.AlertPolicy.ConditionCombinerType
	27, // 4: google.monitoring.v3.AlertPolicy.enabled:type_name -> google.protobuf.BoolValue
	28, // 5: google.monitoring.v3.AlertPolicy.validity:type_name -> google.rpc.Status
	29, // 6: google.monitoring.v3.AlertPolicy.creation_record:type_name -> google.monitoring.v3.MutationRecord
	29, // 7: google.monitoring.v3.AlertPolicy.mutation_record:type_name -> google.monitoring.v3.MutationRecord
	7,  // 8: google.monitoring.v3.AlertPolicy.alert_strategy:type_name -> google.monitoring.v3.AlertPolicy.AlertStrategy
	1,  // 9: google.monitoring.v3.AlertPolicy.severity:type_name -> google.monitoring.v3.AlertPolicy.Severity
	9,  // 10: google.monitoring.v3.AlertPolicy.Documentation.links:type_name -> google.monitoring.v3.AlertPolicy.Documentation.Link
	11, // 11: google.monitoring.v3.AlertPolicy.Condition.condition_threshold:type_name -> google.monitoring.v3.AlertPolicy.Condition.MetricThreshold
	12, // 12: google.monitoring.v3.AlertPolicy.Condition.condition_absent:type_name -> google.monitoring.v3.AlertPolicy.Condition.MetricAbsence
	13, // 13: google.monitoring.v3.AlertPolicy.Condition.condition_matched_log:type_name -> google.monitoring.v3.AlertPolicy.Condition.LogMatch
	14, // 14: google.monitoring.v3.AlertPolicy.Condition.condition_monitoring_query_language:type_name -> google.monitoring.v3.AlertPolicy.Condition.MonitoringQueryLanguageCondition
	15, // 15: google.monitoring.v3.AlertPolicy.Condition.condition_prometheus_query_language:type_name -> google.monitoring.v3.AlertPolicy.Condition.PrometheusQueryLanguageCondition
	16, // 16: google.monitoring.v3.AlertPolicy.Condition.condition_sql:type_name -> google.monitoring.v3.AlertPolicy.Condition.SqlCondition
	25, // 17: google.monitoring.v3.AlertPolicy.AlertStrategy.notification_rate_limit:type_name -> google.monitoring.v3.AlertPolicy.AlertStrategy.NotificationRateLimit
	3,  // 18: google.monitoring.v3.AlertPolicy.AlertStrategy.notification_prompts:type_name -> google.monitoring.v3.AlertPolicy.AlertStrategy.NotificationPrompt
	30, // 19: google.monitoring.v3.AlertPolicy.AlertStrategy.auto_close:type_name -> google.protobuf.Duration
	26, // 20: google.monitoring.v3.AlertPolicy.AlertStrategy.notification_channel_strategy:type_name -> google.monitoring.v3.AlertPolicy.AlertStrategy.NotificationChannelStrategy
	31, // 21: google.monitoring.v3.AlertPolicy.Condition.MetricThreshold.aggregations:type_name -> google.monitoring.v3.Aggregation
	31, // 22: google.monitoring.v3.AlertPolicy.Condition.MetricThreshold.denominator_aggregations:type_name -> google.monitoring.v3.Aggregation
	17, // 23: google.monitoring.v3.AlertPolicy.Condition.MetricThreshold.forecast_options:type_name -> google.monitoring.v3.AlertPolicy.Condition.MetricThreshold.ForecastOptions
	32, // 24: google.monitoring.v3.AlertPolicy.Condition.MetricThreshold.comparison:type_name -> google.monitoring.v3.ComparisonType
	30, // 25: google.monitoring.v3.AlertPolicy.Condition.MetricThreshold.duration:type_name -> google.protobuf.Duration
	10, // 26: google.monitoring.v3.AlertPolicy.Condition.MetricThreshold.trigger:type_name -> google.monitoring.v3.AlertPolicy.Condition.Trigger
	2,  // 27: google.monitoring.v3.AlertPolicy.Condition.MetricThreshold.evaluation_missing_data:type_name -> google.monitoring.v3.AlertPolicy.Condition.EvaluationMissingData
	31, // 28: google.monitoring.v3.AlertPolicy.Condition.MetricAbsence.aggregations:type_name -> google.monitoring.v3.Aggregation
	30, // 29: google.monitoring.v3.AlertPolicy.Condition.MetricAbsence.duration:type_name -> google.protobuf.Duration
	10, // 30: google.monitoring.v3.AlertPolicy.Condition.MetricAbsence.trigger:type_name -> google.monitoring.v3.AlertPolicy.Condition.Trigger
	18, // 31: google.monitoring.v3.AlertPolicy.Condition.LogMatch.label_extractors:type_name -> google.monitoring.v3.AlertPolicy.Condition.LogMatch.LabelExtractorsEntry
	30, // 32: google.monitoring.v3.AlertPolicy.Condition.MonitoringQueryLanguageCondition.duration:type_name -> google.protobuf.Duration
	10, // 33: google.monitoring.v3.AlertPolicy.Condition.MonitoringQueryLanguageCondition.trigger:type_name -> google.monitoring.v3.AlertPolicy.Condition.Trigger
	2,  // 34: google.monitoring.v3.AlertPolicy.Condition.MonitoringQueryLanguageCondition.evaluation_missing_data:type_name -> google.monitoring.v3.AlertPolicy.Condition.EvaluationMissingData
	30, // 35: google.monitoring.v3.AlertPolicy.Condition.PrometheusQueryLanguageCondition.duration:type_name -> google.protobuf.Duration
	30, // 36: google.monitoring.v3.AlertPolicy.Condition.PrometheusQueryLanguageCondition.evaluation_interval:type_name -> google.protobuf.Duration
	19, // 37: google.monitoring.v3.AlertPolicy.Condition.PrometheusQueryLanguageCondition.labels:type_name -> google.monitoring.v3.AlertPolicy.Condition.PrometheusQueryLanguageCondition.LabelsEntry
	20, // 38: google.monitoring.v3.AlertPolicy.Condition.SqlCondition.minutes:type_name -> google.monitoring.v3.AlertPolicy.Condition.SqlCondition.Minutes
	21, // 39: google.monitoring.v3.AlertPolicy.Condition.SqlCondition.hourly:type_name -> google.monitoring.v3.AlertPolicy.Condition.SqlCondition.Hourly
	22, // 40: google.monitoring.v3.AlertPolicy.Condition.SqlCondition.daily:type_name -> google.monitoring.v3.AlertPolicy.Condition.SqlCondition.Daily
	23, // 41: google.monitoring.v3.AlertPolicy.Condition.SqlCondition.row_count_test:type_name -> google.monitoring.v3.AlertPolicy.Condition.SqlCondition.RowCountTest
	24, // 42: google.monitoring.v3.AlertPolicy.Condition.SqlCondition.boolean_test:type_name -> google.monitoring.v3.AlertPolicy.Condition.SqlCondition.BooleanTest
	30, // 43: google.monitoring.v3.AlertPolicy.Condition.MetricThreshold.ForecastOptions.forecast_horizon:type_name -> google.protobuf.Duration
	33, // 44: google.monitoring.v3.AlertPolicy.Condition.SqlCondition.Daily.execution_time:type_name -> google.type.TimeOfDay
	32, // 45: google.monitoring.v3.AlertPolicy.Condition.SqlCondition.RowCountTest.comparison:type_name -> google.monitoring.v3.ComparisonType
	30, // 46: google.monitoring.v3.AlertPolicy.AlertStrategy.NotificationRateLimit.period:type_name -> google.protobuf.Duration
	30, // 47: google.monitoring.v3.AlertPolicy.AlertStrategy.NotificationChannelStrategy.renotify_interval:type_name -> google.protobuf.Duration
	48, // [48:48] is the sub-list for method output_type
	48, // [48:48] is the sub-list for method input_type
	48, // [48:48] is the sub-list for extension type_name
	48, // [48:48] is the sub-list for extension extendee
	0,  // [0:48] is the sub-list for field type_name
}

func init() { file_google_monitoring_v3_alert_proto_init() }
func file_google_monitoring_v3_alert_proto_init() {
	if File_google_monitoring_v3_alert_proto != nil {
		return
	}
	file_google_monitoring_v3_common_proto_init()
	file_google_monitoring_v3_mutation_record_proto_init()
	file_google_monitoring_v3_alert_proto_msgTypes[2].OneofWrappers = []any{
		(*AlertPolicy_Condition_ConditionThreshold)(nil),
		(*AlertPolicy_Condition_ConditionAbsent)(nil),
		(*AlertPolicy_Condition_ConditionMatchedLog)(nil),
		(*AlertPolicy_Condition_ConditionMonitoringQueryLanguage)(nil),
		(*AlertPolicy_Condition_ConditionPrometheusQueryLanguage)(nil),
		(*AlertPolicy_Condition_ConditionSql)(nil),
	}
	file_google_monitoring_v3_alert_proto_msgTypes[6].OneofWrappers = []any{
		(*AlertPolicy_Condition_Trigger_Count)(nil),
		(*AlertPolicy_Condition_Trigger_Percent)(nil),
	}
	file_google_monitoring_v3_alert_proto_msgTypes[12].OneofWrappers = []any{
		(*AlertPolicy_Condition_SqlCondition_Minutes_)(nil),
		(*AlertPolicy_Condition_SqlCondition_Hourly_)(nil),
		(*AlertPolicy_Condition_SqlCondition_Daily_)(nil),
		(*AlertPolicy_Condition_SqlCondition_RowCountTest_)(nil),
		(*AlertPolicy_Condition_SqlCondition_BooleanTest_)(nil),
	}
	file_google_monitoring_v3_alert_proto_msgTypes[17].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_google_monitoring_v3_alert_proto_rawDesc), len(file_google_monitoring_v3_alert_proto_rawDesc)),
			NumEnums:      4,
			NumMessages:   23,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_google_monitoring_v3_alert_proto_goTypes,
		DependencyIndexes: file_google_monitoring_v3_alert_proto_depIdxs,
		EnumInfos:         file_google_monitoring_v3_alert_proto_enumTypes,
		MessageInfos:      file_google_monitoring_v3_alert_proto_msgTypes,
	}.Build()
	File_google_monitoring_v3_alert_proto = out.File
	file_google_monitoring_v3_alert_proto_goTypes = nil
	file_google_monitoring_v3_alert_proto_depIdxs = nil
}
