// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.6
// 	protoc        v6.30.2
// source: proto/metrics.proto

package metrics

import (
	protoreflect "google.golang.org/protobuf/reflect/protoreflect"
	protoimpl "google.golang.org/protobuf/runtime/protoimpl"
	reflect "reflect"
	sync "sync"
	unsafe "unsafe"
)

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)
)

type MetricType_Type int32

const (
	MetricType_TYPE_UNSPECIFIED MetricType_Type = 0
	// COUNTER represents a monotonically increasing value
	MetricType_TYPE_COUNTER MetricType_Type = 1
	// GAUGE represents a value that can go up and down
	MetricType_TYPE_GAUGE MetricType_Type = 2
	// UNTYPED represents an untyped metric
	MetricType_TYPE_UNTYPED MetricType_Type = 3
)

// Enum value maps for MetricType_Type.
var (
	MetricType_Type_name = map[int32]string{
		0: "TYPE_UNSPECIFIED",
		1: "TYPE_COUNTER",
		2: "TYPE_GAUGE",
		3: "TYPE_UNTYPED",
	}
	MetricType_Type_value = map[string]int32{
		"TYPE_UNSPECIFIED": 0,
		"TYPE_COUNTER":     1,
		"TYPE_GAUGE":       2,
		"TYPE_UNTYPED":     3,
	}
)

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

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

func (MetricType_Type) Descriptor() protoreflect.EnumDescriptor {
	return file_proto_metrics_proto_enumTypes[0].Descriptor()
}

func (MetricType_Type) Type() protoreflect.EnumType {
	return &file_proto_metrics_proto_enumTypes[0]
}

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

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

type MetricsCapability_RPC_Type int32

const (
	MetricsCapability_RPC_TYPE_UNSPECIFIED MetricsCapability_RPC_Type = 0
	// TYPE_METRICS indicates that the Plugin is able to
	// collect metrics. This feature is required for every
	// plugin exposing the Metrics service
	MetricsCapability_RPC_TYPE_METRICS MetricsCapability_RPC_Type = 1
)

// Enum value maps for MetricsCapability_RPC_Type.
var (
	MetricsCapability_RPC_Type_name = map[int32]string{
		0: "TYPE_UNSPECIFIED",
		1: "TYPE_METRICS",
	}
	MetricsCapability_RPC_Type_value = map[string]int32{
		"TYPE_UNSPECIFIED": 0,
		"TYPE_METRICS":     1,
	}
)

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

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

func (MetricsCapability_RPC_Type) Descriptor() protoreflect.EnumDescriptor {
	return file_proto_metrics_proto_enumTypes[1].Descriptor()
}

func (MetricsCapability_RPC_Type) Type() protoreflect.EnumType {
	return &file_proto_metrics_proto_enumTypes[1]
}

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

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

type CollectMetricsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// This field is REQUIRED and contains the JSON serialization of the
	// Cluster being monitored
	ClusterDefinition []byte `protobuf:"bytes,1,opt,name=cluster_definition,json=clusterDefinition,proto3" json:"cluster_definition,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

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

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

func (*CollectMetricsRequest) ProtoMessage() {}

func (x *CollectMetricsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_proto_metrics_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 CollectMetricsRequest.ProtoReflect.Descriptor instead.
func (*CollectMetricsRequest) Descriptor() ([]byte, []int) {
	return file_proto_metrics_proto_rawDescGZIP(), []int{0}
}

func (x *CollectMetricsRequest) GetClusterDefinition() []byte {
	if x != nil {
		return x.ClusterDefinition
	}
	return nil
}

type CollectMetric struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// value is the metric value
	Value float64 `protobuf:"fixed64,1,opt,name=value,proto3" json:"value,omitempty"`
	// fq_name is the fully qualified name of the metric
	FqName string `protobuf:"bytes,2,opt,name=fq_name,json=fqName,proto3" json:"fq_name,omitempty"`
	// variable_labels are the values for the variable labels of this metric
	VariableLabels []string `protobuf:"bytes,3,rep,name=variable_labels,json=variableLabels,proto3" json:"variable_labels,omitempty"`
	unknownFields  protoimpl.UnknownFields
	sizeCache      protoimpl.SizeCache
}

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

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

func (*CollectMetric) ProtoMessage() {}

func (x *CollectMetric) ProtoReflect() protoreflect.Message {
	mi := &file_proto_metrics_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 CollectMetric.ProtoReflect.Descriptor instead.
func (*CollectMetric) Descriptor() ([]byte, []int) {
	return file_proto_metrics_proto_rawDescGZIP(), []int{1}
}

func (x *CollectMetric) GetValue() float64 {
	if x != nil {
		return x.Value
	}
	return 0
}

func (x *CollectMetric) GetFqName() string {
	if x != nil {
		return x.FqName
	}
	return ""
}

func (x *CollectMetric) GetVariableLabels() []string {
	if x != nil {
		return x.VariableLabels
	}
	return nil
}

type CollectMetricsResult struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// This field is REQUIRED and contains the JSON serialization of the
	// collected metrics
	Metrics       []*CollectMetric `protobuf:"bytes,1,rep,name=metrics,proto3" json:"metrics,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*CollectMetricsResult) ProtoMessage() {}

func (x *CollectMetricsResult) ProtoReflect() protoreflect.Message {
	mi := &file_proto_metrics_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 CollectMetricsResult.ProtoReflect.Descriptor instead.
func (*CollectMetricsResult) Descriptor() ([]byte, []int) {
	return file_proto_metrics_proto_rawDescGZIP(), []int{2}
}

func (x *CollectMetricsResult) GetMetrics() []*CollectMetric {
	if x != nil {
		return x.Metrics
	}
	return nil
}

type DefineMetricsRequest struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// This field is REQUIRED and contains the JSON serialization of the
	// Cluster being monitored
	ClusterDefinition []byte `protobuf:"bytes,1,opt,name=cluster_definition,json=clusterDefinition,proto3" json:"cluster_definition,omitempty"`
	unknownFields     protoimpl.UnknownFields
	sizeCache         protoimpl.SizeCache
}

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

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

func (*DefineMetricsRequest) ProtoMessage() {}

func (x *DefineMetricsRequest) ProtoReflect() protoreflect.Message {
	mi := &file_proto_metrics_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 DefineMetricsRequest.ProtoReflect.Descriptor instead.
func (*DefineMetricsRequest) Descriptor() ([]byte, []int) {
	return file_proto_metrics_proto_rawDescGZIP(), []int{3}
}

func (x *DefineMetricsRequest) GetClusterDefinition() []byte {
	if x != nil {
		return x.ClusterDefinition
	}
	return nil
}

type DefineMetricsResult struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// This field is REQUIRED and contains the JSON serialization of the
	// defined metrics
	Metrics       []*Metric `protobuf:"bytes,1,rep,name=metrics,proto3" json:"metrics,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

func (x *DefineMetricsResult) Reset() {
	*x = DefineMetricsResult{}
	mi := &file_proto_metrics_proto_msgTypes[4]
	ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
	ms.StoreMessageInfo(mi)
}

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

func (*DefineMetricsResult) ProtoMessage() {}

func (x *DefineMetricsResult) ProtoReflect() protoreflect.Message {
	mi := &file_proto_metrics_proto_msgTypes[4]
	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 DefineMetricsResult.ProtoReflect.Descriptor instead.
func (*DefineMetricsResult) Descriptor() ([]byte, []int) {
	return file_proto_metrics_proto_rawDescGZIP(), []int{4}
}

func (x *DefineMetricsResult) GetMetrics() []*Metric {
	if x != nil {
		return x.Metrics
	}
	return nil
}

type MetricType struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Type          MetricType_Type        `protobuf:"varint,1,opt,name=type,proto3,enum=cnpgi.metrics.v1.MetricType_Type" json:"type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MetricType) ProtoMessage() {}

func (x *MetricType) ProtoReflect() protoreflect.Message {
	mi := &file_proto_metrics_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 MetricType.ProtoReflect.Descriptor instead.
func (*MetricType) Descriptor() ([]byte, []int) {
	return file_proto_metrics_proto_rawDescGZIP(), []int{5}
}

func (x *MetricType) GetType() MetricType_Type {
	if x != nil {
		return x.Type
	}
	return MetricType_TYPE_UNSPECIFIED
}

type Metric struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// fqName is the fully qualified name of the metric
	FqName string `protobuf:"bytes,1,opt,name=fq_name,json=fqName,proto3" json:"fq_name,omitempty"`
	// help provides a human-readable description of the metric
	Help string `protobuf:"bytes,2,opt,name=help,proto3" json:"help,omitempty"`
	// variable_labels are the label names that can vary for this metric
	VariableLabels []string `protobuf:"bytes,3,rep,name=variable_labels,json=variableLabels,proto3" json:"variable_labels,omitempty"`
	// const_labels are the constant labels applied to this metric
	ConstLabels map[string]string `protobuf:"bytes,4,rep,name=const_labels,json=constLabels,proto3" json:"const_labels,omitempty" protobuf_key:"bytes,1,opt,name=key" protobuf_val:"bytes,2,opt,name=value"`
	// value_type indicates the Prometheus value type for this metric
	ValueType     *MetricType `protobuf:"bytes,5,opt,name=value_type,json=valueType,proto3" json:"value_type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Metric) ProtoMessage() {}

func (x *Metric) ProtoReflect() protoreflect.Message {
	mi := &file_proto_metrics_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 Metric.ProtoReflect.Descriptor instead.
func (*Metric) Descriptor() ([]byte, []int) {
	return file_proto_metrics_proto_rawDescGZIP(), []int{6}
}

func (x *Metric) GetFqName() string {
	if x != nil {
		return x.FqName
	}
	return ""
}

func (x *Metric) GetHelp() string {
	if x != nil {
		return x.Help
	}
	return ""
}

func (x *Metric) GetVariableLabels() []string {
	if x != nil {
		return x.VariableLabels
	}
	return nil
}

func (x *Metric) GetConstLabels() map[string]string {
	if x != nil {
		return x.ConstLabels
	}
	return nil
}

func (x *Metric) GetValueType() *MetricType {
	if x != nil {
		return x.ValueType
	}
	return nil
}

type MetricsCapabilitiesRequest struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MetricsCapabilitiesRequest) ProtoMessage() {}

func (x *MetricsCapabilitiesRequest) ProtoReflect() protoreflect.Message {
	mi := &file_proto_metrics_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 MetricsCapabilitiesRequest.ProtoReflect.Descriptor instead.
func (*MetricsCapabilitiesRequest) Descriptor() ([]byte, []int) {
	return file_proto_metrics_proto_rawDescGZIP(), []int{7}
}

type MetricsCapabilitiesResult struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// All the capabilities that the controller service supports. This
	// field is OPTIONAL.
	Capabilities  []*MetricsCapability `protobuf:"bytes,1,rep,name=capabilities,proto3" json:"capabilities,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MetricsCapabilitiesResult) ProtoMessage() {}

func (x *MetricsCapabilitiesResult) ProtoReflect() protoreflect.Message {
	mi := &file_proto_metrics_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 MetricsCapabilitiesResult.ProtoReflect.Descriptor instead.
func (*MetricsCapabilitiesResult) Descriptor() ([]byte, []int) {
	return file_proto_metrics_proto_rawDescGZIP(), []int{8}
}

func (x *MetricsCapabilitiesResult) GetCapabilities() []*MetricsCapability {
	if x != nil {
		return x.Capabilities
	}
	return nil
}

type MetricsCapability struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Type:
	//
	//	*MetricsCapability_Rpc
	Type          isMetricsCapability_Type `protobuf_oneof:"type"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MetricsCapability) ProtoMessage() {}

func (x *MetricsCapability) ProtoReflect() protoreflect.Message {
	mi := &file_proto_metrics_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 MetricsCapability.ProtoReflect.Descriptor instead.
func (*MetricsCapability) Descriptor() ([]byte, []int) {
	return file_proto_metrics_proto_rawDescGZIP(), []int{9}
}

func (x *MetricsCapability) GetType() isMetricsCapability_Type {
	if x != nil {
		return x.Type
	}
	return nil
}

func (x *MetricsCapability) GetRpc() *MetricsCapability_RPC {
	if x != nil {
		if x, ok := x.Type.(*MetricsCapability_Rpc); ok {
			return x.Rpc
		}
	}
	return nil
}

type isMetricsCapability_Type interface {
	isMetricsCapability_Type()
}

type MetricsCapability_Rpc struct {
	Rpc *MetricsCapability_RPC `protobuf:"bytes,1,opt,name=rpc,proto3,oneof"`
}

func (*MetricsCapability_Rpc) isMetricsCapability_Type() {}

type MetricsCapability_RPC struct {
	state         protoimpl.MessageState     `protogen:"open.v1"`
	Type          MetricsCapability_RPC_Type `protobuf:"varint,1,opt,name=type,proto3,enum=cnpgi.metrics.v1.MetricsCapability_RPC_Type" json:"type,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*MetricsCapability_RPC) ProtoMessage() {}

func (x *MetricsCapability_RPC) ProtoReflect() protoreflect.Message {
	mi := &file_proto_metrics_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 MetricsCapability_RPC.ProtoReflect.Descriptor instead.
func (*MetricsCapability_RPC) Descriptor() ([]byte, []int) {
	return file_proto_metrics_proto_rawDescGZIP(), []int{9, 0}
}

func (x *MetricsCapability_RPC) GetType() MetricsCapability_RPC_Type {
	if x != nil {
		return x.Type
	}
	return MetricsCapability_RPC_TYPE_UNSPECIFIED
}

var File_proto_metrics_proto protoreflect.FileDescriptor

const file_proto_metrics_proto_rawDesc = "" +
	"\n" +
	"\x13proto/metrics.proto\x12\x10cnpgi.metrics.v1\"F\n" +
	"\x15CollectMetricsRequest\x12-\n" +
	"\x12cluster_definition\x18\x01 \x01(\fR\x11clusterDefinition\"g\n" +
	"\rCollectMetric\x12\x14\n" +
	"\x05value\x18\x01 \x01(\x01R\x05value\x12\x17\n" +
	"\afq_name\x18\x02 \x01(\tR\x06fqName\x12'\n" +
	"\x0fvariable_labels\x18\x03 \x03(\tR\x0evariableLabels\"Q\n" +
	"\x14CollectMetricsResult\x129\n" +
	"\ametrics\x18\x01 \x03(\v2\x1f.cnpgi.metrics.v1.CollectMetricR\ametrics\"E\n" +
	"\x14DefineMetricsRequest\x12-\n" +
	"\x12cluster_definition\x18\x01 \x01(\fR\x11clusterDefinition\"I\n" +
	"\x13DefineMetricsResult\x122\n" +
	"\ametrics\x18\x01 \x03(\v2\x18.cnpgi.metrics.v1.MetricR\ametrics\"\x95\x01\n" +
	"\n" +
	"MetricType\x125\n" +
	"\x04type\x18\x01 \x01(\x0e2!.cnpgi.metrics.v1.MetricType.TypeR\x04type\"P\n" +
	"\x04Type\x12\x14\n" +
	"\x10TYPE_UNSPECIFIED\x10\x00\x12\x10\n" +
	"\fTYPE_COUNTER\x10\x01\x12\x0e\n" +
	"\n" +
	"TYPE_GAUGE\x10\x02\x12\x10\n" +
	"\fTYPE_UNTYPED\x10\x03\"\xa9\x02\n" +
	"\x06Metric\x12\x17\n" +
	"\afq_name\x18\x01 \x01(\tR\x06fqName\x12\x12\n" +
	"\x04help\x18\x02 \x01(\tR\x04help\x12'\n" +
	"\x0fvariable_labels\x18\x03 \x03(\tR\x0evariableLabels\x12L\n" +
	"\fconst_labels\x18\x04 \x03(\v2).cnpgi.metrics.v1.Metric.ConstLabelsEntryR\vconstLabels\x12;\n" +
	"\n" +
	"value_type\x18\x05 \x01(\v2\x1c.cnpgi.metrics.v1.MetricTypeR\tvalueType\x1a>\n" +
	"\x10ConstLabelsEntry\x12\x10\n" +
	"\x03key\x18\x01 \x01(\tR\x03key\x12\x14\n" +
	"\x05value\x18\x02 \x01(\tR\x05value:\x028\x01\"\x1c\n" +
	"\x1aMetricsCapabilitiesRequest\"d\n" +
	"\x19MetricsCapabilitiesResult\x12G\n" +
	"\fcapabilities\x18\x01 \x03(\v2#.cnpgi.metrics.v1.MetricsCapabilityR\fcapabilities\"\xd1\x01\n" +
	"\x11MetricsCapability\x12;\n" +
	"\x03rpc\x18\x01 \x01(\v2'.cnpgi.metrics.v1.MetricsCapability.RPCH\x00R\x03rpc\x1aw\n" +
	"\x03RPC\x12@\n" +
	"\x04type\x18\x01 \x01(\x0e2,.cnpgi.metrics.v1.MetricsCapability.RPC.TypeR\x04type\".\n" +
	"\x04Type\x12\x14\n" +
	"\x10TYPE_UNSPECIFIED\x10\x00\x12\x10\n" +
	"\fTYPE_METRICS\x10\x01B\x06\n" +
	"\x04type2\xb2\x02\n" +
	"\aMetrics\x12n\n" +
	"\x0fGetCapabilities\x12,.cnpgi.metrics.v1.MetricsCapabilitiesRequest\x1a+.cnpgi.metrics.v1.MetricsCapabilitiesResult\"\x00\x12Y\n" +
	"\x06Define\x12&.cnpgi.metrics.v1.DefineMetricsRequest\x1a%.cnpgi.metrics.v1.DefineMetricsResult\"\x00\x12\\\n" +
	"\aCollect\x12'.cnpgi.metrics.v1.CollectMetricsRequest\x1a&.cnpgi.metrics.v1.CollectMetricsResult\"\x00B.Z,github.com/cloudnative-pg/cnpg-i/pkg/metricsb\x06proto3"

var (
	file_proto_metrics_proto_rawDescOnce sync.Once
	file_proto_metrics_proto_rawDescData []byte
)

func file_proto_metrics_proto_rawDescGZIP() []byte {
	file_proto_metrics_proto_rawDescOnce.Do(func() {
		file_proto_metrics_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_proto_metrics_proto_rawDesc), len(file_proto_metrics_proto_rawDesc)))
	})
	return file_proto_metrics_proto_rawDescData
}

var file_proto_metrics_proto_enumTypes = make([]protoimpl.EnumInfo, 2)
var file_proto_metrics_proto_msgTypes = make([]protoimpl.MessageInfo, 12)
var file_proto_metrics_proto_goTypes = []any{
	(MetricType_Type)(0),               // 0: cnpgi.metrics.v1.MetricType.Type
	(MetricsCapability_RPC_Type)(0),    // 1: cnpgi.metrics.v1.MetricsCapability.RPC.Type
	(*CollectMetricsRequest)(nil),      // 2: cnpgi.metrics.v1.CollectMetricsRequest
	(*CollectMetric)(nil),              // 3: cnpgi.metrics.v1.CollectMetric
	(*CollectMetricsResult)(nil),       // 4: cnpgi.metrics.v1.CollectMetricsResult
	(*DefineMetricsRequest)(nil),       // 5: cnpgi.metrics.v1.DefineMetricsRequest
	(*DefineMetricsResult)(nil),        // 6: cnpgi.metrics.v1.DefineMetricsResult
	(*MetricType)(nil),                 // 7: cnpgi.metrics.v1.MetricType
	(*Metric)(nil),                     // 8: cnpgi.metrics.v1.Metric
	(*MetricsCapabilitiesRequest)(nil), // 9: cnpgi.metrics.v1.MetricsCapabilitiesRequest
	(*MetricsCapabilitiesResult)(nil),  // 10: cnpgi.metrics.v1.MetricsCapabilitiesResult
	(*MetricsCapability)(nil),          // 11: cnpgi.metrics.v1.MetricsCapability
	nil,                                // 12: cnpgi.metrics.v1.Metric.ConstLabelsEntry
	(*MetricsCapability_RPC)(nil),      // 13: cnpgi.metrics.v1.MetricsCapability.RPC
}
var file_proto_metrics_proto_depIdxs = []int32{
	3,  // 0: cnpgi.metrics.v1.CollectMetricsResult.metrics:type_name -> cnpgi.metrics.v1.CollectMetric
	8,  // 1: cnpgi.metrics.v1.DefineMetricsResult.metrics:type_name -> cnpgi.metrics.v1.Metric
	0,  // 2: cnpgi.metrics.v1.MetricType.type:type_name -> cnpgi.metrics.v1.MetricType.Type
	12, // 3: cnpgi.metrics.v1.Metric.const_labels:type_name -> cnpgi.metrics.v1.Metric.ConstLabelsEntry
	7,  // 4: cnpgi.metrics.v1.Metric.value_type:type_name -> cnpgi.metrics.v1.MetricType
	11, // 5: cnpgi.metrics.v1.MetricsCapabilitiesResult.capabilities:type_name -> cnpgi.metrics.v1.MetricsCapability
	13, // 6: cnpgi.metrics.v1.MetricsCapability.rpc:type_name -> cnpgi.metrics.v1.MetricsCapability.RPC
	1,  // 7: cnpgi.metrics.v1.MetricsCapability.RPC.type:type_name -> cnpgi.metrics.v1.MetricsCapability.RPC.Type
	9,  // 8: cnpgi.metrics.v1.Metrics.GetCapabilities:input_type -> cnpgi.metrics.v1.MetricsCapabilitiesRequest
	5,  // 9: cnpgi.metrics.v1.Metrics.Define:input_type -> cnpgi.metrics.v1.DefineMetricsRequest
	2,  // 10: cnpgi.metrics.v1.Metrics.Collect:input_type -> cnpgi.metrics.v1.CollectMetricsRequest
	10, // 11: cnpgi.metrics.v1.Metrics.GetCapabilities:output_type -> cnpgi.metrics.v1.MetricsCapabilitiesResult
	6,  // 12: cnpgi.metrics.v1.Metrics.Define:output_type -> cnpgi.metrics.v1.DefineMetricsResult
	4,  // 13: cnpgi.metrics.v1.Metrics.Collect:output_type -> cnpgi.metrics.v1.CollectMetricsResult
	11, // [11:14] is the sub-list for method output_type
	8,  // [8:11] is the sub-list for method input_type
	8,  // [8:8] is the sub-list for extension type_name
	8,  // [8:8] is the sub-list for extension extendee
	0,  // [0:8] is the sub-list for field type_name
}

func init() { file_proto_metrics_proto_init() }
func file_proto_metrics_proto_init() {
	if File_proto_metrics_proto != nil {
		return
	}
	file_proto_metrics_proto_msgTypes[9].OneofWrappers = []any{
		(*MetricsCapability_Rpc)(nil),
	}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_proto_metrics_proto_rawDesc), len(file_proto_metrics_proto_rawDesc)),
			NumEnums:      2,
			NumMessages:   12,
			NumExtensions: 0,
			NumServices:   1,
		},
		GoTypes:           file_proto_metrics_proto_goTypes,
		DependencyIndexes: file_proto_metrics_proto_depIdxs,
		EnumInfos:         file_proto_metrics_proto_enumTypes,
		MessageInfos:      file_proto_metrics_proto_msgTypes,
	}.Build()
	File_proto_metrics_proto = out.File
	file_proto_metrics_proto_goTypes = nil
	file_proto_metrics_proto_depIdxs = nil
}
