query.pb.go

// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// 	protoc-gen-go v1.36.11
// 	protoc        v5.29.3
// source: loop/chain-common/query.proto

package chaincommonpb

import (
	codec "github.com/smartcontractkit/chainlink-common/pkg/internal/codec"
	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 ComparisonOperator int32

const (
	ComparisonOperator_Eq  ComparisonOperator = 0
	ComparisonOperator_Neq ComparisonOperator = 1
	ComparisonOperator_Gt  ComparisonOperator = 2
	ComparisonOperator_Lt  ComparisonOperator = 3
	ComparisonOperator_Gte ComparisonOperator = 4
	ComparisonOperator_Lte ComparisonOperator = 5
)

// Enum value maps for ComparisonOperator.
var (
	ComparisonOperator_name = map[int32]string{
		0: "Eq",
		1: "Neq",
		2: "Gt",
		3: "Lt",
		4: "Gte",
		5: "Lte",
	}
	ComparisonOperator_value = map[string]int32{
		"Eq":  0,
		"Neq": 1,
		"Gt":  2,
		"Lt":  3,
		"Gte": 4,
		"Lte": 5,
	}
)

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

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

func (ComparisonOperator) Descriptor() protoreflect.EnumDescriptor {
	return file_loop_chain_common_query_proto_enumTypes[0].Descriptor()
}

func (ComparisonOperator) Type() protoreflect.EnumType {
	return &file_loop_chain_common_query_proto_enumTypes[0]
}

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

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

type BooleanOperator int32

const (
	BooleanOperator_AND BooleanOperator = 0
	BooleanOperator_OR  BooleanOperator = 1
)

// Enum value maps for BooleanOperator.
var (
	BooleanOperator_name = map[int32]string{
		0: "AND",
		1: "OR",
	}
	BooleanOperator_value = map[string]int32{
		"AND": 0,
		"OR":  1,
	}
)

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

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

func (BooleanOperator) Descriptor() protoreflect.EnumDescriptor {
	return file_loop_chain_common_query_proto_enumTypes[1].Descriptor()
}

func (BooleanOperator) Type() protoreflect.EnumType {
	return &file_loop_chain_common_query_proto_enumTypes[1]
}

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

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

type Confidence int32

const (
	Confidence_Unconfirmed Confidence = 0
	Confidence_Finalized   Confidence = 1
	Confidence_Safe        Confidence = 2
)

// Enum value maps for Confidence.
var (
	Confidence_name = map[int32]string{
		0: "Unconfirmed",
		1: "Finalized",
		2: "Safe",
	}
	Confidence_value = map[string]int32{
		"Unconfirmed": 0,
		"Finalized":   1,
		"Safe":        2,
	}
)

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

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

func (Confidence) Descriptor() protoreflect.EnumDescriptor {
	return file_loop_chain_common_query_proto_enumTypes[2].Descriptor()
}

func (Confidence) Type() protoreflect.EnumType {
	return &file_loop_chain_common_query_proto_enumTypes[2]
}

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

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

// CursorDirection defines the direction for cursor-based data fetching.
type CursorDirection int32

const (
	CursorDirection_Preceding CursorDirection = 0
	CursorDirection_Following CursorDirection = 1
)

// Enum value maps for CursorDirection.
var (
	CursorDirection_name = map[int32]string{
		0: "Preceding",
		1: "Following",
	}
	CursorDirection_value = map[string]int32{
		"Preceding": 0,
		"Following": 1,
	}
)

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

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

func (CursorDirection) Descriptor() protoreflect.EnumDescriptor {
	return file_loop_chain_common_query_proto_enumTypes[3].Descriptor()
}

func (CursorDirection) Type() protoreflect.EnumType {
	return &file_loop_chain_common_query_proto_enumTypes[3]
}

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

// Deprecated: Use CursorDirection.Descriptor instead.
func (CursorDirection) EnumDescriptor() ([]byte, []int) {
	return file_loop_chain_common_query_proto_rawDescGZIP(), []int{3}
}

type SortDirection int32

const (
	SortDirection_Asc  SortDirection = 0
	SortDirection_Desc SortDirection = 1
)

// Enum value maps for SortDirection.
var (
	SortDirection_name = map[int32]string{
		0: "Asc",
		1: "Desc",
	}
	SortDirection_value = map[string]int32{
		"Asc":  0,
		"Desc": 1,
	}
)

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

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

func (SortDirection) Descriptor() protoreflect.EnumDescriptor {
	return file_loop_chain_common_query_proto_enumTypes[4].Descriptor()
}

func (SortDirection) Type() protoreflect.EnumType {
	return &file_loop_chain_common_query_proto_enumTypes[4]
}

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

// Deprecated: Use SortDirection.Descriptor instead.
func (SortDirection) EnumDescriptor() ([]byte, []int) {
	return file_loop_chain_common_query_proto_rawDescGZIP(), []int{4}
}

type SortType int32

const (
	SortType_SortTimestamp SortType = 0
	SortType_SortBlock     SortType = 1
	SortType_SortSequence  SortType = 2
)

// Enum value maps for SortType.
var (
	SortType_name = map[int32]string{
		0: "SortTimestamp",
		1: "SortBlock",
		2: "SortSequence",
	}
	SortType_value = map[string]int32{
		"SortTimestamp": 0,
		"SortBlock":     1,
		"SortSequence":  2,
	}
)

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

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

func (SortType) Descriptor() protoreflect.EnumDescriptor {
	return file_loop_chain_common_query_proto_enumTypes[5].Descriptor()
}

func (SortType) Type() protoreflect.EnumType {
	return &file_loop_chain_common_query_proto_enumTypes[5]
}

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

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

// Expression encapsulates a single unit of filtering logic, which can be a common blockchain primitive or a composite of boolean expressions.
// This allows for both simple and more complex nested expressions.
type Expression struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Evaluator:
	//
	//	*Expression_Primitive
	//	*Expression_BooleanExpression
	Evaluator     isExpression_Evaluator `protobuf_oneof:"evaluator"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Expression) ProtoMessage() {}

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

func (x *Expression) GetEvaluator() isExpression_Evaluator {
	if x != nil {
		return x.Evaluator
	}
	return nil
}

func (x *Expression) GetPrimitive() *Primitive {
	if x != nil {
		if x, ok := x.Evaluator.(*Expression_Primitive); ok {
			return x.Primitive
		}
	}
	return nil
}

func (x *Expression) GetBooleanExpression() *BooleanExpression {
	if x != nil {
		if x, ok := x.Evaluator.(*Expression_BooleanExpression); ok {
			return x.BooleanExpression
		}
	}
	return nil
}

type isExpression_Evaluator interface {
	isExpression_Evaluator()
}

type Expression_Primitive struct {
	Primitive *Primitive `protobuf:"bytes,1,opt,name=primitive,proto3,oneof"`
}

type Expression_BooleanExpression struct {
	BooleanExpression *BooleanExpression `protobuf:"bytes,2,opt,name=boolean_expression,json=booleanExpression,proto3,oneof"`
}

func (*Expression_Primitive) isExpression_Evaluator() {}

func (*Expression_BooleanExpression) isExpression_Evaluator() {}

type BooleanExpression struct {
	state           protoimpl.MessageState `protogen:"open.v1"`
	BooleanOperator BooleanOperator        `protobuf:"varint,1,opt,name=boolean_operator,json=booleanOperator,proto3,enum=loop.chain.common.BooleanOperator" json:"boolean_operator,omitempty"`
	Expression      []*Expression          `protobuf:"bytes,2,rep,name=expression,proto3" json:"expression,omitempty"`
	unknownFields   protoimpl.UnknownFields
	sizeCache       protoimpl.SizeCache
}

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

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

func (*BooleanExpression) ProtoMessage() {}

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

func (x *BooleanExpression) GetBooleanOperator() BooleanOperator {
	if x != nil {
		return x.BooleanOperator
	}
	return BooleanOperator_AND
}

func (x *BooleanExpression) GetExpression() []*Expression {
	if x != nil {
		return x.Expression
	}
	return nil
}

type And struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Expr          []*Expression          `protobuf:"bytes,1,rep,name=expr,proto3" json:"expr,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*And) ProtoMessage() {}

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

func (x *And) GetExpr() []*Expression {
	if x != nil {
		return x.Expr
	}
	return nil
}

type Or struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Expr          []*Expression          `protobuf:"bytes,1,rep,name=expr,proto3" json:"expr,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Or) ProtoMessage() {}

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

func (x *Or) GetExpr() []*Expression {
	if x != nil {
		return x.Expr
	}
	return nil
}

type ValueComparator struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Value         *codec.VersionedBytes  `protobuf:"bytes,1,opt,name=value,proto3" json:"value,omitempty"`
	Operator      ComparisonOperator     `protobuf:"varint,2,opt,name=operator,proto3,enum=loop.chain.common.ComparisonOperator" json:"operator,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*ValueComparator) ProtoMessage() {}

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

func (x *ValueComparator) GetValue() *codec.VersionedBytes {
	if x != nil {
		return x.Value
	}
	return nil
}

func (x *ValueComparator) GetOperator() ComparisonOperator {
	if x != nil {
		return x.Operator
	}
	return ComparisonOperator_Eq
}

type Comparator struct {
	state            protoimpl.MessageState `protogen:"open.v1"`
	Name             string                 `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
	ValueComparators []*ValueComparator     `protobuf:"bytes,2,rep,name=value_comparators,json=valueComparators,proto3" json:"value_comparators,omitempty"`
	unknownFields    protoimpl.UnknownFields
	sizeCache        protoimpl.SizeCache
}

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

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

func (*Comparator) ProtoMessage() {}

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

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

func (x *Comparator) GetValueComparators() []*ValueComparator {
	if x != nil {
		return x.ValueComparators
	}
	return nil
}

type Block struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	BlockNumber   string                 `protobuf:"bytes,1,opt,name=block_number,json=blockNumber,proto3" json:"block_number,omitempty"`
	Operator      ComparisonOperator     `protobuf:"varint,2,opt,name=operator,proto3,enum=loop.chain.common.ComparisonOperator" json:"operator,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Block) ProtoMessage() {}

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

func (x *Block) GetBlockNumber() string {
	if x != nil {
		return x.BlockNumber
	}
	return ""
}

func (x *Block) GetOperator() ComparisonOperator {
	if x != nil {
		return x.Operator
	}
	return ComparisonOperator_Eq
}

type Timestamp struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Timestamp     uint64                 `protobuf:"varint,1,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
	Operator      ComparisonOperator     `protobuf:"varint,2,opt,name=operator,proto3,enum=loop.chain.common.ComparisonOperator" json:"operator,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Timestamp) ProtoMessage() {}

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

func (x *Timestamp) GetTimestamp() uint64 {
	if x != nil {
		return x.Timestamp
	}
	return 0
}

func (x *Timestamp) GetOperator() ComparisonOperator {
	if x != nil {
		return x.Operator
	}
	return ComparisonOperator_Eq
}

type TxHash struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	TxHash        string                 `protobuf:"bytes,1,opt,name=tx_hash,json=txHash,proto3" json:"tx_hash,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*TxHash) ProtoMessage() {}

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

func (x *TxHash) GetTxHash() string {
	if x != nil {
		return x.TxHash
	}
	return ""
}

// Primitive defines the basic building blocks for filter conditions based around fundamental blockchain concepts.
type Primitive struct {
	state protoimpl.MessageState `protogen:"open.v1"`
	// Types that are valid to be assigned to Primitive:
	//
	//	*Primitive_Comparator
	//	*Primitive_Block
	//	*Primitive_Confidence
	//	*Primitive_Timestamp
	//	*Primitive_TxHash
	Primitive     isPrimitive_Primitive `protobuf_oneof:"primitive"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Primitive) ProtoMessage() {}

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

func (x *Primitive) GetPrimitive() isPrimitive_Primitive {
	if x != nil {
		return x.Primitive
	}
	return nil
}

func (x *Primitive) GetComparator() *Comparator {
	if x != nil {
		if x, ok := x.Primitive.(*Primitive_Comparator); ok {
			return x.Comparator
		}
	}
	return nil
}

func (x *Primitive) GetBlock() *Block {
	if x != nil {
		if x, ok := x.Primitive.(*Primitive_Block); ok {
			return x.Block
		}
	}
	return nil
}

func (x *Primitive) GetConfidence() Confidence {
	if x != nil {
		if x, ok := x.Primitive.(*Primitive_Confidence); ok {
			return x.Confidence
		}
	}
	return Confidence_Unconfirmed
}

func (x *Primitive) GetTimestamp() *Timestamp {
	if x != nil {
		if x, ok := x.Primitive.(*Primitive_Timestamp); ok {
			return x.Timestamp
		}
	}
	return nil
}

func (x *Primitive) GetTxHash() *TxHash {
	if x != nil {
		if x, ok := x.Primitive.(*Primitive_TxHash); ok {
			return x.TxHash
		}
	}
	return nil
}

type isPrimitive_Primitive interface {
	isPrimitive_Primitive()
}

type Primitive_Comparator struct {
	Comparator *Comparator `protobuf:"bytes,1,opt,name=comparator,proto3,oneof"`
}

type Primitive_Block struct {
	Block *Block `protobuf:"bytes,2,opt,name=block,proto3,oneof"`
}

type Primitive_Confidence struct {
	Confidence Confidence `protobuf:"varint,3,opt,name=confidence,proto3,enum=loop.chain.common.Confidence,oneof"`
}

type Primitive_Timestamp struct {
	Timestamp *Timestamp `protobuf:"bytes,4,opt,name=timestamp,proto3,oneof"`
}

type Primitive_TxHash struct {
	TxHash *TxHash `protobuf:"bytes,5,opt,name=tx_hash,json=txHash,proto3,oneof"`
}

func (*Primitive_Comparator) isPrimitive_Primitive() {}

func (*Primitive_Block) isPrimitive_Primitive() {}

func (*Primitive_Confidence) isPrimitive_Primitive() {}

func (*Primitive_Timestamp) isPrimitive_Primitive() {}

func (*Primitive_TxHash) isPrimitive_Primitive() {}

// Limit defines a structure for limiting the results of a query, including optional cursor-based pagination.
type Limit struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	Cursor        *string                `protobuf:"bytes,1,opt,name=cursor,proto3,oneof" json:"cursor,omitempty"`
	Direction     *CursorDirection       `protobuf:"varint,2,opt,name=direction,proto3,enum=loop.chain.common.CursorDirection,oneof" json:"direction,omitempty"`
	Count         uint64                 `protobuf:"varint,3,opt,name=count,proto3" json:"count,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*Limit) ProtoMessage() {}

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

func (x *Limit) GetCursor() string {
	if x != nil && x.Cursor != nil {
		return *x.Cursor
	}
	return ""
}

func (x *Limit) GetDirection() CursorDirection {
	if x != nil && x.Direction != nil {
		return *x.Direction
	}
	return CursorDirection_Preceding
}

func (x *Limit) GetCount() uint64 {
	if x != nil {
		return x.Count
	}
	return 0
}

type SortBy struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	SortType      SortType               `protobuf:"varint,1,opt,name=sort_type,json=sortType,proto3,enum=loop.chain.common.SortType" json:"sort_type,omitempty"`
	Direction     SortDirection          `protobuf:"varint,2,opt,name=direction,proto3,enum=loop.chain.common.SortDirection" json:"direction,omitempty"`
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*SortBy) ProtoMessage() {}

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

func (x *SortBy) GetSortType() SortType {
	if x != nil {
		return x.SortType
	}
	return SortType_SortTimestamp
}

func (x *SortBy) GetDirection() SortDirection {
	if x != nil {
		return x.Direction
	}
	return SortDirection_Asc
}

// LimitAndSort combines sorting criteria with pagination limits.
type LimitAndSort struct {
	state         protoimpl.MessageState `protogen:"open.v1"`
	SortBy        []*SortBy              `protobuf:"bytes,1,rep,name=sort_by,json=sortBy,proto3" json:"sort_by,omitempty"` // A list of sorting criteria.
	Limit         *Limit                 `protobuf:"bytes,2,opt,name=limit,proto3" json:"limit,omitempty"`                 // Pagination limit and direction.
	unknownFields protoimpl.UnknownFields
	sizeCache     protoimpl.SizeCache
}

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

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

func (*LimitAndSort) ProtoMessage() {}

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

func (x *LimitAndSort) GetSortBy() []*SortBy {
	if x != nil {
		return x.SortBy
	}
	return nil
}

func (x *LimitAndSort) GetLimit() *Limit {
	if x != nil {
		return x.Limit
	}
	return nil
}

var File_loop_chain_common_query_proto protoreflect.FileDescriptor

const file_loop_chain_common_query_proto_rawDesc = "" +
	"\n" +
	"\x1dloop/chain-common/query.proto\x12\x11loop.chain.common\x1a\x1ainternal/codec/codec.proto\"\xae\x01\n" +
	"\n" +
	"Expression\x12<\n" +
	"\tprimitive\x18\x01 \x01(\v2\x1c.loop.chain.common.PrimitiveH\x00R\tprimitive\x12U\n" +
	"\x12boolean_expression\x18\x02 \x01(\v2$.loop.chain.common.BooleanExpressionH\x00R\x11booleanExpressionB\v\n" +
	"\tevaluator\"\xa1\x01\n" +
	"\x11BooleanExpression\x12M\n" +
	"\x10boolean_operator\x18\x01 \x01(\x0e2\".loop.chain.common.BooleanOperatorR\x0fbooleanOperator\x12=\n" +
	"\n" +
	"expression\x18\x02 \x03(\v2\x1d.loop.chain.common.ExpressionR\n" +
	"expression\"8\n" +
	"\x03And\x121\n" +
	"\x04expr\x18\x01 \x03(\v2\x1d.loop.chain.common.ExpressionR\x04expr\"7\n" +
	"\x02Or\x121\n" +
	"\x04expr\x18\x01 \x03(\v2\x1d.loop.chain.common.ExpressionR\x04expr\"\x81\x01\n" +
	"\x0fValueComparator\x12+\n" +
	"\x05value\x18\x01 \x01(\v2\x15.codec.VersionedBytesR\x05value\x12A\n" +
	"\boperator\x18\x02 \x01(\x0e2%.loop.chain.common.ComparisonOperatorR\boperator\"q\n" +
	"\n" +
	"Comparator\x12\x12\n" +
	"\x04name\x18\x01 \x01(\tR\x04name\x12O\n" +
	"\x11value_comparators\x18\x02 \x03(\v2\".loop.chain.common.ValueComparatorR\x10valueComparators\"m\n" +
	"\x05Block\x12!\n" +
	"\fblock_number\x18\x01 \x01(\tR\vblockNumber\x12A\n" +
	"\boperator\x18\x02 \x01(\x0e2%.loop.chain.common.ComparisonOperatorR\boperator\"l\n" +
	"\tTimestamp\x12\x1c\n" +
	"\ttimestamp\x18\x01 \x01(\x04R\ttimestamp\x12A\n" +
	"\boperator\x18\x02 \x01(\x0e2%.loop.chain.common.ComparisonOperatorR\boperator\"!\n" +
	"\x06TxHash\x12\x17\n" +
	"\atx_hash\x18\x01 \x01(\tR\x06txHash\"\xc0\x02\n" +
	"\tPrimitive\x12?\n" +
	"\n" +
	"comparator\x18\x01 \x01(\v2\x1d.loop.chain.common.ComparatorH\x00R\n" +
	"comparator\x120\n" +
	"\x05block\x18\x02 \x01(\v2\x18.loop.chain.common.BlockH\x00R\x05block\x12?\n" +
	"\n" +
	"confidence\x18\x03 \x01(\x0e2\x1d.loop.chain.common.ConfidenceH\x00R\n" +
	"confidence\x12<\n" +
	"\ttimestamp\x18\x04 \x01(\v2\x1c.loop.chain.common.TimestampH\x00R\ttimestamp\x124\n" +
	"\atx_hash\x18\x05 \x01(\v2\x19.loop.chain.common.TxHashH\x00R\x06txHashB\v\n" +
	"\tprimitive\"\x9a\x01\n" +
	"\x05Limit\x12\x1b\n" +
	"\x06cursor\x18\x01 \x01(\tH\x00R\x06cursor\x88\x01\x01\x12E\n" +
	"\tdirection\x18\x02 \x01(\x0e2\".loop.chain.common.CursorDirectionH\x01R\tdirection\x88\x01\x01\x12\x14\n" +
	"\x05count\x18\x03 \x01(\x04R\x05countB\t\n" +
	"\a_cursorB\f\n" +
	"\n" +
	"_direction\"\x82\x01\n" +
	"\x06SortBy\x128\n" +
	"\tsort_type\x18\x01 \x01(\x0e2\x1b.loop.chain.common.SortTypeR\bsortType\x12>\n" +
	"\tdirection\x18\x02 \x01(\x0e2 .loop.chain.common.SortDirectionR\tdirection\"r\n" +
	"\fLimitAndSort\x122\n" +
	"\asort_by\x18\x01 \x03(\v2\x19.loop.chain.common.SortByR\x06sortBy\x12.\n" +
	"\x05limit\x18\x02 \x01(\v2\x18.loop.chain.common.LimitR\x05limit*G\n" +
	"\x12ComparisonOperator\x12\x06\n" +
	"\x02Eq\x10\x00\x12\a\n" +
	"\x03Neq\x10\x01\x12\x06\n" +
	"\x02Gt\x10\x02\x12\x06\n" +
	"\x02Lt\x10\x03\x12\a\n" +
	"\x03Gte\x10\x04\x12\a\n" +
	"\x03Lte\x10\x05*\"\n" +
	"\x0fBooleanOperator\x12\a\n" +
	"\x03AND\x10\x00\x12\x06\n" +
	"\x02OR\x10\x01*6\n" +
	"\n" +
	"Confidence\x12\x0f\n" +
	"\vUnconfirmed\x10\x00\x12\r\n" +
	"\tFinalized\x10\x01\x12\b\n" +
	"\x04Safe\x10\x02*/\n" +
	"\x0fCursorDirection\x12\r\n" +
	"\tPreceding\x10\x00\x12\r\n" +
	"\tFollowing\x10\x01*\"\n" +
	"\rSortDirection\x12\a\n" +
	"\x03Asc\x10\x00\x12\b\n" +
	"\x04Desc\x10\x01*>\n" +
	"\bSortType\x12\x11\n" +
	"\rSortTimestamp\x10\x00\x12\r\n" +
	"\tSortBlock\x10\x01\x12\x10\n" +
	"\fSortSequence\x10\x02BRZPgithub.com/smartcontractkit/chainlink-common/pkg/loop/chain-common;chaincommonpbb\x06proto3"

var (
	file_loop_chain_common_query_proto_rawDescOnce sync.Once
	file_loop_chain_common_query_proto_rawDescData []byte
)

func file_loop_chain_common_query_proto_rawDescGZIP() []byte {
	file_loop_chain_common_query_proto_rawDescOnce.Do(func() {
		file_loop_chain_common_query_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_loop_chain_common_query_proto_rawDesc), len(file_loop_chain_common_query_proto_rawDesc)))
	})
	return file_loop_chain_common_query_proto_rawDescData
}

var file_loop_chain_common_query_proto_enumTypes = make([]protoimpl.EnumInfo, 6)
var file_loop_chain_common_query_proto_msgTypes = make([]protoimpl.MessageInfo, 13)
var file_loop_chain_common_query_proto_goTypes = []any{
	(ComparisonOperator)(0),      // 0: loop.chain.common.ComparisonOperator
	(BooleanOperator)(0),         // 1: loop.chain.common.BooleanOperator
	(Confidence)(0),              // 2: loop.chain.common.Confidence
	(CursorDirection)(0),         // 3: loop.chain.common.CursorDirection
	(SortDirection)(0),           // 4: loop.chain.common.SortDirection
	(SortType)(0),                // 5: loop.chain.common.SortType
	(*Expression)(nil),           // 6: loop.chain.common.Expression
	(*BooleanExpression)(nil),    // 7: loop.chain.common.BooleanExpression
	(*And)(nil),                  // 8: loop.chain.common.And
	(*Or)(nil),                   // 9: loop.chain.common.Or
	(*ValueComparator)(nil),      // 10: loop.chain.common.ValueComparator
	(*Comparator)(nil),           // 11: loop.chain.common.Comparator
	(*Block)(nil),                // 12: loop.chain.common.Block
	(*Timestamp)(nil),            // 13: loop.chain.common.Timestamp
	(*TxHash)(nil),               // 14: loop.chain.common.TxHash
	(*Primitive)(nil),            // 15: loop.chain.common.Primitive
	(*Limit)(nil),                // 16: loop.chain.common.Limit
	(*SortBy)(nil),               // 17: loop.chain.common.SortBy
	(*LimitAndSort)(nil),         // 18: loop.chain.common.LimitAndSort
	(*codec.VersionedBytes)(nil), // 19: codec.VersionedBytes
}
var file_loop_chain_common_query_proto_depIdxs = []int32{
	15, // 0: loop.chain.common.Expression.primitive:type_name -> loop.chain.common.Primitive
	7,  // 1: loop.chain.common.Expression.boolean_expression:type_name -> loop.chain.common.BooleanExpression
	1,  // 2: loop.chain.common.BooleanExpression.boolean_operator:type_name -> loop.chain.common.BooleanOperator
	6,  // 3: loop.chain.common.BooleanExpression.expression:type_name -> loop.chain.common.Expression
	6,  // 4: loop.chain.common.And.expr:type_name -> loop.chain.common.Expression
	6,  // 5: loop.chain.common.Or.expr:type_name -> loop.chain.common.Expression
	19, // 6: loop.chain.common.ValueComparator.value:type_name -> codec.VersionedBytes
	0,  // 7: loop.chain.common.ValueComparator.operator:type_name -> loop.chain.common.ComparisonOperator
	10, // 8: loop.chain.common.Comparator.value_comparators:type_name -> loop.chain.common.ValueComparator
	0,  // 9: loop.chain.common.Block.operator:type_name -> loop.chain.common.ComparisonOperator
	0,  // 10: loop.chain.common.Timestamp.operator:type_name -> loop.chain.common.ComparisonOperator
	11, // 11: loop.chain.common.Primitive.comparator:type_name -> loop.chain.common.Comparator
	12, // 12: loop.chain.common.Primitive.block:type_name -> loop.chain.common.Block
	2,  // 13: loop.chain.common.Primitive.confidence:type_name -> loop.chain.common.Confidence
	13, // 14: loop.chain.common.Primitive.timestamp:type_name -> loop.chain.common.Timestamp
	14, // 15: loop.chain.common.Primitive.tx_hash:type_name -> loop.chain.common.TxHash
	3,  // 16: loop.chain.common.Limit.direction:type_name -> loop.chain.common.CursorDirection
	5,  // 17: loop.chain.common.SortBy.sort_type:type_name -> loop.chain.common.SortType
	4,  // 18: loop.chain.common.SortBy.direction:type_name -> loop.chain.common.SortDirection
	17, // 19: loop.chain.common.LimitAndSort.sort_by:type_name -> loop.chain.common.SortBy
	16, // 20: loop.chain.common.LimitAndSort.limit:type_name -> loop.chain.common.Limit
	21, // [21:21] is the sub-list for method output_type
	21, // [21:21] is the sub-list for method input_type
	21, // [21:21] is the sub-list for extension type_name
	21, // [21:21] is the sub-list for extension extendee
	0,  // [0:21] is the sub-list for field type_name
}

func init() { file_loop_chain_common_query_proto_init() }
func file_loop_chain_common_query_proto_init() {
	if File_loop_chain_common_query_proto != nil {
		return
	}
	file_loop_chain_common_query_proto_msgTypes[0].OneofWrappers = []any{
		(*Expression_Primitive)(nil),
		(*Expression_BooleanExpression)(nil),
	}
	file_loop_chain_common_query_proto_msgTypes[9].OneofWrappers = []any{
		(*Primitive_Comparator)(nil),
		(*Primitive_Block)(nil),
		(*Primitive_Confidence)(nil),
		(*Primitive_Timestamp)(nil),
		(*Primitive_TxHash)(nil),
	}
	file_loop_chain_common_query_proto_msgTypes[10].OneofWrappers = []any{}
	type x struct{}
	out := protoimpl.TypeBuilder{
		File: protoimpl.DescBuilder{
			GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
			RawDescriptor: unsafe.Slice(unsafe.StringData(file_loop_chain_common_query_proto_rawDesc), len(file_loop_chain_common_query_proto_rawDesc)),
			NumEnums:      6,
			NumMessages:   13,
			NumExtensions: 0,
			NumServices:   0,
		},
		GoTypes:           file_loop_chain_common_query_proto_goTypes,
		DependencyIndexes: file_loop_chain_common_query_proto_depIdxs,
		EnumInfos:         file_loop_chain_common_query_proto_enumTypes,
		MessageInfos:      file_loop_chain_common_query_proto_msgTypes,
	}.Build()
	File_loop_chain_common_query_proto = out.File
	file_loop_chain_common_query_proto_goTypes = nil
	file_loop_chain_common_query_proto_depIdxs = nil
}